diff options
Diffstat (limited to 'Master/tlpkg/tlperl/lib/POSIX.pod')
-rw-r--r-- | Master/tlpkg/tlperl/lib/POSIX.pod | 2218 |
1 files changed, 2218 insertions, 0 deletions
diff --git a/Master/tlpkg/tlperl/lib/POSIX.pod b/Master/tlpkg/tlperl/lib/POSIX.pod new file mode 100644 index 00000000000..64852e94b6b --- /dev/null +++ b/Master/tlpkg/tlperl/lib/POSIX.pod @@ -0,0 +1,2218 @@ +=head1 NAME + +POSIX - Perl interface to IEEE Std 1003.1 + +=head1 SYNOPSIS + + 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 + +=head1 DESCRIPTION + +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. + +I<Everything is exported by default> with the exception of any POSIX +functions with the same name as a built-in Perl function, such as +C<abs>, C<alarm>, C<rmdir>, C<write>, etc.., which will be exported +only if you ask for them explicitly. This is an unfortunate backwards +compatibility feature. You can stop the exporting by saying C<use +POSIX ()> and then use the fully qualified names (ie. C<POSIX::SEEK_END>). + +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 L<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. + +=head1 NOTE + +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. + +=head1 CAVEATS + +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. + +=head1 FUNCTIONS + +=over 8 + +=item _exit + +This is identical to the C function C<_exit()>. It exits the program +immediately which means among other things buffered I/O is B<not> flushed. + +Note that when using threads and in Linux this is B<not> a good way to +exit a thread because in Linux processes and threads are kind of the +same thing (Note: while this is the situation in early 2003 there are +projects under way to have threads with more POSIXly semantics in Linux). +If you want not to return from a thread, detach the thread. + +=item abort + +This is identical to the C function C<abort()>. It terminates the +process with a C<SIGABRT> signal unless caught by a signal handler or +if the handler does not return normally (it e.g. does a C<longjmp>). + +=item abs + +This is identical to Perl's builtin C<abs()> function, returning +the absolute value of its numerical argument. + +=item access + +Determines the accessibility of a file. + + if( POSIX::access( "/", &POSIX::R_OK ) ){ + print "have read permission\n"; + } + +Returns C<undef> on failure. Note: do not use C<access()> for +security purposes. Between the C<access()> call and the operation +you are preparing for the permissions might change: a classic +I<race condition>. + +=item acos + +This is identical to the C function C<acos()>, returning +the arcus cosine of its numerical argument. See also L<Math::Trig>. + +=item alarm + +This is identical to Perl's builtin C<alarm()> function, +either for arming or disarming the C<SIGARLM> timer. + +=item asctime + +This is identical to the C function C<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 C<$mon> is zero-based: January equals C<0>. The C<$year> is +1900-based: 2001 equals C<101>. C<$wday> and C<$yday> default to zero +(and are usually ignored anyway), and C<$isdst> defaults to -1. + +=item asin + +This is identical to the C function C<asin()>, returning +the arcus sine of its numerical argument. See also L<Math::Trig>. + +=item assert + +Unimplemented, but you can use L<perlfunc/die> and the L<Carp> module +to achieve similar things. + +=item atan + +This is identical to the C function C<atan()>, returning the +arcus tangent of its numerical argument. See also L<Math::Trig>. + +=item atan2 + +This is identical to Perl's builtin C<atan2()> function, returning +the arcus tangent defined by its two numerical arguments, the I<y> +coordinate and the I<x> coordinate. See also L<Math::Trig>. + +=item atexit + +atexit() is C-specific: use C<END {}> instead, see L<perlsub>. + +=item atof + +atof() is C-specific. Perl converts strings to numbers transparently. +If you need to force a scalar to a number, add a zero to it. + +=item atoi + +atoi() is C-specific. Perl converts strings to numbers transparently. +If you need to force a scalar to a number, add a zero to it. +If you need to have just the integer part, see L<perlfunc/int>. + +=item atol + +atol() is C-specific. Perl converts strings to numbers transparently. +If you need to force a scalar to a number, add a zero to it. +If you need to have just the integer part, see L<perlfunc/int>. + +=item bsearch + +bsearch() not supplied. For doing binary search on wordlists, +see L<Search::Dict>. + +=item calloc + +calloc() is C-specific. Perl does memory management transparently. + +=item ceil + +This is identical to the C function C<ceil()>, returning the smallest +integer value greater than or equal to the given numerical argument. + +=item chdir + +This is identical to Perl's builtin C<chdir()> function, allowing +one to change the working (default) directory, see L<perlfunc/chdir>. + +=item chmod + +This is identical to Perl's builtin C<chmod()> function, allowing +one to change file and directory permissions, see L<perlfunc/chmod>. + +=item chown + +This is identical to Perl's builtin C<chown()> function, allowing one +to change file and directory owners and groups, see L<perlfunc/chown>. + +=item clearerr + +Use the method C<IO::Handle::clearerr()> instead, to reset the error +state (if any) and EOF state (if any) of the given stream. + +=item clock + +This is identical to the C function C<clock()>, returning the +amount of spent processor time in microseconds. + +=item close + +Close the file. This uses file descriptors such as those obtained by calling +C<POSIX::open>. + + $fd = POSIX::open( "foo", &POSIX::O_RDONLY ); + POSIX::close( $fd ); + +Returns C<undef> on failure. + +See also L<perlfunc/close>. + +=item closedir + +This is identical to Perl's builtin C<closedir()> function for closing +a directory handle, see L<perlfunc/closedir>. + +=item cos + +This is identical to Perl's builtin C<cos()> function, for returning +the cosine of its numerical argument, see L<perlfunc/cos>. +See also L<Math::Trig>. + +=item cosh + +This is identical to the C function C<cosh()>, for returning +the hyperbolic cosine of its numeric argument. See also L<Math::Trig>. + +=item creat + +Create a new file. This returns a file descriptor like the ones returned by +C<POSIX::open>. Use C<POSIX::close> to close the file. + + $fd = POSIX::creat( "foo", 0611 ); + POSIX::close( $fd ); + +See also L<perlfunc/sysopen> and its C<O_CREAT> flag. + +=item ctermid + +Generates the path name for the controlling terminal. + + $path = POSIX::ctermid(); + +=item ctime + +This is identical to the C function C<ctime()> and equivalent +to C<asctime(localtime(...))>, see L</asctime> and L</localtime>. + +=item cuserid + +Get the login name of the owner of the current process. + + $name = POSIX::cuserid(); + +=item difftime + +This is identical to the C function C<difftime()>, for returning +the time difference (in seconds) between two times (as returned +by C<time()>), see L</time>. + +=item div + +div() is C-specific, use L<perlfunc/int> on the usual C</> division and +the modulus C<%>. + +=item dup + +This is similar to the C function C<dup()>, for duplicating a file +descriptor. + +This uses file descriptors such as those obtained by calling +C<POSIX::open>. + +Returns C<undef> on failure. + +=item dup2 + +This is similar to the C function C<dup2()>, for duplicating a file +descriptor to an another known file descriptor. + +This uses file descriptors such as those obtained by calling +C<POSIX::open>. + +Returns C<undef> on failure. + +=item errno + +Returns the value of errno. + + $errno = POSIX::errno(); + +This identical to the numerical values of the C<$!>, see L<perlvar/$ERRNO>. + +=item execl + +execl() is C-specific, see L<perlfunc/exec>. + +=item execle + +execle() is C-specific, see L<perlfunc/exec>. + +=item execlp + +execlp() is C-specific, see L<perlfunc/exec>. + +=item execv + +execv() is C-specific, see L<perlfunc/exec>. + +=item execve + +execve() is C-specific, see L<perlfunc/exec>. + +=item execvp + +execvp() is C-specific, see L<perlfunc/exec>. + +=item exit + +This is identical to Perl's builtin C<exit()> function for exiting the +program, see L<perlfunc/exit>. + +=item exp + +This is identical to Perl's builtin C<exp()> function for +returning the exponent (I<e>-based) of the numerical argument, +see L<perlfunc/exp>. + +=item fabs + +This is identical to Perl's builtin C<abs()> function for returning +the absolute value of the numerical argument, see L<perlfunc/abs>. + +=item fclose + +Use method C<IO::Handle::close()> instead, or see L<perlfunc/close>. + +=item fcntl + +This is identical to Perl's builtin C<fcntl()> function, +see L<perlfunc/fcntl>. + +=item fdopen + +Use method C<IO::Handle::new_from_fd()> instead, or see L<perlfunc/open>. + +=item feof + +Use method C<IO::Handle::eof()> instead, or see L<perlfunc/eof>. + +=item ferror + +Use method C<IO::Handle::error()> instead. + +=item fflush + +Use method C<IO::Handle::flush()> instead. +See also L<perlvar/$OUTPUT_AUTOFLUSH>. + +=item fgetc + +Use method C<IO::Handle::getc()> instead, or see L<perlfunc/read>. + +=item fgetpos + +Use method C<IO::Seekable::getpos()> instead, or see L<L/seek>. + +=item fgets + +Use method C<IO::Handle::gets()> instead. Similar to E<lt>E<gt>, also known +as L<perlfunc/readline>. + +=item fileno + +Use method C<IO::Handle::fileno()> instead, or see L<perlfunc/fileno>. + +=item floor + +This is identical to the C function C<floor()>, returning the largest +integer value less than or equal to the numerical argument. + +=item fmod + +This is identical to the C function C<fmod()>. + + $r = fmod($x, $y); + +It returns the remainder C<$r = $x - $n*$y>, where C<$n = trunc($x/$y)>. +The C<$r> has the same sign as C<$x> and magnitude (absolute value) +less than the magnitude of C<$y>. + +=item fopen + +Use method C<IO::File::open()> instead, or see L<perlfunc/open>. + +=item fork + +This is identical to Perl's builtin C<fork()> function +for duplicating the current process, see L<perlfunc/fork> +and L<perlfork> if you are in Windows. + +=item fpathconf + +Retrieves the value of a configurable limit on a file or directory. This +uses file descriptors such as those obtained by calling C<POSIX::open>. + +The following will determine the maximum length of the longest allowable +pathname on the filesystem which holds C</var/foo>. + + $fd = POSIX::open( "/var/foo", &POSIX::O_RDONLY ); + $path_max = POSIX::fpathconf( $fd, &POSIX::_PC_PATH_MAX ); + +Returns C<undef> on failure. + +=item fprintf + +fprintf() is C-specific, see L<perlfunc/printf> instead. + +=item fputc + +fputc() is C-specific, see L<perlfunc/print> instead. + +=item fputs + +fputs() is C-specific, see L<perlfunc/print> instead. + +=item fread + +fread() is C-specific, see L<perlfunc/read> instead. + +=item free + +free() is C-specific. Perl does memory management transparently. + +=item freopen + +freopen() is C-specific, see L<perlfunc/open> instead. + +=item frexp + +Return the mantissa and exponent of a floating-point number. + + ($mantissa, $exponent) = POSIX::frexp( 1.234e56 ); + +=item fscanf + +fscanf() is C-specific, use E<lt>E<gt> and regular expressions instead. + +=item fseek + +Use method C<IO::Seekable::seek()> instead, or see L<perlfunc/seek>. + +=item fsetpos + +Use method C<IO::Seekable::setpos()> instead, or seek L<perlfunc/seek>. + +=item fstat + +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 ); + +=item fsync + +Use method C<IO::Handle::sync()> instead. + +=item ftell + +Use method C<IO::Seekable::tell()> instead, or see L<perlfunc/tell>. + +=item fwrite + +fwrite() is C-specific, see L<perlfunc/print> instead. + +=item getc + +This is identical to Perl's builtin C<getc()> function, +see L<perlfunc/getc>. + +=item getchar + +Returns one character from STDIN. Identical to Perl's C<getc()>, +see L<perlfunc/getc>. + +=item getcwd + +Returns the name of the current working directory. +See also L<Cwd>. + +=item getegid + +Returns the effective group identifier. Similar to Perl' s builtin +variable C<$(>, see L<perlvar/$EGID>. + +=item getenv + +Returns the value of the specified environment variable. +The same information is available through the C<%ENV> array. + +=item geteuid + +Returns the effective user identifier. Identical to Perl's builtin C<$E<gt>> +variable, see L<perlvar/$EUID>. + +=item getgid + +Returns the user's real group identifier. Similar to Perl's builtin +variable C<$)>, see L<perlvar/$GID>. + +=item getgrgid + +This is identical to Perl's builtin C<getgrgid()> function for +returning group entries by group identifiers, see +L<perlfunc/getgrgid>. + +=item getgrnam + +This is identical to Perl's builtin C<getgrnam()> function for +returning group entries by group names, see L<perlfunc/getgrnam>. + +=item getgroups + +Returns the ids of the user's supplementary groups. Similar to Perl's +builtin variable C<$)>, see L<perlvar/$GID>. + +=item getlogin + +This is identical to Perl's builtin C<getlogin()> function for +returning the user name associated with the current session, see +L<perlfunc/getlogin>. + +=item getpgrp + +This is identical to Perl's builtin C<getpgrp()> function for +returning the process group identifier of the current process, see +L<perlfunc/getpgrp>. + +=item getpid + +Returns the process identifier. Identical to Perl's builtin +variable C<$$>, see L<perlvar/$PID>. + +=item getppid + +This is identical to Perl's builtin C<getppid()> function for +returning the process identifier of the parent process of the current +process , see L<perlfunc/getppid>. + +=item getpwnam + +This is identical to Perl's builtin C<getpwnam()> function for +returning user entries by user names, see L<perlfunc/getpwnam>. + +=item getpwuid + +This is identical to Perl's builtin C<getpwuid()> function for +returning user entries by user identifiers, see L<perlfunc/getpwuid>. + +=item gets + +Returns one line from C<STDIN>, similar to E<lt>E<gt>, also known +as the C<readline()> function, see L<perlfunc/readline>. + +B<NOTE>: if you have C programs that still use C<gets()>, be very +afraid. The C<gets()> function is a source of endless grief because +it has no buffer overrun checks. It should B<never> be used. The +C<fgets()> function should be preferred instead. + +=item getuid + +Returns the user's identifier. Identical to Perl's builtin C<$E<lt>> variable, +see L<perlvar/$UID>. + +=item gmtime + +This is identical to Perl's builtin C<gmtime()> function for +converting seconds since the epoch to a date in Greenwich Mean Time, +see L<perlfunc/gmtime>. + +=item isalnum + +This is identical to the C function, except that it can apply to a +single character or to a whole string. Note that locale settings may +affect what characters are considered C<isalnum>. Does not work on +Unicode characters code point 256 or higher. Consider using regular +expressions and the C</[[:alnum:]]/> construct instead, or possibly +the C</\w/> construct. + +=item isalpha + +This is identical to the C function, except that it can apply to +a single character or to a whole string. Note that locale settings +may affect what characters are considered C<isalpha>. Does not work +on Unicode characters code point 256 or higher. Consider using regular +expressions and the C</[[:alpha:]]/> construct instead. + +=item isatty + +Returns a boolean indicating whether the specified filehandle is connected +to a tty. Similar to the C<-t> operator, see L<perlfunc/-X>. + +=item iscntrl + +This is identical to the C function, except that it can apply to +a single character or to a whole string. Note that locale settings +may affect what characters are considered C<iscntrl>. Does not work +on Unicode characters code point 256 or higher. Consider using regular +expressions and the C</[[:cntrl:]]/> construct instead. + +=item isdigit + +This is identical to the C function, except that it can apply to +a single character or to a whole string. Note that locale settings +may affect what characters are considered C<isdigit> (unlikely, but +still possible). Does not work on Unicode characters code point 256 +or higher. Consider using regular expressions and the C</[[:digit:]]/> +construct instead, or the C</\d/> construct. + +=item isgraph + +This is identical to the C function, except that it can apply to +a single character or to a whole string. Note that locale settings +may affect what characters are considered C<isgraph>. Does not work +on Unicode characters code point 256 or higher. Consider using regular +expressions and the C</[[:graph:]]/> construct instead. + +=item islower + +This is identical to the C function, except that it can apply to +a single character or to a whole string. Note that locale settings +may affect what characters are considered C<islower>. Does not work +on Unicode characters code point 256 or higher. Consider using regular +expressions and the C</[[:lower:]]/> construct instead. Do B<not> use +C</[a-z]/>. + +=item isprint + +This is identical to the C function, except that it can apply to +a single character or to a whole string. Note that locale settings +may affect what characters are considered C<isprint>. Does not work +on Unicode characters code point 256 or higher. Consider using regular +expressions and the C</[[:print:]]/> construct instead. + +=item ispunct + +This is identical to the C function, except that it can apply to +a single character or to a whole string. Note that locale settings +may affect what characters are considered C<ispunct>. Does not work +on Unicode characters code point 256 or higher. Consider using regular +expressions and the C</[[:punct:]]/> construct instead. + +=item isspace + +This is identical to the C function, except that it can apply to +a single character or to a whole string. Note that locale settings +may affect what characters are considered C<isspace>. Does not work +on Unicode characters code point 256 or higher. Consider using regular +expressions and the C</[[:space:]]/> construct instead, or the C</\s/> +construct. (Note that C</\s/> and C</[[:space:]]/> are slightly +different in that C</[[:space:]]/> can normally match a vertical tab, +while C</\s/> does not.) + +=item isupper + +This is identical to the C function, except that it can apply to +a single character or to a whole string. Note that locale settings +may affect what characters are considered C<isupper>. Does not work +on Unicode characters code point 256 or higher. Consider using regular +expressions and the C</[[:upper:]]/> construct instead. Do B<not> use +C</[A-Z]/>. + +=item isxdigit + +This is identical to the C function, except that it can apply to a single +character or to a whole string. Note that locale settings may affect what +characters are considered C<isxdigit> (unlikely, but still possible). +Does not work on Unicode characters code point 256 or higher. +Consider using regular expressions and the C</[[:xdigit:]]/> +construct instead, or simply C</[0-9a-f]/i>. + +=item kill + +This is identical to Perl's builtin C<kill()> function for sending +signals to processes (often to terminate them), see L<perlfunc/kill>. + +=item labs + +(For returning absolute values of long integers.) +labs() is C-specific, see L<perlfunc/abs> instead. + +=item lchown + +This is identical to the C function, except the order of arguments is +consistent with Perl's builtin C<chown()> with the added restriction +of only one path, not an list of paths. Does the same thing as the +C<chown()> function but changes the owner of a symbolic link instead +of the file the symbolic link points to. + +=item ldexp + +This is identical to the C function C<ldexp()> +for multiplying floating point numbers with powers of two. + + $x_quadrupled = POSIX::ldexp($x, 2); + +=item ldiv + +(For computing dividends of long integers.) +ldiv() is C-specific, use C</> and C<int()> instead. + +=item link + +This is identical to Perl's builtin C<link()> function +for creating hard links into files, see L<perlfunc/link>. + +=item localeconv + +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 B<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"; + +=item localtime + +This is identical to Perl's builtin C<localtime()> function for +converting seconds since the epoch to a date see L<perlfunc/localtime>. + +=item log + +This is identical to Perl's builtin C<log()> function, +returning the natural (I<e>-based) logarithm of the numerical argument, +see L<perlfunc/log>. + +=item log10 + +This is identical to the C function C<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 } + +=item longjmp + +longjmp() is C-specific: use L<perlfunc/die> instead. + +=item lseek + +Move the file's read/write position. 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 ); + +Returns C<undef> on failure. + +=item malloc + +malloc() is C-specific. Perl does memory management transparently. + +=item mblen + +This is identical to the C function C<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. + +=item mbstowcs + +This is identical to the C function C<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. + +=item mbtowc + +This is identical to the C function C<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. + +=item memchr + +memchr() is C-specific, see L<perlfunc/index> instead. + +=item memcmp + +memcmp() is C-specific, use C<eq> instead, see L<perlop>. + +=item memcpy + +memcpy() is C-specific, use C<=>, see L<perlop>, or see L<perlfunc/substr>. + +=item memmove + +memmove() is C-specific, use C<=>, see L<perlop>, or see L<perlfunc/substr>. + +=item memset + +memset() is C-specific, use C<x> instead, see L<perlop>. + +=item mkdir + +This is identical to Perl's builtin C<mkdir()> function +for creating directories, see L<perlfunc/mkdir>. + +=item mkfifo + +This is similar to the C function C<mkfifo()> for creating +FIFO special files. + + if (mkfifo($path, $mode)) { .... + +Returns C<undef> on failure. The C<$mode> is similar to the +mode of C<mkdir()>, see L<perlfunc/mkdir>, though for C<mkfifo> +you B<must> specify the C<$mode>. + +=item mktime + +Convert date/time info to a calendar time. + +Synopsis: + + mktime(sec, min, hour, mday, mon, year, wday = 0, yday = 0, isdst = -1) + +The month (C<mon>), weekday (C<wday>), and yearday (C<yday>) begin at zero. +I.e. January is 0, not 1; Sunday is 0, not 1; January 1st is 0, not 1. The +year (C<year>) is given in years since 1900. I.e. The year 1995 is 95; the +year 2001 is 101. Consult your system's C<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 C<undef> on failure. + +=item modf + +Return the integral and fractional parts of a floating-point number. + + ($fractional, $integral) = POSIX::modf( 3.14 ); + +=item nice + +This is similar to the C function C<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 C<undef> on failure. + +=item offsetof + +offsetof() is C-specific, you probably want to see L<perlfunc/pack> instead. + +=item open + +Open a file for reading for writing. This returns file descriptors, not +Perl filehandles. Use C<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 C<undef> on failure. + +See also L<perlfunc/sysopen>. + +=item opendir + +Open a directory for reading. + + $dir = POSIX::opendir( "/var" ); + @files = POSIX::readdir( $dir ); + POSIX::closedir( $dir ); + +Returns C<undef> on failure. + +=item 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 C</var>. + + $path_max = POSIX::pathconf( "/var", &POSIX::_PC_PATH_MAX ); + +Returns C<undef> on failure. + +=item pause + +This is similar to the C function C<pause()>, which suspends +the execution of the current process until a signal is received. + +Returns C<undef> on failure. + +=item perror + +This is identical to the C function C<perror()>, which outputs to the +standard error stream the specified message followed by ": " and the +current error string. Use the C<warn()> function and the C<$!> +variable instead, see L<perlfunc/warn> and L<perlvar/$ERRNO>. + +=item pipe + +Create an interprocess channel. This returns file descriptors like those +returned by C<POSIX::open>. + + my ($read, $write) = POSIX::pipe(); + POSIX::write( $write, "hello", 5 ); + POSIX::read( $read, $buf, 5 ); + +See also L<perlfunc/pipe>. + +=item pow + +Computes C<$x> raised to the power C<$exponent>. + + $ret = POSIX::pow( $x, $exponent ); + +You can also use the C<**> operator, see L<perlop>. + +=item printf + +Formats and prints the specified arguments to STDOUT. +See also L<perlfunc/printf>. + +=item putc + +putc() is C-specific, see L<perlfunc/print> instead. + +=item putchar + +putchar() is C-specific, see L<perlfunc/print> instead. + +=item puts + +puts() is C-specific, see L<perlfunc/print> instead. + +=item qsort + +qsort() is C-specific, see L<perlfunc/sort> instead. + +=item raise + +Sends the specified signal to the current process. +See also L<perlfunc/kill> and the C<$$> in L<perlvar/$PID>. + +=item rand + +C<rand()> is non-portable, see L<perlfunc/rand> instead. + +=item read + +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 ); + +Returns C<undef> on failure. + +See also L<perlfunc/sysread>. + +=item readdir + +This is identical to Perl's builtin C<readdir()> function +for reading directory entries, see L<perlfunc/readdir>. + +=item realloc + +realloc() is C-specific. Perl does memory management transparently. + +=item remove + +This is identical to Perl's builtin C<unlink()> function +for removing files, see L<perlfunc/unlink>. + +=item rename + +This is identical to Perl's builtin C<rename()> function +for renaming files, see L<perlfunc/rename>. + +=item rewind + +Seeks to the beginning of the file. + +=item rewinddir + +This is identical to Perl's builtin C<rewinddir()> function for +rewinding directory entry streams, see L<perlfunc/rewinddir>. + +=item rmdir + +This is identical to Perl's builtin C<rmdir()> function +for removing (empty) directories, see L<perlfunc/rmdir>. + +=item scanf + +scanf() is C-specific, use E<lt>E<gt> and regular expressions instead, +see L<perlre>. + +=item setgid + +Sets the real group identifier and the effective group identifier for +this process. Similar to assigning a value to the Perl's builtin +C<$)> variable, see L<perlvar/$EGID>, 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. + +=item setjmp + +C<setjmp()> is C-specific: use C<eval {}> instead, +see L<perlfunc/eval>. + +=item setlocale + +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<"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 C<"">). +Please see your systems C<setlocale(3)> documentation for the locale +environment variables' meaning or consult L<perllocale>. + + $loc = setlocale( LC_CTYPE, "" ); + +The following will set the LC_COLLATE behaviour to Argentinian +Spanish. B<NOTE>: The naming and availability of locales depends on +your operating system. Please consult L<perllocale> for how to find +out which locales are available in your system. + + $loc = setlocale( LC_COLLATE, "es_AR.ISO8859-1" ); + +=item setpgid + +This is similar to the C function C<setpgid()> for +setting the process group identifier of the current process. + +Returns C<undef> on failure. + +=item setsid + +This is identical to the C function C<setsid()> for +setting the session identifier of the current process. + +=item setuid + +Sets the real user identifier and the effective user identifier for +this process. Similar to assigning a value to the Perl's builtin +C<$E<lt>> variable, see L<perlvar/$UID>, except that the latter +will change only the real user identifier. + +=item sigaction + +Detailed signal management. This uses C<POSIX::SigAction> objects for +the C<action> and C<oldaction> arguments (the oldaction can also be +just a hash reference). Consult your system's C<sigaction> manpage +for details, see also C<POSIX::SigRt>. + +Synopsis: + + sigaction(signal, action, oldaction = 0) + +Returns C<undef> on failure. The C<signal> must be a number (like +SIGHUP), not a string (like "SIGHUP"), though Perl does try hard +to understand you. + +If you use the SA_SIGINFO flag, the signal handler will in addition to +the first argument, the signal name, also receive a second argument, a +hash reference, inside which are the following keys with the following +semantics, as defined by POSIX/SUSv3: + + signo the signal number + errno the error number + code if this is zero or less, the signal was sent by + a user process and the uid and pid make sense, + otherwise the signal was sent by the kernel + +The following are also defined by POSIX/SUSv3, but unfortunately +not very widely implemented: + + pid the process id generating the signal + uid the uid of the process id generating the signal + status exit value or signal for SIGCHLD + band band event for SIGPOLL + +A third argument is also passed to the handler, which contains a copy +of the raw binary contents of the siginfo structure: if a system has +some non-POSIX fields, this third argument is where to unpack() them +from. + +Note that not all siginfo values make sense simultaneously (some are +valid only for certain signals, for example), and not all values make +sense from Perl perspective, you should to consult your system's +C<sigaction> and possibly also C<siginfo> documentation. + +=item siglongjmp + +siglongjmp() is C-specific: use L<perlfunc/die> instead. + +=item sigpending + +Examine signals that are blocked and pending. This uses C<POSIX::SigSet> +objects for the C<sigset> argument. Consult your system's C<sigpending> +manpage for details. + +Synopsis: + + sigpending(sigset) + +Returns C<undef> on failure. + +=item sigprocmask + +Change and/or examine calling process's signal mask. This uses +C<POSIX::SigSet> objects for the C<sigset> and C<oldsigset> arguments. +Consult your system's C<sigprocmask> manpage for details. + +Synopsis: + + sigprocmask(how, sigset, oldsigset = 0) + +Returns C<undef> on failure. + +=item sigsetjmp + +C<sigsetjmp()> is C-specific: use C<eval {}> instead, +see L<perlfunc/eval>. + +=item sigsuspend + +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. + +Synopsis: + + sigsuspend(signal_mask) + +Returns C<undef> on failure. + +=item sin + +This is identical to Perl's builtin C<sin()> function +for returning the sine of the numerical argument, +see L<perlfunc/sin>. See also L<Math::Trig>. + +=item sinh + +This is identical to the C function C<sinh()> +for returning the hyperbolic sine of the numerical argument. +See also L<Math::Trig>. + +=item sleep + +This is functionally identical to Perl's builtin C<sleep()> function +for suspending the execution of the current for process for certain +number of seconds, see L<perlfunc/sleep>. There is one significant +difference, however: C<POSIX::sleep()> returns the number of +B<unslept> seconds, while the C<CORE::sleep()> returns the +number of slept seconds. + +=item sprintf + +This is similar to Perl's builtin C<sprintf()> function +for returning a string that has the arguments formatted as requested, +see L<perlfunc/sprintf>. + +=item sqrt + +This is identical to Perl's builtin C<sqrt()> function. +for returning the square root of the numerical argument, +see L<perlfunc/sqrt>. + +=item srand + +Give a seed the pseudorandom number generator, see L<perlfunc/srand>. + +=item sscanf + +sscanf() is C-specific, use regular expressions instead, +see L<perlre>. + +=item stat + +This is identical to Perl's builtin C<stat()> function +for returning information about files and directories. + +=item strcat + +strcat() is C-specific, use C<.=> instead, see L<perlop>. + +=item strchr + +strchr() is C-specific, see L<perlfunc/index> instead. + +=item strcmp + +strcmp() is C-specific, use C<eq> or C<cmp> instead, see L<perlop>. + +=item strcoll + +This is identical to the C function C<strcoll()> +for collating (comparing) strings transformed using +the C<strxfrm()> function. Not really needed since +Perl can do this transparently, see L<perllocale>. + +=item strcpy + +strcpy() is C-specific, use C<=> instead, see L<perlop>. + +=item strcspn + +strcspn() is C-specific, use regular expressions instead, +see L<perlre>. + +=item strerror + +Returns the error string for the specified errno. +Identical to the string form of the C<$!>, see L<perlvar/$ERRNO>. + +=item strftime + +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 (C<mon>), weekday (C<wday>), and yearday (C<yday>) begin at zero. +I.e. January is 0, not 1; Sunday is 0, not 1; January 1st is 0, not 1. The +year (C<year>) is given in years since 1900. I.e., the year 1995 is 95; the +year 2001 is 101. Consult your system's C<strftime()> manpage for details +about these and the other arguments. + +If you want your code to be portable, your format (C<fmt>) argument +should use only the conversion specifiers defined by the ANSI C +standard (C89, to play safe). These are C<aAbBcdHIjmMpSUwWxXyYZ%>. +But even then, the B<results> of some of the conversion specifiers are +non-portable. For example, the specifiers C<aAbBcpZ> change according +to the locale settings of the user, and both how to set locales (the +locale names) and what output to expect are non-standard. +The specifier C<c> changes according to the timezone settings of the +user and the timezone computation rules of the operating system. +The C<Z> specifier is notoriously unportable since the names of +timezones are non-standard. Sticking to the numeric specifiers is the +safest route. + +The given arguments are made consistent as though by calling +C<mktime()> before calling your system's C<strftime()> function, +except that the C<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"; + +=item strlen + +strlen() is C-specific, use C<length()> instead, see L<perlfunc/length>. + +=item strncat + +strncat() is C-specific, use C<.=> instead, see L<perlop>. + +=item strncmp + +strncmp() is C-specific, use C<eq> instead, see L<perlop>. + +=item strncpy + +strncpy() is C-specific, use C<=> instead, see L<perlop>. + +=item strpbrk + +strpbrk() is C-specific, use regular expressions instead, +see L<perlre>. + +=item strrchr + +strrchr() is C-specific, see L<perlfunc/rindex> instead. + +=item strspn + +strspn() is C-specific, use regular expressions instead, +see L<perlre>. + +=item strstr + +This is identical to Perl's builtin C<index()> function, +see L<perlfunc/index>. + +=item strtod + +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 I<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. + +=item strtok + +strtok() is C-specific, use regular expressions instead, see +L<perlre>, or L<perlfunc/split>. + +=item strtol + +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 I<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. + +=item strtoul + +String to unsigned (long) integer translation. strtoul() is identical +to strtol() except that strtoul() only parses unsigned integers. See +L</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. + +=item strxfrm + +String transformation. Returns the transformed string. + + $dst = POSIX::strxfrm( $src ); + +Used in conjunction with the C<strcoll()> function, see L</strcoll>. + +Not really needed since Perl can do this transparently, see +L<perllocale>. + +=item sysconf + +Retrieves values of system configurable variables. + +The following will get the machine's clock speed. + + $clock_ticks = POSIX::sysconf( &POSIX::_SC_CLK_TCK ); + +Returns C<undef> on failure. + +=item system + +This is identical to Perl's builtin C<system()> function, see +L<perlfunc/system>. + +=item tan + +This is identical to the C function C<tan()>, returning the +tangent of the numerical argument. See also L<Math::Trig>. + +=item tanh + +This is identical to the C function C<tanh()>, returning the +hyperbolic tangent of the numerical argument. See also L<Math::Trig>. + +=item tcdrain + +This is similar to the C function C<tcdrain()> for draining +the output queue of its argument stream. + +Returns C<undef> on failure. + +=item tcflow + +This is similar to the C function C<tcflow()> for controlling +the flow of its argument stream. + +Returns C<undef> on failure. + +=item tcflush + +This is similar to the C function C<tcflush()> for flushing +the I/O buffers of its argument stream. + +Returns C<undef> on failure. + +=item tcgetpgrp + +This is identical to the C function C<tcgetpgrp()> for returning the +process group identifier of the foreground process group of the controlling +terminal. + +=item tcsendbreak + +This is similar to the C function C<tcsendbreak()> for sending +a break on its argument stream. + +Returns C<undef> on failure. + +=item tcsetpgrp + +This is similar to the C function C<tcsetpgrp()> for setting the +process group identifier of the foreground process group of the controlling +terminal. + +Returns C<undef> on failure. + +=item time + +This is identical to Perl's builtin C<time()> function +for returning the number of seconds since the epoch +(whatever it is for the system), see L<perlfunc/time>. + +=item 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 C<times()> function returns four values, measured in +seconds. + +=item tmpfile + +Use method C<IO::File::new_tmpfile()> instead, or see L<File::Temp>. + +=item tmpnam + +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 L<File::Temp>. + +=item tolower + +This is identical to the C function, except that it can apply to a single +character or to a whole string. Consider using the C<lc()> function, +see L<perlfunc/lc>, or the equivalent C<\L> operator inside doublequotish +strings. + +=item toupper + +This is identical to the C function, except that it can apply to a single +character or to a whole string. Consider using the C<uc()> function, +see L<perlfunc/uc>, or the equivalent C<\U> operator inside doublequotish +strings. + +=item ttyname + +This is identical to the C function C<ttyname()> for returning the +name of the current terminal. + +=item tzname + +Retrieves the time conversion information from the C<tzname> variable. + + POSIX::tzset(); + ($std, $dst) = POSIX::tzname(); + +=item tzset + +This is identical to the C function C<tzset()> for setting +the current timezone based on the environment variable C<TZ>, +to be used by C<ctime()>, C<localtime()>, C<mktime()>, and C<strftime()> +functions. + +=item umask + +This is identical to Perl's builtin C<umask()> function +for setting (and querying) the file creation permission mask, +see L<perlfunc/umask>. + +=item uname + +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 C<$sysname> might be the name of the operating system, +the C<$nodename> might be the name of the host, the C<$release> +might be the (major) release number of the operating system, +the C<$version> might be the (minor) release number of the +operating system, and the C<$machine> might be a hardware identifier. +Maybe. + +=item ungetc + +Use method C<IO::Handle::ungetc()> instead. + +=item unlink + +This is identical to Perl's builtin C<unlink()> function +for removing files, see L<perlfunc/unlink>. + +=item utime + +This is identical to Perl's builtin C<utime()> function +for changing the time stamps of files and directories, +see L<perlfunc/utime>. + +=item vfprintf + +vfprintf() is C-specific, see L<perlfunc/printf> instead. + +=item vprintf + +vprintf() is C-specific, see L<perlfunc/printf> instead. + +=item vsprintf + +vsprintf() is C-specific, see L<perlfunc/sprintf> instead. + +=item wait + +This is identical to Perl's builtin C<wait()> function, +see L<perlfunc/wait>. + +=item waitpid + +Wait for a child process to change state. This is identical to Perl's +builtin C<waitpid()> function, see L<perlfunc/waitpid>. + + $pid = POSIX::waitpid( -1, POSIX::WNOHANG ); + print "status = ", ($? / 256), "\n"; + +=item wcstombs + +This is identical to the C function C<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. + +=item wctomb + +This is identical to the C function C<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. + +=item write + +Write to a file. This uses file descriptors such as those obtained by +calling C<POSIX::open>. + + $fd = POSIX::open( "foo", &POSIX::O_WRONLY ); + $buf = "hello"; + $bytes = POSIX::write( $fd, $buf, 5 ); + +Returns C<undef> on failure. + +See also L<perlfunc/syswrite>. + +=back + +=head1 CLASSES + +=head2 POSIX::SigAction + +=over 8 + +=item new + +Creates a new C<POSIX::SigAction> object which corresponds to the C +C<struct sigaction>. This object will be destroyed automatically when +it is no longer needed. The first parameter is the handler, a sub +reference. The second parameter is a C<POSIX::SigSet> object, it +defaults to the empty set. The third parameter contains the +C<sa_flags>, it defaults to 0. + + $sigset = POSIX::SigSet->new(SIGINT, SIGQUIT); + $sigaction = POSIX::SigAction->new( \&handler, $sigset, &POSIX::SA_NOCLDSTOP ); + +This C<POSIX::SigAction> object is intended for use with the C<POSIX::sigaction()> +function. + +=back + +=over 8 + +=item handler + +=item mask + +=item flags + +accessor functions to get/set the values of a SigAction object. + + $sigset = $sigaction->mask; + $sigaction->flags(&POSIX::SA_RESTART); + +=item safe + +accessor function for the "safe signals" flag of a SigAction object; see +L<perlipc> for general information on safe (a.k.a. "deferred") signals. If +you wish to handle a signal safely, use this accessor to set the "safe" flag +in the C<POSIX::SigAction> object: + + $sigaction->safe(1); + +You may also examine the "safe" flag on the output action object which is +filled in when given as the third parameter to C<POSIX::sigaction()>: + + sigaction(SIGINT, $new_action, $old_action); + if ($old_action->safe) { + # previous SIGINT handler used safe signals + } + +=back + +=head2 POSIX::SigRt + +=over 8 + +=item %SIGRT + +A hash of the POSIX realtime signal handlers. It is an extension of +the standard %SIG, the $POSIX::SIGRT{SIGRTMIN} is roughly equivalent +to $SIG{SIGRTMIN}, but the right POSIX moves (see below) are made with +the POSIX::SigSet and POSIX::sigaction instead of accessing the %SIG. + +You can set the %POSIX::SIGRT elements to set the POSIX realtime +signal handlers, use C<delete> and C<exists> on the elements, and use +C<scalar> on the C<%POSIX::SIGRT> to find out how many POSIX realtime +signals there are available (SIGRTMAX - SIGRTMIN + 1, the SIGRTMAX is +a valid POSIX realtime signal). + +Setting the %SIGRT elements is equivalent to calling this: + + sub new { + my ($rtsig, $handler, $flags) = @_; + my $sigset = POSIX::SigSet($rtsig); + my $sigact = POSIX::SigAction->new($handler, $sigset, $flags); + sigaction($rtsig, $sigact); + } + +The flags default to zero, if you want something different you can +either use C<local> on $POSIX::SigRt::SIGACTION_FLAGS, or you can +derive from POSIX::SigRt and define your own C<new()> (the tied hash +STORE method of the %SIGRT calls C<new($rtsig, $handler, $SIGACTION_FLAGS)>, +where the $rtsig ranges from zero to SIGRTMAX - SIGRTMIN + 1). + +Just as with any signal, you can use sigaction($rtsig, undef, $oa) to +retrieve the installed signal handler (or, rather, the signal action). + +B<NOTE:> whether POSIX realtime signals really work in your system, or +whether Perl has been compiled so that it works with them, is outside +of this discussion. + +=item SIGRTMIN + +Return the minimum POSIX realtime signal number available, or C<undef> +if no POSIX realtime signals are available. + +=item SIGRTMAX + +Return the maximum POSIX realtime signal number available, or C<undef> +if no POSIX realtime signals are available. + +=back + +=head2 POSIX::SigSet + +=over 8 + +=item 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 ); + +=item addset + +Add a signal to a SigSet object. + + $sigset->addset( &POSIX::SIGUSR2 ); + +Returns C<undef> on failure. + +=item delset + +Remove a signal from the SigSet object. + + $sigset->delset( &POSIX::SIGUSR2 ); + +Returns C<undef> on failure. + +=item emptyset + +Initialize the SigSet object to be empty. + + $sigset->emptyset(); + +Returns C<undef> on failure. + +=item fillset + +Initialize the SigSet object to include all signals. + + $sigset->fillset(); + +Returns C<undef> on failure. + +=item ismember + +Tests the SigSet object to see if it contains a specific signal. + + if( $sigset->ismember( &POSIX::SIGUSR1 ) ){ + print "contains SIGUSR1\n"; + } + +=back + +=head2 POSIX::Termios + +=over 8 + +=item new + +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; + +=item getattr + +Get terminal control attributes. + +Obtain the attributes for stdin. + + $termios->getattr( 0 ) # Recommended for clarity. + $termios->getattr() + +Obtain the attributes for stdout. + + $termios->getattr( 1 ) + +Returns C<undef> on failure. + +=item 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); + +=item getcflag + +Retrieve the c_cflag field of a termios object. + + $c_cflag = $termios->getcflag; + +=item getiflag + +Retrieve the c_iflag field of a termios object. + + $c_iflag = $termios->getiflag; + +=item getispeed + +Retrieve the input baud rate. + + $ispeed = $termios->getispeed; + +=item getlflag + +Retrieve the c_lflag field of a termios object. + + $c_lflag = $termios->getlflag; + +=item getoflag + +Retrieve the c_oflag field of a termios object. + + $c_oflag = $termios->getoflag; + +=item getospeed + +Retrieve the output baud rate. + + $ospeed = $termios->getospeed; + +=item setattr + +Set terminal control attributes. + +Set attributes immediately for stdout. + + $termios->setattr( 1, &POSIX::TCSANOW ); + +Returns C<undef> on failure. + +=item 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( &POSIX::VEOF, 1 ); + +=item setcflag + +Set the c_cflag field of a termios object. + + $termios->setcflag( $c_cflag | &POSIX::CLOCAL ); + +=item setiflag + +Set the c_iflag field of a termios object. + + $termios->setiflag( $c_iflag | &POSIX::BRKINT ); + +=item setispeed + +Set the input baud rate. + + $termios->setispeed( &POSIX::B9600 ); + +Returns C<undef> on failure. + +=item setlflag + +Set the c_lflag field of a termios object. + + $termios->setlflag( $c_lflag | &POSIX::ECHO ); + +=item setoflag + +Set the c_oflag field of a termios object. + + $termios->setoflag( $c_oflag | &POSIX::OPOST ); + +=item setospeed + +Set the output baud rate. + + $termios->setospeed( &POSIX::B9600 ); + +Returns C<undef> on failure. + +=item Baud rate values + +B38400 B75 B200 B134 B300 B1800 B150 B0 B19200 B1200 B9600 B600 B4800 B50 B2400 B110 + +=item Terminal interface values + +TCSADRAIN TCSANOW TCOON TCIOFLUSH TCOFLUSH TCION TCIFLUSH TCSAFLUSH TCIOFF TCOOFF + +=item c_cc field values + +VEOF VEOL VERASE VINTR VKILL VQUIT VSUSP VSTART VSTOP VMIN VTIME NCCS + +=item c_cflag field values + +CLOCAL CREAD CSIZE CS5 CS6 CS7 CS8 CSTOPB HUPCL PARENB PARODD + +=item c_iflag field values + +BRKINT ICRNL IGNBRK IGNCR IGNPAR INLCR INPCK ISTRIP IXOFF IXON PARMRK + +=item c_lflag field values + +ECHO ECHOE ECHOK ECHONL ICANON IEXTEN ISIG NOFLSH TOSTOP + +=item c_oflag field values + +OPOST + +=back + +=head1 PATHNAME CONSTANTS + +=over 8 + +=item Constants + +_PC_CHOWN_RESTRICTED _PC_LINK_MAX _PC_MAX_CANON _PC_MAX_INPUT _PC_NAME_MAX _PC_NO_TRUNC _PC_PATH_MAX _PC_PIPE_BUF _PC_VDISABLE + +=back + +=head1 POSIX CONSTANTS + +=over 8 + +=item Constants + +_POSIX_ARG_MAX _POSIX_CHILD_MAX _POSIX_CHOWN_RESTRICTED _POSIX_JOB_CONTROL _POSIX_LINK_MAX _POSIX_MAX_CANON _POSIX_MAX_INPUT _POSIX_NAME_MAX _POSIX_NGROUPS_MAX _POSIX_NO_TRUNC _POSIX_OPEN_MAX _POSIX_PATH_MAX _POSIX_PIPE_BUF _POSIX_SAVED_IDS _POSIX_SSIZE_MAX _POSIX_STREAM_MAX _POSIX_TZNAME_MAX _POSIX_VDISABLE _POSIX_VERSION + +=back + +=head1 SYSTEM CONFIGURATION + +=over 8 + +=item Constants + +_SC_ARG_MAX _SC_CHILD_MAX _SC_CLK_TCK _SC_JOB_CONTROL _SC_NGROUPS_MAX _SC_OPEN_MAX _SC_PAGESIZE _SC_SAVED_IDS _SC_STREAM_MAX _SC_TZNAME_MAX _SC_VERSION + +=back + +=head1 ERRNO + +=over 8 + +=item Constants + +E2BIG EACCES EADDRINUSE EADDRNOTAVAIL EAFNOSUPPORT EAGAIN EALREADY EBADF +EBUSY ECHILD ECONNABORTED ECONNREFUSED ECONNRESET EDEADLK EDESTADDRREQ +EDOM EDQUOT EEXIST EFAULT EFBIG EHOSTDOWN EHOSTUNREACH EINPROGRESS EINTR +EINVAL EIO EISCONN EISDIR ELOOP EMFILE EMLINK EMSGSIZE ENAMETOOLONG +ENETDOWN ENETRESET ENETUNREACH ENFILE ENOBUFS ENODEV ENOENT ENOEXEC +ENOLCK ENOMEM ENOPROTOOPT ENOSPC ENOSYS ENOTBLK ENOTCONN ENOTDIR +ENOTEMPTY ENOTSOCK ENOTTY ENXIO EOPNOTSUPP EPERM EPFNOSUPPORT EPIPE +EPROCLIM EPROTONOSUPPORT EPROTOTYPE ERANGE EREMOTE ERESTART EROFS +ESHUTDOWN ESOCKTNOSUPPORT ESPIPE ESRCH ESTALE ETIMEDOUT ETOOMANYREFS +ETXTBSY EUSERS EWOULDBLOCK EXDEV + +=back + +=head1 FCNTL + +=over 8 + +=item Constants + +FD_CLOEXEC F_DUPFD F_GETFD F_GETFL F_GETLK F_OK F_RDLCK F_SETFD F_SETFL F_SETLK F_SETLKW F_UNLCK F_WRLCK O_ACCMODE O_APPEND O_CREAT O_EXCL O_NOCTTY O_NONBLOCK O_RDONLY O_RDWR O_TRUNC O_WRONLY + +=back + +=head1 FLOAT + +=over 8 + +=item Constants + +DBL_DIG DBL_EPSILON DBL_MANT_DIG DBL_MAX DBL_MAX_10_EXP DBL_MAX_EXP DBL_MIN DBL_MIN_10_EXP DBL_MIN_EXP FLT_DIG FLT_EPSILON FLT_MANT_DIG FLT_MAX FLT_MAX_10_EXP FLT_MAX_EXP FLT_MIN FLT_MIN_10_EXP FLT_MIN_EXP FLT_RADIX FLT_ROUNDS LDBL_DIG LDBL_EPSILON LDBL_MANT_DIG LDBL_MAX LDBL_MAX_10_EXP LDBL_MAX_EXP LDBL_MIN LDBL_MIN_10_EXP LDBL_MIN_EXP + +=back + +=head1 LIMITS + +=over 8 + +=item Constants + +ARG_MAX CHAR_BIT CHAR_MAX CHAR_MIN CHILD_MAX INT_MAX INT_MIN LINK_MAX LONG_MAX LONG_MIN MAX_CANON MAX_INPUT MB_LEN_MAX NAME_MAX NGROUPS_MAX OPEN_MAX PATH_MAX PIPE_BUF SCHAR_MAX SCHAR_MIN SHRT_MAX SHRT_MIN SSIZE_MAX STREAM_MAX TZNAME_MAX UCHAR_MAX UINT_MAX ULONG_MAX USHRT_MAX + +=back + +=head1 LOCALE + +=over 8 + +=item Constants + +LC_ALL LC_COLLATE LC_CTYPE LC_MONETARY LC_NUMERIC LC_TIME + +=back + +=head1 MATH + +=over 8 + +=item Constants + +HUGE_VAL + +=back + +=head1 SIGNAL + +=over 8 + +=item Constants + +SA_NOCLDSTOP SA_NOCLDWAIT SA_NODEFER SA_ONSTACK SA_RESETHAND SA_RESTART +SA_SIGINFO SIGABRT SIGALRM SIGCHLD SIGCONT SIGFPE SIGHUP SIGILL SIGINT +SIGKILL SIGPIPE SIGQUIT SIGSEGV SIGSTOP SIGTERM SIGTSTP SIGTTIN SIGTTOU +SIGUSR1 SIGUSR2 SIG_BLOCK SIG_DFL SIG_ERR SIG_IGN SIG_SETMASK +SIG_UNBLOCK + +=back + +=head1 STAT + +=over 8 + +=item Constants + +S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU S_ISGID S_ISUID S_IWGRP S_IWOTH S_IWUSR S_IXGRP S_IXOTH S_IXUSR + +=item Macros + +S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISREG + +=back + +=head1 STDLIB + +=over 8 + +=item Constants + +EXIT_FAILURE EXIT_SUCCESS MB_CUR_MAX RAND_MAX + +=back + +=head1 STDIO + +=over 8 + +=item Constants + +BUFSIZ EOF FILENAME_MAX L_ctermid L_cuserid L_tmpname TMP_MAX + +=back + +=head1 TIME + +=over 8 + +=item Constants + +CLK_TCK CLOCKS_PER_SEC + +=back + +=head1 UNISTD + +=over 8 + +=item Constants + +R_OK SEEK_CUR SEEK_END SEEK_SET STDIN_FILENO STDOUT_FILENO STDERR_FILENO W_OK X_OK + +=back + +=head1 WAIT + +=over 8 + +=item Constants + +WNOHANG WUNTRACED + +=over 16 + +=item WNOHANG + +Do not suspend the calling process until a child process +changes state but instead return immediately. + +=item WUNTRACED + +Catch stopped child processes. + +=back + +=item Macros + +WIFEXITED WEXITSTATUS WIFSIGNALED WTERMSIG WIFSTOPPED WSTOPSIG + +=over 16 + +=item WIFEXITED + +WIFEXITED($?) returns true if the child process exited normally +(C<exit()> or by falling off the end of C<main()>) + +=item WEXITSTATUS + +WEXITSTATUS($?) returns the normal exit status of the child process +(only meaningful if WIFEXITED($?) is true) + +=item WIFSIGNALED + +WIFSIGNALED($?) returns true if the child process terminated because +of a signal + +=item WTERMSIG + +WTERMSIG($?) returns the signal the child process terminated for +(only meaningful if WIFSIGNALED($?) is true) + +=item WIFSTOPPED + +WIFSTOPPED($?) returns true if the child process is currently stopped +(can happen only if you specified the WUNTRACED flag to waitpid()) + +=item WSTOPSIG + +WSTOPSIG($?) returns the signal the child process was stopped for +(only meaningful if WIFSTOPPED($?) is true) + +=back + +=back + |