malloc
malloc
malloc
malloc
malloc-Related Functions
printf
sysconf
pathconf
@dircategory GNU libraries @direntry * Libc: (libc). C library.
@shorttitlepage The GNU C Library Reference Manual The GNU C Library
Reference Manual
Sandra Loosemore with Richard M. Stallman, Roland McGrath, Andrew Oram, and Ulrich Drepper
Edition 0.07 DRAFT
last updated 4 Oct 1996
for version 2.00 Beta Copyright (C) 1993, '94, '95, '96, '97 Free Software Foundation, Inc.
Published by the Free Software Foundation
59 Temple Place -- Suite 330,
Boston, MA 02111-1307 USA
Printed copies are available for $50 each.
ISBN 1-882114-53-1
Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.
Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the section entitled "GNU Library General Public License" is included exactly as in the original, and provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that the text of the translation of the section entitled "GNU Library General Public License" must be approved for accuracy by the Foundation.
The C language provides no built-in facilities for performing such common operations as input/output, memory management, string manipulation, and the like. Instead, these facilities are defined in a standard library, which you compile and link with your programs.
The GNU C library, described in this document, defines all of the library functions that are specified by the ISO C standard, as well as additional features specific to POSIX and other derivatives of the Unix operating system, and extensions specific to the GNU system.
The purpose of this manual is to tell you how to use the facilities of the GNU library. We have mentioned which features belong to which standards to help you identify things that are potentially nonportable to other systems. But the emphasis in this manual is not on strict portability.
This manual is written with the assumption that you are at least somewhat familiar with the C programming language and basic programming concepts. Specifically, familiarity with ISO standard C (see section ISO C), rather than "traditional" pre-ISO C dialects, is assumed.
The GNU C library includes several header files, each of which provides definitions and declarations for a group of related facilities; this information is used by the C compiler when processing your program. For example, the header file `stdio.h' declares facilities for performing input and output, and the header file `string.h' declares string processing utilities. The organization of this manual generally follows the same division as the header files.
If you are reading this manual for the first time, you should read all of the introductory material and skim the remaining chapters. There are a lot of functions in the GNU C library and it's not realistic to expect that you will be able to remember exactly how to use each and every one of them. It's more important to become generally familiar with the kinds of facilities that the library provides, so that when you are writing your programs you can recognize when to make use of library functions, and where in this manual you can find more specific information about them.
This section discusses the various standards and other sources that the GNU C library is based upon. These sources include the ISO C and POSIX standards, and the System V and Berkeley Unix implementations.
The primary focus of this manual is to tell you how to make effective use of the GNU library facilities. But if you are concerned about making your programs compatible with these standards, or portable to operating systems other than GNU, this can affect how you use the library. This section gives you an overview of these standards, so that you will know what they are when they are mentioned in other parts of the manual.
See section Summary of Library Facilities, for an alphabetical list of the functions and other symbols provided by the library. This list also states which standards each function or symbol comes from.
The GNU C library is compatible with the C standard adopted by the American National Standards Institute (ANSI): American National Standard X3.159-1989---"ANSI C" and later by the International Standardization Organization (ISO): ISO/IEC 9899:1990, "Programming languages--C". We here refer to the standard as ISO C since this is the more general standard in respect of ratification. The header files and library facilities that make up the GNU library are a superset of those specified by the ISO C standard.
If you are concerned about strict adherence to the ISO C standard, you should use the `-ansi' option when you compile your programs with the GNU C compiler. This tells the compiler to define only ISO standard features from the library header files, unless you explicitly ask for additional features. See section Feature Test Macros, for information on how to do this.
Being able to restrict the library to include only ISO C features is important because ISO C puts limitations on what names can be defined by the library implementation, and the GNU extensions don't fit these limitations. See section Reserved Names, for more information about these restrictions.
This manual does not attempt to give you complete details on the differences between ISO C and older dialects. It gives advice on how to write programs to work portably under multiple C dialects, but does not aim for completeness.
The GNU library is also compatible with the IEEE POSIX family of standards, known more formally as the Portable Operating System Interface for Computer Environments. POSIX is derived mostly from various versions of the Unix operating system.
The library facilities specified by the POSIX standards are a superset of those required by ISO C; POSIX specifies additional features for ISO C functions, as well as specifying new additional functions. In general, the additional requirements and functionality defined by the POSIX standards are aimed at providing lower-level support for a particular kind of operating system environment, rather than general programming language support which can run in many diverse operating system environments.
The GNU C library implements all of the functions specified in IEEE Std 1003.1-1990, the POSIX System Application Program Interface, commonly referred to as POSIX.1. The primary extensions to the ISO C facilities specified by this standard include file system interface primitives (see section File System Interface), device-specific terminal control functions (see section Low-Level Terminal Interface), and process control functions (see section Processes).
Some facilities from IEEE Std 1003.2-1992, the POSIX Shell and Utilities standard (POSIX.2) are also implemented in the GNU library. These include utilities for dealing with regular expressions and other pattern matching facilities (see section Pattern Matching).
The GNU C library defines facilities from some versions of Unix which are not formally standardized, specifically from the 4.2 BSD, 4.3 BSD, and 4.4 BSD Unix systems (also known as Berkeley Unix) and from SunOS (a popular 4.2 BSD derivative that includes some Unix System V functionality). These systems support most of the ISO C and POSIX facilities, and 4.4 BSD and newer releases of SunOS in fact support them all.
The BSD facilities include symbolic links (see section Symbolic Links), the
select function (see section Waiting for Input or Output), the BSD signal
functions (see section BSD Signal Handling), and sockets (see section Sockets).
The System V Interface Description (SVID) is a document describing the AT&T Unix System V operating system. It is to some extent a superset of the POSIX standard (see section POSIX (The Portable Operating System Interface)).
The GNU C library defines some of the facilities required by the SVID that are not also required by the ISO C or POSIX standards, for compatibility with System V Unix and other Unix systems (such as SunOS) which include these facilities. However, many of the more obscure and less generally useful facilities required by the SVID are not included. (In fact, Unix System V itself does not provide them all.)
This section describes some of the practical issues involved in using the GNU C library.
Libraries for use by C programs really consist of two parts: header files that define types and macros and declare variables and functions; and the actual library or archive that contains the definitions of the variables and functions.
(Recall that in C, a declaration merely provides information that a function or variable exists and gives its type. For a function declaration, information about the types of its arguments might be provided as well. The purpose of declarations is to allow the compiler to correctly process references to the declared variables and functions. A definition, on the other hand, actually allocates storage for a variable or says what a function does.)
In order to use the facilities in the GNU C library, you should be sure that your program source files include the appropriate header files. This is so that the compiler has declarations of these facilities available and can correctly process references to them. Once your program has been compiled, the linker resolves these references to the actual definitions provided in the archive file.
Header files are included into a program source file by the `#include' preprocessor directive. The C language supports two forms of this directive; the first,
#include "header"
is typically used to include a header file header that you write yourself; this would contain definitions and declarations describing the interfaces between the different parts of your particular application. By contrast,
#include <file.h>
is typically used to include a header file `file.h' that contains definitions and declarations for a standard library. This file would normally be installed in a standard place by your system administrator. You should use this second form for the C library header files.
Typically, `#include' directives are placed at the top of the C source file, before any other code. If you begin your source files with some comments explaining what the code in the file does (a good idea), put the `#include' directives immediately afterwards, following the feature test macro definition (see section Feature Test Macros).
For more information about the use of header files and `#include' directives, see section `Header Files' in The GNU C Preprocessor Manual.
The GNU C library provides several header files, each of which contains the type and macro definitions and variable and function declarations for a group of related facilities. This means that your programs may need to include several header files, depending on exactly which facilities you are using.
Some library header files include other library header files automatically. However, as a matter of programming style, you should not rely on this; it is better to explicitly include all the header files required for the library facilities you are using. The GNU C library header files have been written in such a way that it doesn't matter if a header file is accidentally included more than once; including a header file a second time has no effect. Likewise, if your program needs to include multiple header files, the order in which they are included doesn't matter.
Compatibility Note: Inclusion of standard header files in any order and any number of times works in any ISO C implementation. However, this has traditionally not been the case in many older C implementations.
Strictly speaking, you don't have to include a header file to use a function it declares; you could declare the function explicitly yourself, according to the specifications in this manual. But it is usually better to include the header file because it may define types and macros that are not otherwise available and because it may define more efficient macro replacements for some functions. It is also a sure way to have the correct declaration.
If we describe something as a function in this manual, it may have a macro definition as well. This normally has no effect on how your program runs--the macro definition does the same thing as the function would. In particular, macro equivalents for library functions evaluate arguments exactly once, in the same way that a function call would. The main reason for these macro definitions is that sometimes they can produce an inline expansion that is considerably faster than an actual function call.
Taking the address of a library function works even if it is also defined as a macro. This is because, in this context, the name of the function isn't followed by the left parenthesis that is syntactically necessary to recognize a macro call.
You might occasionally want to avoid using the macro definition of a function--perhaps to make your program easier to debug. There are two ways you can do this:
For example, suppose the header file `stdlib.h' declares a function
named abs with
extern int abs (int);
and also provides a macro definition for abs. Then, in:
#include <stdlib.h>
int f (int *i) { return (abs (++*i)); }
the reference to abs might refer to either a macro or a function.
On the other hand, in each of the following examples the reference is
to a function and not a macro.
#include <stdlib.h>
int g (int *i) { return ((abs)(++*i)); }
#undef abs
int h (int *i) { return (abs (++*i)); }
Since macro definitions that double for a function behave in exactly the same way as the actual function version, there is usually no need for any of these methods. In fact, removing macro definitions usually just makes your program slower.
The names of all library types, macros, variables and functions that come from the ISO C standard are reserved unconditionally; your program may not redefine these names. All other library names are reserved if your program explicitly includes the header file that defines or declares them. There are several reasons for these restrictions:
exit to do something completely different from
what the standard exit function does, for example. Preventing
this situation helps to make your programs easier to understand and
contributes to modularity and maintainability.
In addition to the names documented in this manual, reserved names include all external identifiers (global functions and variables) that begin with an underscore (`_') and all identifiers regardless of use that begin with either two underscores or an underscore followed by a capital letter are reserved names. This is so that the library and header files can define functions, variables, and macros for internal purposes without risk of conflict with names in user programs.
Some additional classes of identifier names are reserved for future extensions to the C language or the POSIX.1 environment. While using these names for your own purposes right now might not cause a problem, they do raise the possibility of conflict with future versions of the C or POSIX standards, so you should avoid these names.
float and long double arguments,
respectively.
In addition, some individual header files reserve names beyond those that they actually define. You only need to worry about these restrictions if your program includes that particular header file.
The exact set of features available when you compile a source file is controlled by which feature test macros you define.
If you compile your programs using `gcc -ansi', you get only the ISO C library features, unless you explicitly request additional features by defining one or more of the feature macros. See section `GNU CC Command Options' in The GNU CC Manual, for more information about GCC options.
You should define these macros by using `#define' preprocessor
directives at the top of your source code files. These directives
must come before any #include of a system header file. It
is best to make them the very first thing in the file, preceded only by
comments. You could also use the `-D' option to GCC, but it's
better if you make the source files indicate their own meaning in a
self-contained way.
1, then the
functionality from the POSIX.1 standard (IEEE Standard 1003.1) is made
available. If you define this macro with a value of 2, then both
the functionality from the POSIX.1 standard and the functionality from
the POSIX.2 standard (IEEE Standard 1003.2) are made available. This is
in addition to the ISO C facilities.
Some of the features derived from 4.3 BSD Unix conflict with the corresponding features specified by the POSIX.1 standard. If this macro is defined, the 4.3 BSD definitions take precedence over the POSIX definitions.
Due to the nature of some of the conflicts between 4.3 BSD and POSIX.1,
you need to use a special BSD compatibility library when linking
programs compiled for BSD compatibility. This is because some functions
must be defined in two different ways, one of them in the normal C
library, and one of them in the compatibility library. If your program
defines _BSD_SOURCE, you must give the option `-lbsd-compat'
to the compiler or linker when linking the program, to tell it to find
functions in this special compatibility library before looking for them in
the normal C library.
_POSIX_SOURCE and
_POSIX_C_SOURCE are automatically defined.
As the unification of all Unices, functionality only available in BSD and SVID is also included.
If the macro _XOPEN_SOURCE_EXTENDED is also defined, even more
functionality is available. The extra functions will make all functions
available which are necessary for the X/Open Unix brand.
If you want to get the full effect of _GNU_SOURCE but make the
BSD definitions take precedence over the POSIX definitions, use this
sequence of definitions:
#define _GNU_SOURCE #define _BSD_SOURCE #define _SVID_SOURCE
Note that if you do this, you must link your program with the BSD compatibility library by passing the `-lbsd-compat' option to the compiler or linker. Note: If you forget to do this, you may get very strange errors at run time.
Unlike on some other systems no special version of the C library must be used for linking. There is only one version but while compiling this it must have been specified to compile as thread safe.
We recommend you use _GNU_SOURCE in new programs. If you don't
specify the `-ansi' option to GCC and don't define any of these
macros explicitly, the effect is the same as defining
_POSIX_C_SOURCE to 2 and _POSIX_SOURCE,
_SVID_SOURCE, and _BSD_SOURCE to 1.
When you define a feature test macro to request a larger class of features,
it is harmless to define in addition a feature test macro for a subset of
those features. For example, if you define _POSIX_C_SOURCE, then
defining _POSIX_SOURCE as well has no effect. Likewise, if you
define _GNU_SOURCE, then defining either _POSIX_SOURCE or
_POSIX_C_SOURCE or _SVID_SOURCE as well has no effect.
Note, however, that the features of _BSD_SOURCE are not a subset of
any of the other feature test macros supported. This is because it defines
BSD features that take precedence over the POSIX features that are
requested by the other macros. For this reason, defining
_BSD_SOURCE in addition to the other feature test macros does have
an effect: it causes the BSD features to take priority over the conflicting
POSIX features.
Here is an overview of the contents of the remaining chapters of this manual.
sizeof
operator and the symbolic constant NULL, how to write functions
accepting variable numbers of arguments, and constants describing the
ranges and other properties of the numerical types. There is also a simple
debugging mechanism which allows you to put assertions in your code, and
have diagnostic messages printed if the tests fail.
isspace) and functions for
performing case conversion.
FILE * objects). These are the normal C library functions
from `stdio.h'.
char data type.
setjmp and
longjmp functions. These functions provide a facility for
goto-like jumps which can jump from one function to another.
If you already know the name of the facility you are interested in, you can look it up in section Summary of Library Facilities. This gives you a summary of its syntax and a pointer to where you can find a more detailed description. This appendix is particularly useful if you just want to verify the order and type of arguments to a function, for example. It also tells you what standard or system each function, variable, or macro is derived from.
Many functions in the GNU C library detect and report error conditions, and sometimes your programs need to check for these error conditions. For example, when you open an input file, you should verify that the file was actually opened correctly, and print an error message or take other appropriate action if the call to the library function failed.
This chapter describes how the error reporting facility works. Your program should include the header file `errno.h' to use this facility.
Most library functions return a special value to indicate that they have
failed. The special value is typically -1, a null pointer, or a
constant such as EOF that is defined for that purpose. But this
return value tells you only that an error has occurred. To find out
what kind of error it was, you need to look at the error code stored in the
variable errno. This variable is declared in the header file
`errno.h'.
errno contains the system error number. You can
change the value of errno.
Since errno is declared volatile, it might be changed
asynchronously by a signal handler; see section Defining Signal Handlers.
However, a properly written signal handler saves and restores the value
of errno, so you generally do not need to worry about this
possibility except when writing signal handlers.
The initial value of errno at program startup is zero. Many
library functions are guaranteed to set it to certain nonzero values
when they encounter certain kinds of errors. These error conditions are
listed for each function. These functions do not change errno
when they succeed; thus, the value of errno after a successful
call is not necessarily zero, and you should not use errno to
determine whether a call failed. The proper way to do that is
documented for each function. If the call the failed, you can
examine errno.
Many library functions can set errno to a nonzero value as a
result of calling other library functions which might fail. You should
assume that any library function might alter errno when the
function returns an error.
Portability Note: ISO C specifies errno as a
"modifiable lvalue" rather than as a variable, permitting it to be
implemented as a macro. For example, its expansion might involve a
function call, like *_errno (). In fact, that is what it is
on the GNU system itself. The GNU library, on non-GNU systems, does
whatever is right for the particular system.
There are a few library functions, like sqrt and atan,
that return a perfectly legitimate value in case of an error, but also
set errno. For these functions, if you want to check to see
whether an error occurred, the recommended method is to set errno
to zero before calling the function, and then check its value afterward.
All the error codes have symbolic names; they are macros defined in `errno.h'. The names start with `E' and an upper-case letter or digit; you should consider names of this form to be reserved names. See section Reserved Names.
The error code values are all positive integers and are all distinct,
with one exception: EWOULDBLOCK and EAGAIN are the same.
Since the values are distinct, you can use them as labels in a
switch statement; just don't use both EWOULDBLOCK and
EAGAIN. Your program should not make any other assumptions about
the specific values of these symbolic constants.
The value of errno doesn't necessarily have to correspond to any
of these macros, since some library functions might return other error
codes of their own for other situations. The only values that are
guaranteed to be meaningful for a particular library function are the
ones that this manual lists for that function.
On non-GNU systems, almost any system call can return EFAULT if
it is given an invalid pointer as an argument. Since this could only
happen as a result of a bug in your program, and since it will not
happen on the GNU system, we have saved space by not mentioning
EFAULT in the descriptions of individual functions.
In some Unix systems, many system calls can also return EFAULT if
given as an argument a pointer into the stack, and the kernel for some
obscure reason fails in its attempt to extend the stack. If this ever
happens, you should probably try using statically or dynamically
allocated memory instead of stack memory on that system.
The error code macros are defined in the header file `errno.h'. All of them expand into integer constant values. Some of these error codes can't occur on the GNU system, but they can occur using the GNU library on other systems.
You can choose to have functions resume after a signal that is handled,
rather than failing with EINTR; see section Primitives Interrupted by Signals.
exec functions (see section Executing a File) occupy too much memory space. This condition never arises in the
GNU system.
exec functions; see section Executing a File.
link (see section Hard Links) but
also when you rename a file with rename (see section Renaming Files).
In BSD and GNU, the number of open files is controlled by a resource
limit that can usually be increased. If you get this error, you might
want to increase the RLIMIT_NOFILE limit or make it unlimited;
see section Limiting Resource Usage.
rename can cause this error if the file being renamed already has
as many links as it can take (see section Renaming Files).
SIGPIPE signal; this signal terminates the program if not handled
or blocked. Thus, your program will never actually see EPIPE
unless it has handled or blocked SIGPIPE.
EWOULDBLOCK is another name for EAGAIN;
they are always the same in the GNU C library.
This error can happen in a few different situations:
select to find out
when the operation will be possible; see section Waiting for Input or Output.
Portability Note: In many older Unix systems, this condition
was indicated by EWOULDBLOCK, which was a distinct error code
different from EAGAIN. To make your program portable, you should
check for both codes and treat them the same.
fork
can return this error. It indicates that the shortage is expected to
pass, so your program can try the call again later and it may succeed.
It is probably a good idea to delay for a few seconds before trying it
again, to allow time for other processes to release scarce resources.
Such shortages are usually fairly serious and affect the whole system,
so usually an interactive program should report the error to the user
and return to its command loop.
EAGAIN (above).
The values are always the same, on every operating system.
C libraries in many older Unix systems have EWOULDBLOCK as a
separate error code.
connect; see section Making a Connection) never return
EAGAIN. Instead, they return EINPROGRESS to indicate that
the operation has begun and will take some time. Attempts to manipulate
the object before the call completes return EALREADY. You can
use the select function to find out when the pending operation
has completed; see section Waiting for Input or Output.
ENOMEM; you may get one or the
other from network operations.
EDESTADDRREQ instead.
connect.
PATH_MAX; see section Limits on File System Capacity) or host name too long (in gethostname or
sethostname; see section Host Identification).
fork. See section Limiting Resource Usage, for details on
the RLIMIT_NPROC limit.
On some systems chmod returns this error if you try to set the
sticky bit on a non-directory file; see section Assigning File Permissions.
term protocol return
this error for certain operations when the caller is not in the
foreground process group of the terminal. Users do not usually see this
error because functions such as read and write translate
it into a SIGTTIN or SIGTTOU signal. See section Job Control,
for information on process groups and these signals.
The following error codes are defined by the Linux/i386 kernel. They are not yet documented.
The library has functions and variables designed to make it easy for
your program to report informative error messages in the customary
format about the failure of a library call. The functions
strerror and perror give you the standard error message
for a given error code; the variable
program_invocation_short_name gives you convenient access to the
name of the program that encountered the error.
strerror function maps the error code (see section Checking for Errors) specified by the errnum argument to a descriptive error
message string. The return value is a pointer to this string.
The value errnum normally comes from the variable errno.
You should not modify the string returned by strerror. Also, if
you make subsequent calls to strerror, the string might be
overwritten. (But it's guaranteed that no library function ever calls
strerror behind your back.)
The function strerror is declared in `string.h'.
strerror_r function works like strerror but instead of
returning the error message in a statically allocated buffer shared by
all threads in the process, it writes the message string in the user
supplied buffer starting at buf with the length of n bytes.
At most n characters are written (including the NUL byte) so it is up to the user to select the buffer large enough.
This function should always be used in multi-threaded programs since
there is no way to guarantee the string returned by strerror
really belongs to the last call of the current thread.
This function strerror_r is a GNU extension and it is declared in
`string.h'.
stderr;
see section Standard Streams.
If you call perror with a message that is either a null
pointer or an empty string, perror just prints the error message
corresponding to errno, adding a trailing newline.
If you supply a non-null message argument, then perror
prefixes its output with this string. It adds a colon and a space
character to separate the message from the error string corresponding
to errno.
The function perror is declared in `stdio.h'.
strerror and perror produce the exact same message for any
given error code; the precise text varies from system to system. On the
GNU system, the messages are fairly short; there are no multi-line
messages or embedded newlines. Each error message begins with a capital
letter and does not include any terminating punctuation.
Compatibility Note: The strerror function is a new
feature of ISO C. Many older C systems do not support this function
yet.
Many programs that don't read input from the terminal are designed to
exit if any system call fails. By convention, the error message from
such a program should start with the program's name, sans directories.
You can find that name in the variable
program_invocation_short_name; the full file name is stored the
variable program_invocation_name:
argv[0]. Note
that this is not necessarily a useful file name; often it contains no
directory names. See section Program Arguments.
program_invocation_name minus
everything up to the last slash, if any.)
The library initialization code sets up both of these variables before
calling main.
Portability Note: These two variables are GNU extensions. If
you want your program to work with non-GNU libraries, you must save the
value of argv[0] in main, and then strip off the directory
names yourself. We added these extensions to make it possible to write
self-contained error-reporting subroutines that require no explicit
cooperation from main.
Here is an example showing how to handle failure to open a file
correctly. The function open_sesame tries to open the named file
for reading and returns a stream if successful. The fopen
library function returns a null pointer if it couldn't open the file for
some reason. In that situation, open_sesame constructs an
appropriate error message using the strerror function, and
terminates the program. If we were going to make some other library
calls before passing the error code to strerror, we'd have to
save it in a local variable instead, because those other library
functions might overwrite errno in the meantime.
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
FILE *
open_sesame (char *name)
{
FILE *stream;
errno = 0;
stream = fopen (name, "r");
if (stream == NULL)
{
fprintf (stderr, "%s: Couldn't open file %s; %s\n",
program_invocation_short_name, name, strerror (errno));
exit (EXIT_FAILURE);
}
else
return stream;
}
The GNU system provides several methods for allocating memory space under explicit program control. They vary in generality and in efficiency.
malloc facility allows fully general dynamic allocation.
See section Unconstrained Allocation.
malloc but more
efficient and convenient for stacklike allocation. See section Obstacks.
alloca lets you allocate storage dynamically that
will be freed automatically. See section Automatic Storage with Variable Size.
Dynamic memory allocation is a technique in which programs determine as they are running where to store some information. You need dynamic allocation when the number of memory blocks you need, or how long you continue to need them, depends on the data you are working on.
For example, you may need a block to store a line read from an input file; since there is no limit to how long a line can be, you must allocate the storage dynamically and make it dynamically larger as you read more of the line.
Or, you may need a block for each record or each definition in the input data; since you can't know in advance how many there will be, you must allocate a new block for each record or definition as you read it.
When you use dynamic allocation, the allocation of a block of memory is an action that the program requests explicitly. You call a function or macro when you want to allocate space, and specify the size with an argument. If you want to free the space, you do so by calling another function or macro. You can do these things whenever you want, as often as you want.
The C language supports two kinds of memory allocation through the variables in C programs:
Dynamic allocation is not supported by C variables; there is no storage class "dynamic", and there can never be a C variable whose value is stored in dynamically allocated space. The only way to refer to dynamically allocated space is through a pointer. Because it is less convenient, and because the actual process of dynamic allocation requires more computation time, programmers generally use dynamic allocation only when neither static nor automatic allocation will serve.
For example, if you want to allocate dynamically some space to hold a
struct foobar, you cannot declare a variable of type struct
foobar whose contents are the dynamically allocated space. But you can
declare a variable of pointer type struct foobar * and assign it the
address of the space. Then you can use the operators `*' and
`->' on this pointer variable to refer to the contents of the space:
{
struct foobar *ptr
= (struct foobar *) malloc (sizeof (struct foobar));
ptr->name = x;
ptr->next = current_foobar;
current_foobar = ptr;
}
The most general dynamic allocation facility is malloc. It
allows you to allocate blocks of memory of any size at any time, make
them bigger or smaller at any time, and free the blocks individually at
any time (or never).
To allocate a block of memory, call malloc. The prototype for
this function is in `stdlib.h'.
The contents of the block are undefined; you must initialize it yourself
(or use calloc instead; see section Allocating Cleared Space).
Normally you would cast the value as a pointer to the kind of object
that you want to store in the block. Here we show an example of doing
so, and of initializing the space with zeros using the library function
memset (see section Copying and Concatenation):
struct foo *ptr; ... ptr = (struct foo *) malloc (sizeof (struct foo)); if (ptr == 0) abort (); memset (ptr, 0, sizeof (struct foo));
You can store the result of malloc into any pointer variable
without a cast, because ISO C automatically converts the type
void * to another type of pointer when necessary. But the cast
is necessary in contexts other than assignment operators or if you might
want your code to run in traditional C.
Remember that when allocating space for a string, the argument to
malloc must be one plus the length of the string. This is
because a string is terminated with a null character that doesn't count
in the "length" of the string but does need space. For example:
char *ptr; ... ptr = (char *) malloc (length + 1);
See section Representation of Strings, for more information about this.
malloc
If no more space is available, malloc returns a null pointer.
You should check the value of every call to malloc. It is
useful to write a subroutine that calls malloc and reports an
error if the value is a null pointer, returning only if the value is
nonzero. This function is conventionally called xmalloc. Here
it is:
void *
xmalloc (size_t size)
{
register void *value = malloc (size);
if (value == 0)
fatal ("virtual memory exhausted");
return value;
}
Here is a real example of using malloc (by way of xmalloc).
The function savestring will copy a sequence of characters into
a newly allocated null-terminated string:
char *
savestring (const char *ptr, size_t len)
{
register char *value = (char *) xmalloc (len + 1);
memcpy (value, ptr, len);
value[len] = '\0';
return value;
}
The block that malloc gives you is guaranteed to be aligned so
that it can hold any type of data. In the GNU system, the address is
always a multiple of eight on most systems, and a multiple of 16 on
64-bit systems. Only rarely is any higher boundary (such as a page
boundary) necessary; for those cases, use memalign or
valloc (see section Allocating Aligned Memory Blocks).
Note that the memory located after the end of the block is likely to be
in use for something else; perhaps a block already allocated by another
call to malloc. If you attempt to treat the block as longer than
you asked for it to be, you are liable to destroy the data that
malloc uses to keep track of its blocks, or you may destroy the
contents of another block. If you have already allocated a block and
discover you want it to be bigger, use realloc (see section Changing the Size of a Block).
malloc
When you no longer need a block that you got with malloc, use the
function free to make the block available to be allocated again.
The prototype for this function is in `stdlib.h'.
free function deallocates the block of storage pointed at
by ptr.
free. It's provided for
backward compatibility with SunOS; you should use free instead.
Freeing a block alters the contents of the block. Do not expect to find any data (such as a pointer to the next block in a chain of blocks) in the block after freeing it. Copy whatever you need out of the block before freeing it! Here is an example of the proper way to free all the blocks in a chain, and the strings that they point to:
struct chain
{
struct chain *next;
char *name;
}
void
free_chain (struct chain *chain)
{
while (chain != 0)
{
struct chain *next = chain->next;
free (chain->name);
free (chain);
chain = next;
}
}
Occasionally, free can actually return memory to the operating
system and make the process smaller. Usually, all it can do is allow a
later call to malloc to reuse the space. In the meantime, the
space remains in your program as part of a free-list used internally by
malloc.
There is no point in freeing blocks at the end of a program, because all of the program's space is given back to the system when the process terminates.
Often you do not know for certain how big a block you will ultimately need at the time you must begin to use the block. For example, the block might be a buffer that you use to hold a line being read from a file; no matter how long you make the buffer initially, you may encounter a line that is longer.
You can make the block longer by calling realloc. This function
is declared in `stdlib.h'.
realloc function changes the size of the block whose address is
ptr to be newsize.
Since the space after the end of the block may be in use, realloc
may find it necessary to copy the block to a new address where more free
space is available. The value of realloc is the new address of the
block. If the block needs to be moved, realloc copies the old
contents.
If you pass a null pointer for ptr, realloc behaves just
like `malloc (newsize)'. This can be convenient, but beware
that older implementations (before ISO C) may not support this
behavior, and will probably crash when realloc is passed a null
pointer.
Like malloc, realloc may return a null pointer if no
memory space is available to make the block bigger. When this happens,
the original block is untouched; it has not been modified or relocated.
In most cases it makes no difference what happens to the original block
when realloc fails, because the application program cannot continue
when it is out of memory, and the only thing to do is to give a fatal error
message. Often it is convenient to write and use a subroutine,
conventionally called xrealloc, that takes care of the error message
as xmalloc does for malloc:
void *
xrealloc (void *ptr, size_t size)
{
register void *value = realloc (ptr, size);
if (value == 0)
fatal ("Virtual memory exhausted");
return value;
}
You can also use realloc to make a block smaller. The reason you
is needed.
In several allocation implementations, making a block smaller sometimes
necessitates copying it, so it can fail if no other space is available.
If the new size you specify is the same as the old size, realloc
is guaranteed to change nothing and return the same address that you gave.
The function calloc allocates memory and clears it to zero. It
is declared in `stdlib.h'.
calloc returns.
You could define calloc as follows:
void *
calloc (size_t count, size_t eltsize)
{
size_t size = count * eltsize;
void *value = malloc (size);
if (value != 0)
memset (value, 0, size);
return value;
}
But in general, it is not guaranteed that calloc calls
malloc internally. Therefore, if an application provides its own
malloc/realloc/free outside the C library, it
should always define calloc, too.
malloc
As apposed to other versions, the malloc in GNU libc does not
round up block sizes to powers of two, neither for large nor for small
sizes. Neighboring chunks can be coalesced on a free no matter
what their size is. This makes the implementation suitable for all
kinds of allocation patterns without generally incurring high memory
waste through fragmentation.
Very large blocks (much larger than a page) are allocated with
mmap (anonymous or via /dev/zero) by this implementation.
This has the great advantage that these chunks are returned to the
system immediately when they are freed. Therefore, it cannot happen
that a large chunk becomes "locked" in between smaller ones and even
after calling free wastes memory. The size threshold for
mmap to be used can be adjusted with mallopt. The use of
mmap can also be disabled completely.
The address of a block returned by malloc or realloc in
the GNU system is always a multiple of eight (or sixteen on 64-bit
systems). If you need a block whose address is a multiple of a higher
power of two than that, use memalign or valloc. These
functions are declared in `stdlib.h'.
With the GNU library, you can use free to free the blocks that
memalign and valloc return. That does not work in BSD,
however--BSD does not provide any way to free such blocks.
memalign function allocates a block of size bytes whose
address is a multiple of boundary. The boundary must be a
power of two! The function memalign works by allocating a
somewhat larger block, and then returning an address within the block
that is on the specified boundary.
valloc is like using memalign and passing the page size
as the value of the second argument. It is implemented like this:
void *
valloc (size_t size)
{
return memalign (getpagesize (), size);
}
You can adjust some parameters for dynamic memory allocation with the
mallopt function. This function is the general SVID/XPG
interface, defined in `malloc.h'.
mallopt, the param argument specifies the
parameter to be set, and value the new value to be set. Possible
choices for param, as defined in `malloc.h', are:
M_TRIM_THRESHOLD
sbrk to be called with a negative argument in
order to return memory to the system.
M_TOP_PAD
sbrk is required. It also specifies the
number of bytes to retain when shrinking the heap by calling sbrk
with a negative argument. This provides the necessary hysteresis in
heap size such that excessive amounts of system calls can be avoided.
M_MMAP_THRESHOLD
mmap system call. This way it is guaranteed
that the memory for these chunks can be returned to the system on
free.
M_MMAP_MAX
mmap. Setting this
to zero disables all use of mmap.
You can ask malloc to check the consistency of dynamic storage by
using the mcheck function. This function is a GNU extension,
declared in `malloc.h'.
mcheck tells malloc to perform occasional
consistency checks. These will catch things such as writing
past the end of a block that was allocated with malloc.
The abortfn argument is the function to call when an inconsistency
is found. If you supply a null pointer, then mcheck uses a
default function which prints a message and calls abort
(see section Aborting a Program). The function you supply is called with
one argument, which says what sort of inconsistency was detected; its
type is described below.
It is too late to begin allocation checking once you have allocated
anything with malloc. So mcheck does nothing in that
case. The function returns -1 if you call it too late, and
0 otherwise (when it is successful).
The easiest way to arrange to call mcheck early enough is to use
the option `-lmcheck' when you link your program; then you don't
need to modify your program source at all.
mprobe function lets you explicitly check for inconsistencies
in a particular allocated block. You must have already called
mcheck at the beginning of the program, to do its occasional
checks; calling mprobe requests an additional consistency check
to be done at the time of the call.
The argument pointer must be a pointer returned by malloc
or realloc. mprobe returns a value that says what
inconsistency, if any, was found. The values are described below.
MCHECK_DISABLED
mcheck was not called before the first allocation.
No consistency checking can be done.
MCHECK_OK
MCHECK_HEAD
MCHECK_TAIL
MCHECK_FREE
The GNU C library lets you modify the behavior of malloc,
realloc, and free by specifying appropriate hook
functions. You can use these hooks to help you debug programs that use
dynamic storage allocation, for example.
The hook variables are declared in `malloc.h'.
malloc
uses whenever it is called. You should define this function to look
like malloc; that is, like:
void *function (size_t size)
realloc
uses whenever it is called. You should define this function to look
like realloc; that is, like:
void *function (void *ptr, size_t size)
free
uses whenever it is called. You should define this function to look
like free; that is, like:
void function (void *ptr)
You must make sure that the function you install as a hook for one of these functions does not call that function recursively without restoring the old value of the hook first! Otherwise, your program will get stuck in an infinite recursion.
Here is an example showing how to use __malloc_hook properly. It
installs a function that prints out information every time malloc
is called.
static void *(*old_malloc_hook) (size_t);
static void *
my_malloc_hook (size_t size)
{
void *result;
__malloc_hook = old_malloc_hook;
result = malloc (size);
/* printf might call malloc, so protect it too. */
printf ("malloc (%u) returns %p\n", (unsigned int) size, result);
__malloc_hook = my_malloc_hook;
return result;
}
main ()
{
...
old_malloc_hook = __malloc_hook;
__malloc_hook = my_malloc_hook;
...
}
The mcheck function (see section Heap Consistency Checking) works by
installing such hooks.
malloc
You can get information about dynamic storage allocation by calling the
mallinfo function. This function and its associated data type
are declared in `malloc.h'; they are an extension of the standard
SVID/XPG version.
int arena
sbrk by
malloc, in bytes.
int ordblks
malloc requests; see
section Efficiency Considerations for malloc.)
int smblks
int hblks
mmap.
int hblkhd
mmap, in bytes.
int usmblks
int fsmblks
int uordblks
malloc.
int fordblks
int keepcost
struct mallinfo.
malloc-Related Functions
Here is a summary of the functions that work with malloc:
void *malloc (size_t size)
void free (void *addr)
malloc. See section Freeing Memory Allocated with malloc.
void *realloc (void *addr, size_t size)
malloc larger or smaller,
possibly by copying it to a new location. See section Changing the Size of a Block.
void *calloc (size_t count, size_t eltsize)
malloc, and set its contents to zero. See section Allocating Cleared Space.
void *valloc (size_t size)
void *memalign (size_t size, size_t boundary)
int mallopt (int param, int value)
int mcheck (void (*abortfn) (void))
malloc to perform occasional consistency checks on
dynamically allocated memory, and to call abortfn when an
inconsistency is found. See section Heap Consistency Checking.
void *(*__malloc_hook) (size_t size)
malloc uses whenever it is called.
void *(*__realloc_hook) (void *ptr, size_t size)
realloc uses whenever it is called.
void (*__free_hook) (void *ptr)
free uses whenever it is called.
struct mallinfo mallinfo (void)
malloc.
An obstack is a pool of memory containing a stack of objects. You can create any number of separate obstacks, and then allocate objects in specified obstacks. Within each obstack, the last object allocated must always be the first one freed, but distinct obstacks are independent of each other.
Aside from this one constraint of order of freeing, obstacks are totally general: an obstack can contain any number of objects of any size. They are implemented with macros, so allocation is usually very fast as long as the objects are usually small. And the only space overhead per object is the padding needed to start each object on a suitable boundary.
The utilities for manipulating obstacks are declared in the header file `obstack.h'.
struct
obstack. This structure has a small fixed size; it records the status
of the obstack and how to find the space in which objects are allocated.
It does not contain any of the objects themselves. You should not try
to access the contents of the structure directly; use only the functions
described in this chapter.
You can declare variables of type struct obstack and use them as
obstacks, or you can allocate obstacks dynamically like any other kind
of object. Dynamic allocation of obstacks allows your program to have a
variable number of different stacks. (You can even allocate an
obstack structure in another obstack, but this is rarely useful.)
All the functions that work with obstacks require you to specify which
obstack to use. You do this with a pointer of type struct obstack
*. In the following, we often say "an obstack" when strictly
speaking the object at hand is such a pointer.
The objects in the obstack are packed into large blocks called
chunks. The struct obstack structure points to a chain of
the chunks currently in use.
The obstack library obtains a new chunk whenever you allocate an object
that won't fit in the previous chunk. Since the obstack library manages
chunks automatically, you don't need to pay much attention to them, but
you do need to supply a function which the obstack library should use to
get a chunk. Usually you supply a function which uses malloc
directly or indirectly. You must also supply a function to free a chunk.
These matters are described in the following section.
Each source file in which you plan to use the obstack functions must include the header file `obstack.h', like this:
#include <obstack.h>
Also, if the source file uses the macro obstack_init, it must
declare or define two functions or macros that will be called by the
obstack library. One, obstack_chunk_alloc, is used to allocate
the chunks of memory into which objects are packed. The other,
obstack_chunk_free, is used to return chunks when the objects in
them are freed. These macros should appear before any use of obstacks
in the source file.
Usually these are defined to use malloc via the intermediary
xmalloc (see section Unconstrained Allocation). This is done with
the following pair of macro definitions:
#define obstack_chunk_alloc xmalloc #define obstack_chunk_free free
Though the storage you get using obstacks really comes from malloc,
using obstacks is faster because malloc is called less often, for
larger blocks of memory. See section Obstack Chunks, for full details.
At run time, before the program can use a struct obstack object
as an obstack, it must initialize the obstack by calling
obstack_init.
obstack_chunk_alloc function. It
returns 0 if obstack_chunk_alloc returns a null pointer, meaning
that it is out of memory. Otherwise, it returns 1. If you supply an
obstack_chunk_alloc function that calls exit
(see section Program Termination) or longjmp (see section Non-Local Exits) when out of memory, you can safely ignore the value that
obstack_init returns.
Here are two examples of how to allocate the space for an obstack and initialize it. First, an obstack that is a static variable:
static struct obstack myobstack; ... obstack_init (&myobstack);
Second, an obstack that is itself dynamically allocated:
struct obstack *myobstack_ptr = (struct obstack *) xmalloc (sizeof (struct obstack)); obstack_init (myobstack_ptr);
The most direct way to allocate an object in an obstack is with
obstack_alloc, which is invoked almost like malloc.
struct obstack
object which represents the obstack. Each obstack function or macro
requires you to specify an obstack-ptr as the first argument.
This function calls the obstack's obstack_chunk_alloc function if
it needs to allocate a new chunk of memory; it returns a null pointer if
obstack_chunk_alloc returns one. In that case, it has not
changed the amount of memory allocated in the obstack. If you supply an
obstack_chunk_alloc function that calls exit
(see section Program Termination) or longjmp (see section Non-Local Exits) when out of memory, then obstack_alloc will never return
a null pointer.
For example, here is a function that allocates a copy of a string str
in a specific obstack, which is in the variable string_obstack:
struct obstack string_obstack;
char *
copystring (char *string)
{
size_t len = strlen (string) + 1;
char *s = (char *) obstack_alloc (&string_obstack, len);
memcpy (s, string, len);
return s;
}
To allocate a block with specified contents, use the function
obstack_copy, declared like this:
obstack_alloc.
obstack_copy, but appends an extra byte containing a null
character. This extra byte is not counted in the argument size.
The obstack_copy0 function is convenient for copying a sequence
of characters into an obstack as a null-terminated string. Here is an
example of its use:
char *
obstack_savestring (char *addr, int size)
{
return obstack_copy0 (&myobstack, addr, size);
}
Contrast this with the previous example of savestring using
malloc (see section Basic Storage Allocation).
To free an object allocated in an obstack, use the function
obstack_free. Since the obstack is a stack of objects, freeing
one object automatically frees all other objects allocated more recently
in the same obstack.
Note that if object is a null pointer, the result is an
uninitialized obstack. To free all storage in an obstack but leave it
valid for further allocation, call obstack_free with the address
of the first object allocated on the obstack:
obstack_free (obstack_ptr, first_object_allocated_ptr);
Recall that the objects in an obstack are grouped into chunks. When all the objects in a chunk become free, the obstack library automatically frees the chunk (see section Preparing for Using Obstacks). Then other obstacks, or non-obstack allocation, can reuse the space of the chunk.
The interfaces for using obstacks may be defined either as functions or as macros, depending on the compiler. The obstack facility works with all C compilers, including both ISO C and traditional C, but there are precautions you must take if you plan to use compilers other than GNU C.
If you are using an old-fashioned non-ISO C compiler, all the obstack "functions" are actually defined only as macros. You can call these macros like functions, but you cannot use them in any other way (for example, you cannot take their address).
Calling the macros requires a special precaution: namely, the first operand (the obstack pointer) may not contain any side effects, because it may be computed more than once. For example, if you write this:
obstack_alloc (get_obstack (), 4);
you will find that get_obstack may be called several times.
If you use *obstack_list_ptr++ as the obstack pointer argument,
you will get very strange results since the incrementation may occur
several times.
In ISO C, each function has both a macro definition and a function definition. The function definition is used if you take the address of the function without calling it. An ordinary call uses the macro definition by default, but you can request the function definition instead by writing the function name in parentheses, as shown here:
char *x; void *(*funcp) (); /* Use the macro. */ x = (char *) obstack_alloc (obptr, size); /* Call the function. */ x = (char *) (obstack_alloc) (obptr, size); /* Take the address of the function. */ funcp = obstack_alloc;
This is the same situation that exists in ISO C for the standard library functions. See section Macro Definitions of Functions.
Warning: When you do use the macros, you must observe the precaution of avoiding side effects in the first operand, even in ISO C.
If you use the GNU C compiler, this precaution is not necessary, because various language extensions in GNU C permit defining the macros so as to compute each argument only once.
Because storage in obstack chunks is used sequentially, it is possible to build up an object step by step, adding one or more bytes at a time to the end of the object. With this technique, you do not need to know how much data you will put in the object until you come to the end of it. We call this the technique of growing objects. The special functions for adding data to the growing object are described in this section.
You don't need to do anything special when you start to grow an object.
Using one of the functions to add data to the object automatically
starts it. However, it is necessary to say explicitly when the object is
finished. This is done with the function obstack_finish.
The actual address of the object thus built up is not known until the object is finished. Until then, it always remains possible that you will add so much data that the object must be copied into a new chunk.
While the obstack is in use for a growing object, you cannot use it for ordinary allocation of another object. If you try to do so, the space already added to the growing object will become part of the other object.
obstack_blank, which adds space without initializing it.
obstack_grow, which is
the growing-object analogue of obstack_copy. It adds size
bytes of data to the growing object, copying the contents from
data.
obstack_copy0. It adds
size bytes copied from data, followed by an additional null
character.
obstack_1grow.
It adds a single byte containing c to the growing object.
obstack_ptr_grow. It adds sizeof (void *) bytes
containing the value of data.
int can be added by using the
obstack_int_grow function. It adds sizeof (int) bytes to
the growing object and initializes them with the value of data.
obstack_finish to close it off and return its final address.
Once you have finished the object, the obstack is available for ordinary allocation or for growing another object.
This function can return a null pointer under the same conditions as
obstack_alloc (see section Allocation in an Obstack).
When you build an object by growing it, you will probably need to know
afterward how long it became. You need not keep track of this as you grow
the object, because you can find out the length from the obstack just
before finishing the object with the function obstack_object_size,
declared as follows:
obstack_object_size will return zero.
If you have started growing an object and wish to cancel it, you should finish it and then free it, like this:
obstack_free (obstack_ptr, obstack_finish (obstack_ptr));
This has no effect if no object was growing.
You can use obstack_blank with a negative size argument to make
the current object smaller. Just don't try to shrink it beyond zero
length--there's no telling what will happen if you do that.
The usual functions for growing objects incur overhead for checking whether there is room for the new growth in the current chunk. If you are frequently constructing objects in small steps of growth, this overhead can be significant.
You can reduce the overhead by using special "fast growth" functions that grow the object without checking. In order to have a robust program, you must do the checking yourself. If you do this checking in the simplest way each time you are about to add data to the object, you have not saved anything, because that is what the ordinary growth functions do. But if you can arrange to check less often, or check more efficiently, then you make the program faster.
The function obstack_room returns the amount of room available
in the current chunk. It is declared as follows:
While you know there is room, you can use these fast growth functions for adding data to a growing object:
obstack_1grow_fast adds one byte containing the
character c to the growing object in obstack obstack-ptr.
obstack_ptr_grow_fast adds sizeof (void *)
bytes containing the value of data to the growing object in
obstack obstack-ptr.
obstack_int_grow_fast adds sizeof (int) bytes
containing the value of data to the growing object in obstack
obstack-ptr.
obstack_blank_fast adds size bytes to the
growing object in obstack obstack-ptr without initializing them.
When you check for space using obstack_room and there is not
enough room for what you want to add, the fast growth functions
are not safe. In this case, simply use the corresponding ordinary
growth function instead. Very soon this will copy the object to a
new chunk; then there will be lots of room available again.
So, each time you use an ordinary growth function, check afterward for
sufficient space using obstack_room. Once the object is copied
to a new chunk, there will be plenty of space again, so the program will
start using the fast growth functions again.
Here is an example:
void
add_string (struct obstack *obstack, const char *ptr, int len)
{
while (len > 0)
{
int room = obstack_room (obstack);
if (room == 0)
{
/* Not enough room. Add one character slowly,
which may copy to a new chunk and make room. */
obstack_1grow (obstack, *ptr++);
len--;
}
else
{
if (room > len)
room = len;
/* Add fast as much as we have room for. */
len -= room;
while (room-- > 0)
obstack_1grow_fast (obstack, *ptr++);
}
}
}
Here are functions that provide information on the current status of allocation in an obstack. You can use them to learn about an object while still growing it.
If no object is growing, this value says where the next object you allocate will start (once again assuming it fits in the current chunk).
obstack_next_free
returns the same value as obstack_base.
obstack_next_free (obstack-ptr) - obstack_base (obstack-ptr)
Each obstack has an alignment boundary; each object allocated in the obstack automatically starts on an address that is a multiple of the specified boundary. By default, this boundary is 4 bytes.
To access an obstack's alignment boundary, use the macro
obstack_alignment_mask, whose function prototype looks like
this:
The expansion of the macro obstack_alignment_mask is an lvalue,
so you can alter the mask by assignment. For example, this statement:
obstack_alignment_mask (obstack_ptr) = 0;
has the effect of turning off alignment processing in the specified obstack.
Note that a change in alignment mask does not take effect until
after the next time an object is allocated or finished in the
obstack. If you are not growing an object, you can make the new
alignment mask take effect immediately by calling obstack_finish.
This will finish a zero-length object and then do proper alignment for
the next object.
Obstacks work by allocating space for themselves in large chunks, and then parceling out space in the chunks to satisfy your requests. Chunks are normally 4096 bytes long unless you specify a different chunk size. The chunk size includes 8 bytes of overhead that are not actually used for storing objects. Regardless of the specified size, longer chunks will be allocated when necessary for long objects.
The obstack library allocates chunks by calling the function
obstack_chunk_alloc, which you must define. When a chunk is no
longer needed because you have freed all the objects in it, the obstack
library frees the chunk by calling obstack_chunk_free, which you
must also define.
These two must be defined (as macros) or declared (as functions) in each
source file that uses obstack_init (see section Creating Obstacks).
Most often they are defined as macros like this:
#define obstack_chunk_alloc xmalloc #define obstack_chunk_free free
Note that these are simple macros (no arguments). Macro definitions with
arguments will not work! It is necessary that obstack_chunk_alloc
or obstack_chunk_free, alone, expand into a function name if it is
not itself a function name.
If you allocate chunks with malloc, the chunk size should be a
power of 2. The default chunk size, 4096, was chosen because it is long
enough to satisfy many typical requests on the obstack yet short enough
not to waste too much memory in the portion of the last chunk not yet used.
Since this macro expands to an lvalue, you can specify a new chunk size by assigning it a new value. Doing so does not affect the chunks already allocated, but will change the size of chunks allocated for that particular obstack in the future. It is unlikely to be useful to make the chunk size smaller, but making it larger might improve efficiency if you are allocating many objects whose size is comparable to the chunk size. Here is how to do so cleanly:
if (obstack_chunk_size (obstack_ptr) < new-chunk-size) obstack_chunk_size (obstack_ptr) = new-chunk-size;
Here is a summary of all the functions associated with obstacks. Each
takes the address of an obstack (struct obstack *) as its first
argument.
void obstack_init (struct obstack *obstack-ptr)
void *obstack_alloc (struct obstack *obstack-ptr, int size)
void *obstack_copy (struct obstack *obstack-ptr, void *address, int size)
void *obstack_copy0 (struct obstack *obstack-ptr, void *address, int size)
void obstack_free (struct obstack *obstack-ptr, void *object)
void obstack_blank (struct obstack *obstack-ptr, int size)
void obstack_grow (struct obstack *obstack-ptr, void *address, int size)
void obstack_grow0 (struct obstack *obstack-ptr, void *address, int size)
void obstack_1grow (struct obstack *obstack-ptr, char data-char)
void *obstack_finish (struct obstack *obstack-ptr)
int obstack_object_size (struct obstack *obstack-ptr)
void obstack_blank_fast (struct obstack *obstack-ptr, int size)
void obstack_1grow_fast (struct obstack *obstack-ptr, char data-char)
int obstack_room (struct obstack *obstack-ptr)
int obstack_alignment_mask (struct obstack *obstack-ptr)
int obstack_chunk_size (struct obstack *obstack-ptr)
void *obstack_base (struct obstack *obstack-ptr)
void *obstack_next_free (struct obstack *obstack-ptr)
The function alloca supports a kind of half-dynamic allocation in
which blocks are allocated dynamically but freed automatically.
Allocating a block with alloca is an explicit action; you can
allocate as many blocks as you wish, and compute the size at run time. But
all the blocks are freed when you exit the function that alloca was
called from, just as if they were automatic variables declared in that
function. There is no way to free the space explicitly.
The prototype for alloca is in `stdlib.h'. This function is
a BSD extension.
alloca is the address of a block of size
bytes of storage, allocated in the stack frame of the calling function.
Do not use alloca inside the arguments of a function call--you
will get unpredictable results, because the stack space for the
alloca would appear on the stack in the middle of the space for
the function arguments. An example of what to avoid is foo (x,
alloca (4), y).
alloca Example
As an example of use of alloca, here is a function that opens a file
name made from concatenating two argument strings, and returns a file
descriptor or minus one signifying failure:
int
open2 (char *str1, char *str2, int flags, int mode)
{
char *name = (char *) alloca (strlen (str1) + strlen (str2) + 1);
stpcpy (stpcpy (name, str1), str2);
return open (name, flags, mode);
}
Here is how you would get the same results with malloc and
free:
int
open2 (char *str1, char *str2, int flags, int mode)
{
char *name = (char *) malloc (strlen (str1) + strlen (str2) + 1);
int desc;
if (name == 0)
fatal ("virtual memory exceeded");
stpcpy (stpcpy (name, str1), str2);
desc = open (name, flags, mode);
free (name);
return desc;
}
As you can see, it is simpler with alloca. But alloca has
other, more important advantages, and some disadvantages.
alloca
Here are the reasons why alloca may be preferable to malloc:
alloca wastes very little space and is very fast. (It is
open-coded by the GNU C compiler.)
alloca does not have separate pools for different sizes of
block, space used for any size block can be reused for any other size.
alloca does not cause storage fragmentation.
longjmp (see section Non-Local Exits)
automatically free the space allocated with alloca when they exit
through the function that called alloca. This is the most
important reason to use alloca.
To illustrate this, suppose you have a function
open_or_report_error which returns a descriptor, like
open, if it succeeds, but does not return to its caller if it
fails. If the file cannot be opened, it prints an error message and
jumps out to the command level of your program using longjmp.
Let's change open2 (see section alloca Example) to use this
subroutine:
int
open2 (char *str1, char *str2, int flags, int mode)
{
char *name = (char *) alloca (strlen (str1) + strlen (str2) + 1);
stpcpy (stpcpy (name, str1), str2);
return open_or_report_error (name, flags, mode);
}
Because of the way alloca works, the storage it allocates is
freed even when an error occurs, with no special effort required.
By contrast, the previous definition of open2 (which uses
malloc and free) would develop a storage leak if it were
changed in this way. Even if you are willing to make more changes to
fix it, there is no easy way to do so.
alloca
These are the disadvantages of alloca in comparison with
malloc:
alloca, so it is less
portable. However, a slower emulation of alloca written in C
is available for use on systems with this deficiency.
In GNU C, you can replace most uses of alloca with an array of
variable size. Here is how open2 would look then:
int open2 (char *str1, char *str2, int flags, int mode)
{
char name[strlen (str1) + strlen (str2) + 1];
stpcpy (stpcpy (name, str1), str2);
return open (name, flags, mode);
}
But alloca is not always equivalent to a variable-sized array, for
several reasons:
alloca
remains until the end of the function.
alloca within a loop, allocating an
additional block on each iteration. This is impossible with
variable-sized arrays.
Note: If you mix use of alloca and variable-sized arrays
within one function, exiting a scope in which a variable-sized array was
declared frees all blocks allocated with alloca during the
execution of that scope.
Any system of dynamic memory allocation has overhead: the amount of space it uses is more than the amount the program asks for. The relocating memory allocator achieves very low overhead by moving blocks in memory as necessary, on its own initiative.
When you allocate a block with malloc, the address of the block
never changes unless you use realloc to change its size. Thus,
you can safely store the address in various places, temporarily or
permanently, as you like. This is not safe when you use the relocating
memory allocator, because any and all relocatable blocks can move
whenever you allocate memory in any fashion. Even calling malloc
or realloc can move the relocatable blocks.
For each relocatable block, you must make a handle---a pointer object in memory, designated to store the address of that block. The relocating allocator knows where each block's handle is, and updates the address stored there whenever it moves the block, so that the handle always points to the block. Each time you access the contents of the block, you should fetch its address anew from the handle.
To call any of the relocating allocator functions from a signal handler is almost certainly incorrect, because the signal could happen at any time and relocate all the blocks. The only way to make this safe is to block the signal around any access to the contents of any relocatable block--not a convenient mode of operation. See section Signal Handling and Nonreentrant Functions.
In the descriptions below, handleptr designates the address of the handle. All the functions are declared in `malloc.h'; all are GNU extensions.
*handleptr and returns
a non-null pointer to indicate success.
If r_alloc can't get the space needed, it stores a null pointer
in *handleptr, and returns a null pointer.
*handleptr points to, and stores a null pointer
in *handleptr to show it doesn't point to an allocated
block any more.
r_re_alloc adjusts the size of the block that
*handleptr points to, making it size bytes long. It
stores the address of the resized block in *handleptr and
returns a non-null pointer to indicate success.
If enough memory is not available, this function returns a null pointer
and does not modify *handleptr.
Programs that work with characters and strings often need to classify a character--is it alphabetic, is it a digit, is it whitespace, and so on--and perform case conversion operations on characters. The functions in the header file `ctype.h' are provided for this purpose.
Since the choice of locale and character set can alter the
classifications of particular character codes, all of these functions
are affected by the current locale. (More precisely, they are affected
by the locale currently selected for character classification--the
LC_CTYPE category; see section Categories of Activities that Locales Affect.)
This section explains the library functions for classifying characters.
For example, isalpha is the function to test for an alphabetic
character. It takes one argument, the character to test, and returns a
nonzero integer if the character is alphabetic, and zero otherwise. You
would use it like this:
if (isalpha (c))
printf ("The character `%c' is alphabetic.\n", c);
Each of the functions in this section tests for membership in a
particular class of characters; each has a name starting with `is'.
Each of them takes one argument, which is a character to test, and
returns an int which is treated as a boolean value. The
character argument is passed as an int, and it may be the
constant value EOF instead of a real character.
The attributes of any given character can vary between locales. See section Locales and Internationalization, for more information on locales.
These functions are declared in the header file `ctype.h'.
islower or isupper is true of a character, then
isalpha is also true.
In some locales, there may be additional characters for which
isalpha is true--letters which are neither upper case nor lower
case. But in the standard "C" locale, there are no such
additional characters.
isalpha or isdigit is
true of a character, then isalnum is also true.
"C" locale, isspace returns true for only the standard
whitespace characters:
' '
'\f'
'\n'
'\r'
'\t'
'\v'
unsigned char value that fits
into the US/UK ASCII character set. This function is a BSD extension
and is also an SVID extension.
This section explains the library functions for performing conversions
such as case mappings on characters. For example, toupper
converts any character to upper case if possible. If the character
can't be converted, toupper returns it unchanged.
These functions take one argument of type int, which is the
character to convert, and return the converted character as an
int. If the conversion is not applicable to the argument given,
the argument is returned unchanged.
Compatibility Note: In pre-ISO C dialects, instead of
returning the argument unchanged, these functions may fail when the
argument is not suitable for the conversion. Thus for portability, you
may need to write islower(c) ? toupper(c) : c rather than just
toupper(c).
These functions are declared in the header file `ctype.h'.
tolower returns the corresponding
lower-case letter. If c is not an upper-case letter,
c is returned unchanged.
tolower returns the corresponding
upper-case letter. Otherwise c is returned unchanged.
unsigned char value
that fits into the US/UK ASCII character set, by clearing the high-order
bits. This function is a BSD extension and is also an SVID extension.
tolower, and is provided for compatibility
with the SVID. See section SVID (The System V Interface Description).
toupper, and is provided for compatibility
with the SVID.
Operations on strings (or arrays of characters) are an important part of
many programs. The GNU C library provides an extensive set of string
utility functions, including functions for copying, concatenating,
comparing, and searching strings. Many of these functions can also
operate on arbitrary regions of storage; for example, the memcpy
function can be used to copy the contents of any kind of array.
It's fairly common for beginning C programmers to "reinvent the wheel" by duplicating this functionality in their own code, but it pays to become familiar with the library functions and to make use of them, since this offers benefits in maintenance, efficiency, and portability.
For instance, you could easily compare one string to another in two
lines of C code, but if you use the built-in strcmp function,
you're less likely to make a mistake. And, since these library
functions are typically highly optimized, your program may run faster
too.
This section is a quick summary of string concepts for beginning C programmers. It describes how character strings are represented in C and some common pitfalls. If you are already familiar with this material, you can skip this section.
A string is an array of char objects. But string-valued
variables are usually declared to be pointers of type char *.
Such variables do not include space for the text of a string; that has
to be stored somewhere else--in an array variable, a string constant,
or dynamically allocated memory (see section Memory Allocation). It's up to
you to store the address of the chosen memory space into the pointer
variable. Alternatively you can store a null pointer in the
pointer variable. The null pointer does not point anywhere, so
attempting to reference the string it points to gets an error.
By convention, a null character, '\0', marks the end of a
string. For example, in testing to see whether the char *
variable p points to a null character marking the end of a string,
you can write !*p or *p == '\0'.
A null character is quite different conceptually from a null pointer,
although both are represented by the integer 0.
String literals appear in C program source as strings of
characters between double-quote characters (`"'). In ISO C,
string literals can also be formed by string concatenation:
"a" "b" is the same as "ab". Modification of string
literals is not allowed by the GNU C compiler, because literals
are placed in read-only storage.
Character arrays that are declared const cannot be modified
either. It's generally good style to declare non-modifiable string
pointers to be of type const char *, since this often allows the
C compiler to detect accidental modifications as well as providing some
amount of documentation about what your program intends to do with the
string.
The amount of memory allocated for the character array may extend past the null character that normally marks the end of the string. In this document, the term allocation size is always used to refer to the total amount of memory allocated for the string, while the term length refers to the number of characters up to (but not including) the terminating null character.
A notorious source of program bugs is trying to put more characters in a string than fit in its allocated size. When writing code that extends strings or moves characters into a pre-allocated array, you should be very careful to keep track of the length of the text and make explicit checks for overflowing the array. Many of the library functions do not do this for you! Remember also that you need to allocate an extra byte to hold the null character that marks the end of the string.
This chapter describes both functions that work on arbitrary arrays or blocks of memory, and functions that are specific to null-terminated arrays of characters.
Functions that operate on arbitrary blocks of memory have names
beginning with `mem' (such as memcpy) and invariably take an
argument which specifies the size (in bytes) of the block of memory to
operate on. The array arguments and return values for these functions
have type void *, and as a matter of style, the elements of these
arrays are referred to as "bytes". You can pass any kind of pointer
to these functions, and the sizeof operator is useful in
computing the value for the size argument.
In contrast, functions that operate specifically on strings have names
beginning with `str' (such as strcpy) and look for a null
character to terminate the string instead of requiring an explicit size
argument to be passed. (Some of these functions accept a specified
maximum length, but they also check for premature termination with a
null character.) The array arguments and return values for these
functions have type char *, and the array elements are referred
to as "characters".
In many cases, there are both `mem' and `str' versions of a function. The one that is more appropriate to use depends on the exact situation. When your program is manipulating arbitrary arrays or blocks of storage, then you should always use the `mem' functions. On the other hand, when you are manipulating null-terminated strings it is usually more convenient to use the `str' functions, unless you already know the length of the string in advance.
You can get the length of a string using the strlen function.
This function is declared in the header file `string.h'.
strlen function returns the length of the null-terminated
string s. (In other words, it returns the offset of the terminating
null character within the array.)
For example,
strlen ("hello, world")
=> 12
When applied to a character array, the strlen function returns
the length of the string stored there, not its allocation size. You can
get the allocation size of the character array that holds a string using
the sizeof operator:
char string[32] = "hello, world";
sizeof (string)
=> 32
strlen (string)
=> 12
You can use the functions described in this section to copy the contents of strings and arrays, or to append the contents of one string to another. These functions are declared in the header file `string.h'.
A helpful way to remember the ordering of the arguments to the functions in this section is that it corresponds to an assignment expression, with the destination array specified to the left of the source array. All of these functions return the address of the destination array.
Most of these functions do not work properly if the source and destination arrays overlap. For example, if the beginning of the destination array overlaps the end of the source array, the original contents of that part of the source array may get overwritten before it is copied. Even worse, in the case of the string functions, the null character marking the end of the string may be lost, and the copy function might get stuck in a loop trashing all the memory allocated to your program.
All functions that have problems copying between overlapping arrays are
explicitly identified in this manual. In addition to functions in this
section, there are a few others like sprintf (see section Formatted Output Functions) and scanf (see section Formatted Input Functions).
memcpy function copies size bytes from the object
beginning at from into the object beginning at to. The
behavior of this function is undefined if the two arrays to and
from overlap; use memmove instead if overlapping is possible.
The value returned by memcpy is the value of to.
Here is an example of how you might use memcpy to copy the
contents of an array:
struct foo *oldarray, *newarray; int arraysize; ... memcpy (new, old, arraysize * sizeof (struct foo));
memmove copies the size bytes at from into the
size bytes at to, even if those two blocks of space
overlap. In the case of overlap, memmove is careful to copy the
original values of the bytes in the block at from, including those
bytes which also belong to the block at to.
unsigned char) into each of the first size bytes of the
object beginning at block. It returns the value of block.
memcpy, this function has undefined results if the strings
overlap. The return value is the value of to.
strcpy but always copies exactly
size characters into to.
If the length of from is more than size, then strncpy
copies just the first size characters. Note that in this case
there is no null terminator written into to.
If the length of from is less than size, then strncpy
copies all of from, followed by enough null characters to add up
to size characters in all. This behavior is rarely useful, but it
is specified by the ISO C standard.
The behavior of strncpy is undefined if the strings overlap.
Using strncpy as opposed to strcpy is a way to avoid bugs
relating to writing past the end of the allocated space for to.
However, it can also make your program much slower in one common case:
copying a string which is probably small into a potentially large buffer.
In this case, size may be large, and when it is, strncpy will
waste a considerable amount of time copying null characters.
malloc; see
section Unconstrained Allocation. If malloc cannot allocate space
for the new string, strdup returns a null pointer. Otherwise it
returns a pointer to the new string.
strdup but always copies at most
size characters into the newly allocated string.
If the length of s is more than size, then strndup
copies just the first size characters and adds a closing null
terminator. Otherwise all characters are copied and the string is
terminated.
This function is different to strncpy in that it always
terminates the destination string.
strcpy, except that it returns a pointer to
the end of the string to (that is, the address of the terminating
null character) rather than the beginning.
For example, this program uses stpcpy to concatenate `foo'
and `bar' to produce `foobar', which it then prints.
#include <string.h>
#include <stdio.h>
int
main (void)
{
char buffer[10];
char *to = buffer;
to = stpcpy (to, "foo");
to = stpcpy (to, "bar");
puts (buffer);
return 0;
}
This function is not part of the ISO or POSIX standards, and is not customary on Unix systems, but we did not invent it either. Perhaps it comes from MS-DOG.
Its behavior is undefined if the strings overlap.
stpcpy but copies always exactly
size characters into to.
If the length of from is more then size, then stpncpy
copies just the first size characters and returns a pointer to the
character directly following the one which was copied last. Note that in
this case there is no null terminator written into to.
If the length of from is less than size, then stpncpy
copies all of from, followed by enough null characters to add up
to size characters in all. This behaviour is rarely useful, but it
is implemented to be useful in contexts where this behaviour of the
strncpy is used. stpncpy returns a pointer to the
first written null character.
This function is not part of ISO or POSIX but was found useful while developing GNU C Library itself.
Its behaviour is undefined if the strings overlap.
strdup but allocates the new string
using alloca instead of malloc
see section Automatic Storage with Variable Size. This means of course the returned
string has the same limitations as any block of memory allocated using
alloca.
For obvious reasons strdupa is implemented only as a macro. I.e.,
you cannot get the address of this function. Despite this limitations
it is a useful function. The following code shows a situation where
using malloc would be a lot more expensive.
#include <paths.h>
#include <string.h>
#include <stdio.h>
const char path[] = _PATH_STDPATH;
int
main (void)
{
char *wr_path = strdupa (path);
char *cp = strtok (wr_path, ":");
while (cp != NULL)
{
puts (cp);
cp = strtok (NULL, ":");
}
return 0;
}
Please note that calling strtok using path directly is
illegal.
This function is only available if GNU CC is used.
strndup but like strdupa it
allocates the new string using alloca
see section Automatic Storage with Variable Size. The same advantages and limitations
of strdupa are valid for strndupa, too.
This function is implemented only as a macro which means one cannot get the address of it.
strndupa is only available if GNU CC is used.
strcat function is similar to strcpy, except that the
characters from from are concatenated or appended to the end of
to, instead of overwriting it. That is, the first character from
from overwrites the null character marking the end of to.
An equivalent definition for strcat would be:
char *
strcat (char *to, const char *from)
{
strcpy (to + strlen (to), from);
return to;
}
This function has undefined results if the strings overlap.
strcat except that not more than size
characters from from are appended to the end of to. A
single null character is also always appended to to, so the total
allocated size of to must be at least size + 1 bytes
longer than its initial length.
The strncat function could be implemented like this:
char *
strncat (char *to, const char *from, size_t size)
{
strncpy (to + strlen (to), from, size);
return to;
}
The behavior of strncat is undefined if the strings overlap.
Here is an example showing the use of strncpy and strncat.
Notice how, in the call to strncat, the size parameter
is computed to avoid overflowing the character array buffer.
#include <string.h>
#include <stdio.h>
#define SIZE 10
static char buffer[SIZE];
main ()
{
strncpy (buffer, "hello", SIZE);
puts (buffer);
strncat (buffer, ", world", SIZE - strlen (buffer) - 1);
puts (buffer);
}
The output produced by this program looks like:
hello hello, wo
memmove, derived from
BSD. Note that it is not quite equivalent to memmove, because the
arguments are not in the same order.
memset, derived from
BSD. Note that it is not as general as memset, because the only
value it can store is zero.
You can use the functions in this section to perform comparisons on the contents of strings and arrays. As well as checking for equality, these functions can also be used as the ordering functions for sorting operations. See section Searching and Sorting, for an example of this.
Unlike most comparison operations in C, the string comparison functions return a nonzero value if the strings are not equivalent rather than if they are. The sign of the value indicates the relative ordering of the first characters in the strings that are not equivalent: a negative value indicates that the first string is "less" than the second, while a positive value indicates that the first string is "greater".
The most common use of these functions is to check only for equality. This is canonically done with an expression like `! strcmp (s1, s2)'.
All of these functions are declared in the header file `string.h'.
memcmp compares the size bytes of memory
beginning at a1 against the size bytes of memory beginning
at a2. The value returned has the same sign as the difference
between the first differing pair of bytes (interpreted as unsigned
char objects, then promoted to int).
If the contents of the two blocks are equal, memcmp returns
0.
On arbitrary arrays, the memcmp function is mostly useful for
testing equality. It usually isn't meaningful to do byte-wise ordering
comparisons on arrays of things other than bytes. For example, a
byte-wise comparison on the bytes that make up floating-point numbers
isn't likely to tell you anything about the relationship between the
values of the floating-point numbers.
You should also be careful about using memcmp to compare objects
that can contain "holes", such as the padding inserted into structure
objects to enforce alignment requirements, extra space at the end of
unions, and extra characters at the ends of strings whose length is less
than their allocated size. The contents of these "holes" are
indeterminate and may cause strange behavior when performing byte-wise
comparisons. For more predictable results, perform an explicit
component-wise comparison.
For example, given a structure type definition like:
struct foo
{
unsigned char tag;
union
{
double f;
long i;
char *p;
} value;
};
you are better off writing a specialized comparison function to compare
struct foo objects instead of comparing them with memcmp.
strcmp function compares the string s1 against
s2, returning a value that has the same sign as the difference
between the first differing pair of characters (interpreted as
unsigned char objects, then promoted to int).
If the two strings are equal, strcmp returns 0.
A consequence of the ordering used by strcmp is that if s1
is an initial substring of s2, then s1 is considered to be
"less than" s2.
strcmp, except that differences in case
are ignored.
strcasecmp is derived from BSD.
strncmp, except that differences in case
are ignored.
strncasecmp is a GNU extension.
strcmp, except that no more than
size characters are compared. In other words, if the two strings are
the same in their first size characters, the return value is zero.
Here are some examples showing the use of strcmp and strncmp.
These examples assume the use of the ASCII character set. (If some
other character set--say, EBCDIC--is used instead, then the glyphs
are associated with different numeric codes, and the return values
and ordering may differ.)
strcmp ("hello", "hello")
=> 0 /* These two strings are the same. */
strcmp ("hello", "Hello")
=> 32 /* Comparisons are case-sensitive. */
strcmp ("hello", "world")
=> -15 /* The character 'h' comes before 'w'. */
strcmp ("hello", "hello, world")
=> -44 /* Comparing a null character against a comma. */
strncmp ("hello", "hello, world", 5)
=> 0 /* The initial 5 characters are the same. */
strncmp ("hello, world", "hello, stupid world!!!", 5)
=> 0 /* The initial 5 characters are the same. */
memcmp, derived from BSD.
In some locales, the conventions for lexicographic ordering differ from the strict numeric ordering of character codes. For example, in Spanish most glyphs with diacritical marks such as accents are not considered distinct letters for the purposes of collation. On the other hand, the two-character sequence `ll' is treated as a single letter that is collated immediately after `l'.
You can use the functions strcoll and strxfrm (declared in
the header file `string.h') to compare strings using a collation
ordering appropriate for the current locale. The locale used by these
functions in particular can be specified by setting the locale for the
LC_COLLATE category; see section Locales and Internationalization.
In the standard C locale, the collation sequence for strcoll is
the same as that for strcmp.
Effectively, the way these functions work is by applying a mapping to transform the characters in a string to a byte sequence that represents the string's position in the collating sequence of the current locale. Comparing two such byte sequences in a simple fashion is equivalent to comparing the strings with the locale's collating sequence.
The function strcoll performs this translation implicitly, in
order to do one comparison. By contrast, strxfrm performs the
mapping explicitly. If you are making multiple comparisons using the
same string or set of strings, it is likely to be more efficient to use
strxfrm to transform all the strings just once, and subsequently
compare the transformed strings with strcmp.
strcoll function is similar to strcmp but uses the
collating sequence of the current locale for collation (the
LC_COLLATE locale).
Here is an example of sorting an array of strings, using strcoll
to compare them. The actual sort algorithm is not written here; it
comes from qsort (see section Array Sort Function). The job of the
code shown here is to say how to compare the strings while sorting them.
(Later on in this section, we will show a way to do this more
efficiently using strxfrm.)
/* This is the comparison function used withqsort. */ int compare_elements (char **p1, char **p2) { return strcoll (*p1, *p2); } /* This is the entry point---the function to sort strings using the locale's collating sequence. */ void sort_strings (char **array, int nstrings) { /* Sorttemp_arrayby comparing the strings. */ qsort (array, sizeof (char *), nstrings, compare_elements); }
strxfrm transforms string using the collation
transformation determined by the locale currently selected for
collation, and stores the transformed string in the array to. Up
to size characters (including a terminating null character) are
stored.
The behavior is undefined if the strings to and from overlap; see section Copying and Concatenation.
The return value is the length of the entire transformed string. This
value is not affected by the value of size, but if it is greater
or equal than size, it means that the transformed string did not
entirely fit in the array to. In this case, only as much of the
string as actually fits was stored. To get the whole transformed
string, call strxfrm again with a bigger output array.
The transformed string may be longer than the original string, and it may also be shorter.
If size is zero, no characters are stored in to. In this
case, strxfrm simply returns the number of characters that would
be the length of the transformed string. This is useful for determining
what size string to allocate. It does not matter what to is if
size is zero; to may even be a null pointer.
Here is an example of how you can use strxfrm when
you plan to do many comparisons. It does the same thing as the previous
example, but much faster, because it has to transform each string only
once, no matter how many times it is compared with other strings. Even
the time needed to allocate and free storage is much less than the time
we save, when there are many strings.
struct sorter { char *input; char *transformed; };
/* This is the comparison function used with qsort
to sort an array of struct sorter. */
int
compare_elements (struct sorter *p1, struct sorter *p2)
{
return strcmp (p1->transformed, p2->transformed);
}
/* This is the entry point---the function to sort
strings using the locale's collating sequence. */
void
sort_strings_fast (char **array, int nstrings)
{
struct sorter temp_array[nstrings];
int i;
/* Set up temp_array. Each element contains
one input string and its transformed string. */
for (i = 0; i < nstrings; i++)
{
size_t length = strlen (array[i]) * 2;
char *transformed;
size_t transformed_lenght;
temp_array[i].input = array[i];
/* First try a buffer perhaps big enough. */
transformed = (char *) xmalloc (length);
/* Transform array[i]. */
transformed_length = strxfrm (transformed, array[i], length);
/* If the buffer was not large enough, resize it
and try again. */
if (transformed_length >= length)
{
/* Allocate the needed space. +1 for terminating
NUL character. */
transformed = (char *) xrealloc (transformed,
transformed_length + 1);
/* The return value is not interesting because we know
how long the transformed string is. */
(void) strxfrm (transformed, array[i], transformed_length + 1);
}
temp_array[i].transformed = transformed;
}
/* Sort temp_array by comparing transformed strings. */
qsort (temp_array, sizeof (struct sorter),
nstrings, compare_elements);
/* Put the elements back in the permanent array
in their sorted order. */
for (i = 0; i < nstrings; i++)
array[i] = temp_array[i].input;
/* Free the strings we allocated. */
for (i = 0; i < nstrings; i++)
free (temp_array[i].transformed);
}
Compatibility Note: The string collation functions are a new feature of ISO C. Older C dialects have no equivalent feature.
This section describes library functions which perform various kinds of searching operations on strings and arrays. These functions are declared in the header file `string.h'.
unsigned char) in the initial size bytes of the
object beginning at block. The return value is a pointer to the
located byte, or a null pointer if no match was found.
strchr function finds the first occurrence of the character
c (converted to a char) in the null-terminated string
beginning at string. The return value is a pointer to the located
character, or a null pointer if no match was found.
For example,
strchr ("hello, world", 'l')
=> "llo, world"
strchr ("hello, world", '?')
=> NULL
The terminating null character is considered to be part of the string, so you can use this function get a pointer to the end of a string by specifying a null character as the value of the c argument.
index is another name for strchr; they are exactly the same.
strrchr is like strchr, except that it searches
backwards from the end of the string string (instead of forwards
from the front).
For example,
strrchr ("hello, world", 'l')
=> "ld"
rindex is another name for strrchr; they are exactly the same.
strchr, except that it searches haystack for a
substring needle rather than just a single character. It
returns a pointer into the string haystack that is the first
character of the substring, or a null pointer if no match was found. If
needle is an empty string, the function returns haystack.
For example,
strstr ("hello, world", "l")
=> "llo, world"
strstr ("hello, world", "wo")
=> "world"
strstr, but needle and haystack are byte
arrays rather than null-terminated strings. needle-len is the
length of needle and haystack-len is the length of
haystack.
This function is a GNU extension.
strspn ("string span") function returns the length of the
initial substring of string that consists entirely of characters that
are members of the set specified by the string skipset. The order
of the characters in skipset is not important.
For example,
strspn ("hello, world", "abcdefghijklmnopqrstuvwxyz")
=> 5
strcspn ("string complement span") function returns the length
of the initial substring of string that consists entirely of characters
that are not members of the set specified by the string stopset.
(In other words, it returns the offset of the first character in string
that is a member of the set stopset.)
For example,
strcspn ("hello, world", " \t\n,.;!?")
=> 5
strpbrk ("string pointer break") function is related to
strcspn, except that it returns a pointer to the first character
in string that is a member of the set stopset instead of the
length of the initial substring. It returns a null pointer if no such
character from stopset is found.
For example,
strpbrk ("hello, world", " \t\n,.;!?")
=> ", world"
It's fairly common for programs to have a need to do some simple kinds
of lexical analysis and parsing, such as splitting a command string up
into tokens. You can do this with the strtok function, declared
in the header file `string.h'.
strtok.
The string to be split up is passed as the newstring argument on
the first call only. The strtok function uses this to set up
some internal state information. Subsequent calls to get additional
tokens from the same string are indicated by passing a null pointer as
the newstring argument. Calling strtok with another
non-null newstring argument reinitializes the state information.
It is guaranteed that no other library function ever calls strtok
behind your back (which would mess up this internal state information).
The delimiters argument is a string that specifies a set of delimiters that may surround the token being extracted. All the initial characters that are members of this set are discarded. The first character that is not a member of this set of delimiters marks the beginning of the next token. The end of the token is found by looking for the next character that is a member of the delimiter set. This character in the original string newstring is overwritten by a null character, and the pointer to the beginning of the token in newstring is returned.
On the next call to strtok, the searching begins at the next
character beyond the one that marked the end of the previous token.
Note that the set of delimiters delimiters do not have to be the
same on every call in a series of calls to strtok.
If the end of the string newstring is reached, or if the remainder of
string consists only of delimiter characters, strtok returns
a null pointer.
Warning: Since strtok alters the string it is parsing,
you always copy the string to a temporary buffer before parsing it with
strtok. If you allow strtok to modify a string that came
from another part of your program, you are asking for trouble; that
string may be part of a data structure that could be used for other
purposes during the parsing, when alteration by strtok makes the
data structure temporarily inaccurate.
The string that you are operating on might even be a constant. Then
when strtok tries to modify it, your program will get a fatal
signal for writing in read-only memory. See section Program Error Signals.
This is a special case of a general principle: if a part of a program does not have as its purpose the modification of a certain data structure, then it is error-prone to modify the data structure temporarily.
The function strtok is not reentrant. See section Signal Handling and Nonreentrant Functions, for
a discussion of where and why reentrancy is important.
Here is a simple example showing the use of strtok.
#include <string.h> #include <stddef.h> ... char string[] = "words separated by spaces -- and, punctuation!"; const char delimiters[] = " .,;:!-"; char *token; ... token = strtok (string, delimiters); /* token => "words" */ token = strtok (NULL, delimiters); /* token => "separated" */ token = strtok (NULL, delimiters); /* token => "by" */ token = strtok (NULL, delimiters); /* token => "spaces" */ token = strtok (NULL, delimiters); /* token => "and" */ token = strtok (NULL, delimiters); /* token => "punctuation" */ token = strtok (NULL, delimiters); /* token => NULL */
The GNU C library contains two more functions for tokenizing a string which overcome the limitation of non-reentrancy.
strtok this function splits the string into several
tokens which can be accessed be successive calls to strtok_r.
The difference is that the information about the next token is not set
up in some internal state information. Instead the caller has to
provide another argument save_ptr which is a pointer to a string
pointer. Calling strtok_r with a null pointer for
newstring and leaving save_ptr between the calls unchanged
does the job without limiting reentrancy.
This function was proposed for POSIX.1b and can be found on many systems which support multi-threading.
strsep move the pointer along the tokens
separated by delimiter, returning the address of the next token
and updating string_ptr to point to the beginning of the next
token.
This function was introduced in 4.3BSD and therefore is widely available.
Here is how the above example looks like when strsep is used.
#include <string.h> #include <stddef.h> ... char string[] = "words separated by spaces -- and, punctuation!"; const char delimiters[] = " .,;:!-"; char *running; char *token; ... running = string; token = strsep (&running, delimiters); /* token => "words" */ token = strsep (&running, delimiters); /* token => "separated" */ token = strsep (&running, delimiters); /* token => "by" */ token = strsep (&running, delimiters); /* token => "spaces" */ token = strsep (&running, delimiters); /* token => "and" */ token = strsep (&running, delimiters); /* token => "punctuation" */ token = strsep (&running, delimiters); /* token => NULL */
Most programs need to do either input (reading data) or output (writing data), or most frequently both, in order to do anything useful. The GNU C library provides such a large selection of input and output functions that the hardest part is often deciding which function is most appropriate!
This chapter introduces concepts and terminology relating to input and output. Other chapters relating to the GNU I/O facilities are:
Before you can read or write the contents of a file, you must establish a connection or communications channel to the file. This process is called opening the file. You can open a file for reading, writing, or both.
The connection to an open file is represented either as a stream or as a file descriptor. You pass this as an argument to the functions that do the actual read or write operations, to tell them which file to operate on. Certain functions expect streams, and others are designed to operate on file descriptors.
When you have finished reading to or writing from the file, you can terminate the connection by closing the file. Once you have closed a stream or file descriptor, you cannot do any more input or output operations on it.
When you want to do input or output to a file, you have a choice of two
basic mechanisms for representing the connection between your program
and the file: file descriptors and streams. File descriptors are
represented as objects of type int, while streams are represented
as FILE * objects.
File descriptors provide a primitive, low-level interface to input and output operations. Both file descriptors and streams can represent a connection to a device (such as a terminal), or a pipe or socket for communicating with another process, as well as a normal file. But, if you want to do control operations that are specific to a particular kind of device, you must use a file descriptor; there are no facilities to use streams in this way. You must also use file descriptors if your program needs to do input or output in special modes, such as nonblocking (or polled) input (see section File Status Flags).
Streams provide a higher-level interface, layered on top of the primitive file descriptor facilities. The stream interface treats all kinds of files pretty much alike--the sole exception being the three styles of buffering that you can choose (see section Stream Buffering).
The main advantage of using the stream interface is that the set of
functions for performing actual input and output operations (as opposed
to control operations) on streams is much richer and more powerful than
the corresponding facilities for file descriptors. The file descriptor
interface provides only simple functions for transferring blocks of
characters, but the stream interface also provides powerful formatted
input and output functions (printf and scanf) as well as
functions for character- and line-oriented input and output.
Since streams are implemented in terms of file descriptors, you can extract the file descriptor from a stream and perform low-level operations directly on the file descriptor. You can also initially open a connection as a file descriptor and then make a stream associated with that file descriptor.
In general, you should stick with using streams rather than file descriptors, unless there is some specific operation you want to do that can only be done on a file descriptor. If you are a beginning programmer and aren't sure what functions to use, we suggest that you concentrate on the formatted input functions (see section Formatted Input) and formatted output functions (see section Formatted Output).
If you are concerned about portability of your programs to systems other than GNU, you should also be aware that file descriptors are not as portable as streams. You can expect any system running ISO C to support streams, but non-GNU systems may not support file descriptors at all, or may only implement a subset of the GNU functions that operate on file descriptors. Most of the file descriptor functions in the GNU library are included in the POSIX.1 standard, however.
One of the attributes of an open file is its file position that keeps track of where in the file the next character is to be read or written. In the GNU system, and all POSIX.1 systems, the file position is simply an integer representing the number of bytes from the beginning of the file.
The file position is normally set to the beginning of the file when it is opened, and each time a character is read or written, the file position is incremented. In other words, access to the file is normally sequential.
Ordinary files permit read or write operations at any position within
the file. Some other kinds of files may also permit this. Files which
do permit this are sometimes referred to as random-access files.
You can change the file position using the fseek function on a
stream (see section File Positioning) or the lseek function on a file
descriptor (see section Input and Output Primitives). If you try to change the file
position on a file that doesn't support random access, you get the
ESPIPE error.
Streams and descriptors that are opened for append access are treated specially for output: output to such files is always appended sequentially to the end of the file, regardless of the file position. However, the file position is still used to control where in the file reading is done.
If you think about it, you'll realize that several programs can read a given file at the same time. In order for each program to be able to read the file at its own pace, each program must have its own file pointer, which is not affected by anything the other programs do.
In fact, each opening of a file creates a separate file position. Thus, if you open a file twice even in the same program, you get two streams or descriptors with independent file positions.
By contrast, if you open a descriptor and then duplicate it to get another descriptor, these two descriptors share the same file position: changing the file position of one descriptor will affect the other.
In order to open a connection to a file, or to perform other operations such as deleting a file, you need some way to refer to the file. Nearly all files have names that are strings--even files which are actually devices such as tape drives or terminals. These strings are called file names. You specify the file name to say which file you want to open or operate on.
This section describes the conventions for file names and how the operating system works with them.
In order to understand the syntax of file names, you need to understand how the file system is organized into a hierarchy of directories.
A directory is a file that contains information to associate other files with names; these associations are called links or directory entries. Sometimes, people speak of "files in a directory", but in reality, a directory only contains pointers to files, not the files themselves.
The name of a file contained in a directory entry is called a file name component. In general, a file name consists of a sequence of one or more such components, separated by the slash character (`/'). A file name which is just one component names a file with respect to its directory. A file name with multiple components names a directory, and then a file in that directory, and so on.
Some other documents, such as the POSIX standard, use the term
pathname for what we call a file name, and either filename
or pathname component for what this manual calls a file name
component. We don't use this terminology because a "path" is
something completely different (a list of directories to search), and we
think that "pathname" used for something else will confuse users. We
always use "file name" and "file name component" (or sometimes just
"component", where the context is obvious) in GNU documentation. Some
macros use the POSIX terminology in their names, such as
PATH_MAX. These macros are defined by the POSIX standard, so we
cannot change their names.
You can find more detailed information about operations on directories in section File System Interface.
A file name consists of file name components separated by slash (`/') characters. On the systems that the GNU C library supports, multiple successive `/' characters are equivalent to a single `/' character.
The process of determining what file a file name refers to is called file name resolution. This is performed by examining the components that make up a file name in left-to-right order, and locating each successive component in the directory named by the previous component. Of course, each of the files that are referenced as directories must actually exist, be directories instead of regular files, and have the appropriate permissions to be accessible by the process; otherwise the file name resolution fails.
If a file name begins with a `/', the first component in the file name is located in the root directory of the process (usually all processes on the system have the same root directory). Such a file name is called an absolute file name.
Otherwise, the first component in the file name is located in the current working directory (see section Working Directory). This kind of file name is called a relative file name.
The file name components `.' ("dot") and `..' ("dot-dot") have special meanings. Every directory has entries for these file name components. The file name component `.' refers to the directory itself, while the file name component `..' refers to its parent directory (the directory that contains the link for the directory in question). As a special case, `..' in the root directory refers to the root directory itself, since it has no parent; thus `/..' is the same as `/'.
Here are some examples of file names:
A file name that names a directory may optionally end in a `/'. You can specify a file name of `/' to refer to the root directory, but the empty string is not a meaningful file name. If you want to refer to the current working directory, use a file name of `.' or `./'.
Unlike some other operating systems, the GNU system doesn't have any built-in support for file types (or extensions) or file versions as part of its file name syntax. Many programs and utilities use conventions for file names--for example, files containing C source code usually have names suffixed with `.c'---but there is nothing in the file system itself that enforces this kind of convention.
Functions that accept file name arguments usually detect these
errno error conditions relating to the file name syntax or
trouble finding the named file. These errors are referred to throughout
this manual as the usual file name errors.
EACCES
ENAMETOOLONG
PATH_MAX, or when an individual file name component
has a length greater than NAME_MAX. See section Limits on File System Capacity.
In the GNU system, there is no imposed limit on overall file name
length, but some file systems may place limits on the length of a
component.
ENOENT
ENOTDIR
ELOOP
The rules for the syntax of file names discussed in section File Names, are the rules normally used by the GNU system and by other POSIX systems. However, other operating systems may use other conventions.
There are two reasons why it can be important for you to be aware of file name portability issues:
The ISO C standard says very little about file name syntax, only that file names are strings. In addition to varying restrictions on the length of file names and what characters can validly appear in a file name, different operating systems use different conventions and syntax for concepts such as structured directories and file types or extensions. Some concepts such as file versions might be supported in some operating systems and not by others.
The POSIX.1 standard allows implementations to put additional restrictions on file name syntax, concerning what characters are permitted in file names and on the length of file name and file name component strings. However, in the GNU system, you do not need to worry about these restrictions; any character except the null character is permitted in a file name string, and there are no limits on the length of file name strings.
This chapter describes the functions for creating streams and performing input and output operations on them. As discussed in section Input/Output Overview, a stream is a fairly abstract, high-level concept representing a communications channel to a file, device, or process.
For historical reasons, the type of the C data structure that represents
a stream is called FILE rather than "stream". Since most of
the library functions deal with objects of type FILE *, sometimes
the term file pointer is also used to mean "stream". This leads
to unfortunate confusion over terminology in many books on C. This
manual, however, is careful to use the terms "file" and "stream"
only in the technical sense.
The FILE type is declared in the header file `stdio.h'.
FILE
object holds all of the internal state information about the connection
to the associated file, including such things as the file position
indicator and buffering information. Each stream also has error and
end-of-file status indicators that can be tested with the ferror
and feof functions; see section End-Of-File and Errors.
FILE objects are allocated and managed internally by the
input/output library functions. Don't try to create your own objects of
type FILE; let the library do it. Your programs should
deal only with pointers to these objects (that is, FILE * values)
rather than the objects themselves.
When the main function of your program is invoked, it already has
three predefined streams open and available for use. These represent
the "standard" input and output channels that have been established
for the process.
These streams are declared in the header file `stdio.h'.
In the GNU system, you can specify what files or processes correspond to these streams using the pipe and redirection facilities provided by the shell. (The primitives shells use to implement these facilities are described in section File System Interface.) Most other operating systems provide similar mechanisms, but the details of how to use them can vary.
In the GNU C library, stdin, stdout, and stderr are
normal variables which you can set just like any others. For example, to redirect
the standard output to a file, you could do:
fclose (stdout);
stdout = fopen ("standard-output-file", "w");
Note however, that in other systems stdin, stdout, and
stderr are macros that you cannot assign to in the normal way.
But you can use freopen to get the effect of closing one and
reopening it. See section Opening Streams.
Opening a file with the fopen function creates a new stream and
establishes a connection between the stream and a file. This may
involve creating a new file.
Everything described in this section is declared in the header file `stdio.h'.
fopen function opens a stream for I/O to the file
filename, and returns a pointer to the stream.
The opentype argument is a string that controls how the file is opened and specifies attributes of the resulting stream. It must begin with one of the following sequences of characters:
As you can see, `+' requests a stream that can do both input and
output. The ISO standard says that when using such a stream, you must
call fflush (see section Stream Buffering) or a file positioning
function such as fseek (see section File Positioning) when switching
from reading to writing or vice versa. Otherwise, internal buffers
might not be emptied properly. The GNU C library does not have this
limitation; you can do arbitrary reading and writing operations on a
stream in whatever order.
Additional characters may appear after these to specify flags for the call. Always put the mode (`r', `w+', etc.) first; that is the only part you are guaranteed will be understood by all systems.
The GNU C library defines one additional character for use in
opentype: the character `x' insists on creating a new
file--if a file filename already exists, fopen fails
rather than opening it. If you use `x' you can are guaranteed that
you will not clobber an existing file. This is equivalent to the
O_EXCL option to the open function (see section Opening and Closing Files).
The character `b' in opentype has a standard meaning; it requests a binary stream rather than a text stream. But this makes no difference in POSIX systems (including the GNU system). If both `+' and `b' are specified, they can appear in either order. See section Text and Binary Streams.
Any other characters in opentype are simply ignored. They may be meaningful in other systems.
If the open fails, fopen returns a null pointer.
You can have multiple streams (or file descriptors) pointing to the same file open at the same time. If you do only input, this works straightforwardly, but you must be careful if any output streams are included. See section Dangers of Mixing Streams and Descriptors. This is equally true whether the streams are in one program (not usual) or in several programs (which can easily happen). It may be advantageous to use the file locking facilities to avoid simultaneous access. See section File Locks.
stdin, stdout, and stderr. In POSIX.1 systems this
value is determined by the OPEN_MAX parameter; see section General Capacity Limits. In BSD and GNU, it is controlled by the RLIMIT_NOFILE
resource limit; see section Limiting Resource Usage.
fclose and fopen.
It first closes the stream referred to by stream, ignoring any
errors that are detected in the process. (Because errors are ignored,
you should not use freopen on an output stream if you have
actually done any output using the stream.) Then the file named by
filename is opened with mode opentype as for fopen,
and associated with the same stream object stream.
If the operation fails, a null pointer is returned; otherwise,
freopen returns stream.
freopen has traditionally been used to connect a standard stream
such as stdin with a file of your own choice. This is useful in
programs in which use of a standard stream for certain purposes is
hard-coded. In the GNU C library, you can simply close the standard
streams and open new ones with fopen. But other systems lack
this ability, so using freopen is more portable.
When a stream is closed with fclose, the connection between the
stream and the file is cancelled. After you have closed a stream, you
cannot perform any additional operations on it.
fclose function returns
a value of 0 if the file was closed successfully, and EOF
if an error was detected.
It is important to check for errors when you call fclose to close
an output stream, because real, everyday errors can be detected at this
time. For example, when fclose writes the remaining buffered
output, it might get an error because the disk is full. Even if you
know the buffer is empty, errors can still occur when closing a file if
you are using NFS.
The function fclose is declared in `stdio.h'.
To close all streams currently available the GNU C Library provides another function.
fcloseall
function returns a value of 0 if all the files were closed
successfully, and EOF if an error was detected.
This function should be used in only in special situation, e.g., when an error occurred and the program must be aborted. Normally each single stream should be closed separately so that problems with one stream can be identifier. It is also problematic since the standard streams (see section Standard Streams) will also be closed.
The function fcloseall is declared in `stdio.h'.
If the main function to your program returns, or if you call the
exit function (see section Normal Termination), all open streams are
automatically closed properly. If your program terminates in any other
manner, such as by calling the abort function (see section Aborting a Program) or from a fatal signal (see section Signal Handling), open streams
might not be closed properly. Buffered output might not be flushed and
files may be incomplete. For more information on buffering of streams,
see section Stream Buffering.
This section describes functions for performing character- and line-oriented output.
These functions are declared in the header file `stdio.h'.
fputc function converts the character c to type
unsigned char, and writes it to the stream stream.
EOF is returned if a write error occurs; otherwise the
character c is returned.
fputc, except that most systems implement it as
a macro, making it faster. One consequence is that it may evaluate the
stream argument more than once, which is an exception to the
general rule for macros. putc is usually the best function to
use for writing a single character.
putchar function is equivalent to putc with
stdout as the value of the stream argument.
fputs writes the string s to the stream
stream. The terminating null character is not written.
This function does not add a newline character, either.
It outputs only the characters in the string.
This function returns EOF if a write error occurs, and otherwise
a non-negative value.
For example:
fputs ("Are ", stdout);
fputs ("you ", stdout);
fputs ("hungry?\n", stdout);
outputs the text `Are you hungry?' followed by a newline.
puts function writes the string s to the stream
stdout followed by a newline. The terminating null character of
the string is not written. (Note that fputs does not
write a newline as this function does.)
puts is the most convenient function for printing simple
messages. For example:
puts ("This is a message.");
int) to
stream. It is provided for compatibility with SVID, but we
recommend you use fwrite instead (see section Block Input/Output).
This section describes functions for performing character-oriented input. These functions are declared in the header file `stdio.h'.
These functions return an int value that is either a character of
input, or the special value EOF (usually -1). It is important to
store the result of these functions in a variable of type int
instead of char, even when you plan to use it only as a
character. Storing EOF in a char variable truncates its
value to the size of a character, so that it is no longer
distinguishable from the valid character `(char) -1'. So always
use an int for the result of getc and friends, and check
for EOF after the call; once you've verified that the result is
not EOF, you can be sure that it will fit in a `char'
variable without loss of information.
unsigned char from
the stream stream and returns its value, converted to an
int. If an end-of-file condition or read error occurs,
EOF is returned instead.
fgetc, except that it is permissible (and
typical) for it to be implemented as a macro that evaluates the
stream argument more than once. getc is often highly
optimized, so it is usually the best function to use to read a single
character.
getchar function is equivalent to getc with stdin
as the value of the stream argument.
Here is an example of a function that does input using fgetc. It
would work just as well using getc instead, or using
getchar () instead of fgetc (stdin).
int
y_or_n_p (const char *question)
{
fputs (question, stdout);
while (1)
{
int c, answer;
/* Write a space to separate answer from question. */
fputc (' ', stdout);
/* Read the first character of the line.
This should be the answer character, but might not be. */
c = tolower (fgetc (stdin));
answer = c;
/* Discard rest of input line. */
while (c != '\n' && c != EOF)
c = fgetc (stdin);
/* Obey the answer if it was valid. */
if (answer == 'y')
return 1;
if (answer == 'n')
return 0;
/* Answer was invalid: ask for valid answer. */
fputs ("Please answer y or n:", stdout);
}
}
int) from stream.
It's provided for compatibility with SVID. We recommend you use
fread instead (see section Block Input/Output). Unlike getc,
any int value could be a valid result. getw returns
EOF when it encounters end-of-file or an error, but there is no
way to distinguish this from an input word with value -1.
Since many programs interpret input on the basis of lines, it's convenient to have functions to read a line of text from a stream.
Standard C has functions to do this, but they aren't very safe: null
characters and even (for gets) long lines can confuse them. So
the GNU library provides the nonstandard getline function that
makes it easy to read lines reliably.
Another GNU extension, getdelim, generalizes getline. It
reads a delimited record, defined as everything through the next
occurrence of a specified delimiter character.
All these functions are declared in `stdio.h'.
*lineptr.
Before calling getline, you should place in *lineptr
the address of a buffer *n bytes long, allocated with
malloc. If this buffer is long enough to hold the line,
getline stores the line in this buffer. Otherwise,
getline makes the buffer bigger using realloc, storing the
new buffer address back in *lineptr and the increased size
back in *n.
See section Unconstrained Allocation.
If you set *lineptr to a null pointer, and *n
to zero, before the call, then getline allocates the initial
buffer for you by calling malloc.
In either case, when getline returns, *lineptr is
a char * which points to the text of the line.
When getline is successful, it returns the number of characters
read (including the newline, but not including the terminating null).
This value enables you to distinguish null characters that are part of
the line from the null character inserted as a terminator.
This function is a GNU extension, but it is the recommended way to read lines from a stream. The alternative standard functions are unreliable.
If an error occurs or end of file is reached, getline returns
-1.
getline except that the character which
tells it to stop reading is not necessarily newline. The argument
delimiter specifies the delimiter character; getdelim keeps
reading until it sees that character (or end of file).
The text is stored in lineptr, including the delimiter character
and a terminating null. Like getline, getdelim makes
lineptr bigger if it isn't big enough.
getline is in fact implemented in terms of getdelim, just
like this:
ssize_t
getline (char **lineptr, size_t *n, FILE *stream)
{
return getdelim (lineptr, n, '\n', stream);
}
fgets function reads characters from the stream stream
up to and including a newline character and stores them in the string
s, adding a null character to mark the end of the string. You
must supply count characters worth of space in s, but the
number of characters read is at most count - 1. The extra
character space is used to hold the null character at the end of the
string.
If the system is already at end of file when you call fgets, then
the contents of the array s are unchanged and a null pointer is
returned. A null pointer is also returned if a read error occurs.
Otherwise, the return value is the pointer s.
Warning: If the input data has a null character, you can't tell.
So don't use fgets unless you know the data cannot contain a null.
Don't use it to read files edited by the user because, if the user inserts
a null character, you should either handle it properly or print a clear
error message. We recommend using getline instead of fgets.
gets reads characters from the stream stdin
up to the next newline character, and stores them in the string s.
The newline character is discarded (note that this differs from the
behavior of fgets, which copies the newline character into the
string). If gets encounters a read error or end-of-file, it
returns a null pointer; otherwise it returns s.
Warning: The gets function is very dangerous
because it provides no protection against overflowing the string
s. The GNU library includes it for compatibility only. You
should always use fgets or getline instead. To
remind you of this, the linker (if using GNU ld) will issue a
warning whenever you use gets.
In parser programs it is often useful to examine the next character in the input stream without removing it from the stream. This is called "peeking ahead" at the input because your program gets a glimpse of the input it will read next.
Using stream I/O, you can peek ahead at input by first reading it and
then unreading it (also called pushing it back on the stream).
Unreading a character makes it available to be input again from the stream,
by the next call to fgetc or other input function on that stream.
Here is a pictorial explanation of unreading. Suppose you have a stream reading a file that contains just six characters, the letters `foobar'. Suppose you have read three characters so far. The situation looks like this:
f o o b a r
^
so the next input character will be `b'.
If instead of reading `b' you unread the letter `o', you get a situation like this:
f o o b a r
|
o--
^
so that the next input characters will be `o' and `b'.
If you unread `9' instead of `o', you get this situation:
f o o b a r
|
9--
^
so that the next input characters will be `9' and `b'.
ungetc To Do Unreading
The function to unread a character is called ungetc, because it
reverses the action of getc.
ungetc function pushes back the character c onto the
input stream stream. So the next input from stream will
read c before anything else.
If c is EOF, ungetc does nothing and just returns
EOF. This lets you call ungetc with the return value of
getc without needing to check for an error from getc.
The character that you push back doesn't have to be the same as the last
character that was actually read from the stream. In fact, it isn't
necessary to actually read any characters from the stream before
unreading them with ungetc! But that is a strange way to write
a program; usually ungetc is used only to unread a character
that was just read from the same stream.
The GNU C library only supports one character of pushback--in other
words, it does not work to call ungetc twice without doing input
in between. Other systems might let you push back multiple characters;
then reading from the stream retrieves the characters in the reverse
order that they were pushed.
Pushing back characters doesn't alter the file; only the internal
buffering for the stream is affected. If a file positioning function
(such as fseek or rewind; see section File Positioning) is
called, any pending pushed-back characters are discarded.
Unreading a character on a stream that is at end of file clears the end-of-file indicator for the stream, because it makes the character of input available. After you read that character, trying to read again will encounter end of file.
Here is an example showing the use of getc and ungetc to
skip over whitespace characters. When this function reaches a
non-whitespace character, it unreads that character to be seen again on
the next read operation on the stream.
#include <stdio.h>
#include <ctype.h>
void
skip_whitespace (FILE *stream)
{
int c;
do
/* No need to check for EOF because it is not
isspace, and ungetc ignores EOF. */
c = getc (stream);
while (isspace (c));
ungetc (c, stream);
}
This section describes how to do input and output operations on blocks of data. You can use these functions to read and write binary data, as well as to read and write text in fixed-size blocks instead of by characters or lines.
Binary files are typically used to read and write blocks of data in the same format as is used to represent the data in a running program. In other words, arbitrary blocks of memory--not just character or string objects--can be written to a binary file, and meaningfully read in again by the same program.
Storing data in binary form is often considerably more efficient than using the formatted I/O functions. Also, for floating-point numbers, the binary form avoids possible loss of precision in the conversion process. On the other hand, binary files can't be examined or modified easily using many standard file utilities (such as text editors), and are not portable between different implementations of the language, or different kinds of computers.
These functions are declared in `stdio.h'.
If fread encounters end of file in the middle of an object, it
returns the number of complete objects read, and discards the partial
object. Therefore, the stream remains at the actual end of the file.
The functions described in this section (printf and related
functions) provide a convenient way to perform formatted output. You
call printf with a format string or template string
that specifies how to format the values of the remaining arguments.
Unless your program is a filter that specifically performs line- or
character-oriented processing, using printf or one of the other
related functions described in this section is usually the easiest and
most concise way to perform output. These functions are especially
useful for printing error messages, tables of data, and the like.
The printf function can be used to print any number of arguments.
The template string argument you supply in a call provides
information not only about the number of additional arguments, but also
about their types and what style should be used for printing them.
Ordinary characters in the template string are simply written to the output stream as-is, while conversion specifications introduced by a `%' character in the template cause subsequent arguments to be formatted and written to the output stream. For example,
int pct = 37;
char filename[] = "foo.txt";
printf ("Processing of `%s' is %d%% finished.\nPlease be patient.\n",
filename, pct);
produces output like
Processing of `foo.txt' is 37% finished. Please be patient.
This example shows the use of the `%d' conversion to specify that
an int argument should be printed in decimal notation, the
`%s' conversion to specify printing of a string argument, and
the `%%' conversion to print a literal `%' character.
There are also conversions for printing an integer argument as an unsigned value in octal, decimal, or hexadecimal radix (`%o', `%u', or `%x', respectively); or as a character value (`%c').
Floating-point numbers can be printed in normal, fixed-point notation using the `%f' conversion or in exponential notation using the `%e' conversion. The `%g' conversion uses either `%e' or `%f' format, depending on what is more appropriate for the magnitude of the particular number.
You can control formatting more precisely by writing modifiers between the `%' and the character that indicates which conversion to apply. These slightly alter the ordinary behavior of the conversion. For example, most conversion specifications permit you to specify a minimum field width and a flag indicating whether you want the result left- or right-justified within the field.
The specific flags and modifiers that are permitted and their interpretation vary depending on the particular conversion. They're all described in more detail in the following sections. Don't worry if this all seems excessively complicated at first; you can almost always get reasonable free-format output without using any of the modifiers at all. The modifiers are mostly used to make the output look "prettier" in tables.
This section provides details about the precise syntax of conversion
specifications that can appear in a printf template
string.
Characters in the template string that are not part of a conversion specification are printed as-is to the output stream. Multibyte character sequences (see section Extended Characters) are permitted in a template string.
The conversion specifications in a printf template string have
the general form:
% flags width [ . precision ] type conversion
For example, in the conversion specifier `%-10.8ld', the `-'
is a flag, `10' specifies the field width, the precision is
`8', the letter `l' is a type modifier, and `d' specifies
the conversion style. (This particular type specifier says to
print a long int argument in decimal notation, with a minimum of
8 digits left-justified in a field at least 10 characters wide.)
In more detail, output conversion specifications consist of an initial `%' character followed in sequence by:
int.
If the value is negative, this means to set the `-' flag (see
below) and to use the absolute value as the field width.
int, and is ignored
if it is negative. If you specify `*' for both the field width and
precision, the field width argument precedes the precision argument.
Other C library versions may not recognize this syntax.
int,
but you can specify `h', `l', or `L' for other integer
types.)
The exact options that are permitted and how they are interpreted vary between the different conversion specifiers. See the descriptions of the individual conversions for information about the particular options that they use.
With the `-Wformat' option, the GNU C compiler checks calls to
printf and related functions. It examines the format string and
verifies that the correct number and types of arguments are supplied.
There is also a GNU C syntax to tell the compiler that a function you
write uses a printf-style format string.
See section `Declaring Attributes of Functions' in Using GNU CC, for more information.
Here is a table summarizing what all the different conversions do:
scanf for input
(see section Table of Input Conversions).
errno.
(This is a GNU extension.)
See section Other Output Conversions.
If the syntax of a conversion specification is invalid, unpredictable things will happen, so don't do this. If there aren't enough function arguments provided to supply values for all the conversion specifications in the template string, or if the arguments are not of the correct types, the results are unpredictable. If you supply more arguments than conversion specifications, the extra argument values are simply ignored; this is sometimes useful.
This section describes the options for the `%d', `%i', `%o', `%u', `%x', and `%X' conversion specifications. These conversions print integers in various formats.
The `%d' and `%i' conversion specifications both print an
int argument as a signed decimal number; while `%o',
`%u', and `%x' print the argument as an unsigned octal,
decimal, or hexadecimal number (respectively). The `%X' conversion
specification is just like `%x' except that it uses the characters
`ABCDEF' as digits instead of `abcdef'.
The following flags are meaningful:
strtoul function (see section Parsing of Integers) and scanf with the `%i' conversion
(see section Numeric Input Conversions).
LC_NUMERIC category; see section Generic Numeric Formatting Parameters. This flag is a
GNU extension.
If a precision is supplied, it specifies the minimum number of digits to appear; leading zeros are produced if necessary. If you don't specify a precision, the number is printed with as many digits as it needs. If you convert a value of zero with an explicit precision of zero, then no characters at all are produced.
Without a type modifier, the corresponding argument is treated as an
int (for the signed conversions `%i' and `%d') or
unsigned int (for the unsigned conversions `%o', `%u',
`%x', and `%X'). Recall that since printf and friends
are variadic, any char and short arguments are
automatically converted to int by the default argument
promotions. For arguments of other integer types, you can use these
modifiers:
short int or unsigned
short int, as appropriate. A short argument is converted to an
int or unsigned int by the default argument promotions
anyway, but the `h' modifier says to convert it back to a
short again.
long int or unsigned long
int, as appropriate. Two `l' characters is like the `L'
modifier, below.
long long int. (This type is
an extension supported by the GNU C compiler. On systems that don't
support extra-long integers, this is the same as long int.)
The `q' modifier is another name for the same thing, which comes
from 4.4 BSD; a long long int is sometimes called a "quad"
int.
size_t. This is a GNU extension.
Here is an example. Using the template string:
"|%5d|%-5d|%+5d|%+-5d|% 5d|%05d|%5.0d|%5.2d|%d|\n"
to print numbers using the different options for the `%d' conversion gives results like:
| 0|0 | +0|+0 | 0|00000| | 00|0| | 1|1 | +1|+1 | 1|00001| 1| 01|1| | -1|-1 | -1|-1 | -1|-0001| -1| -01|-1| |100000|100000|+100000| 100000|100000|100000|100000|100000|
In particular, notice what happens in the last case where the number is too large to fit in the minimum field width specified.
Here are some more examples showing how unsigned integers print under various format options, using the template string:
"|%5u|%5o|%5x|%5X|%#5o|%#5x|%#5X|%#10.8x|\n"
| 0| 0| 0| 0| 0| 0x0| 0X0|0x00000000| | 1| 1| 1| 1| 01| 0x1| 0X1|0x00000001| |100000|303240|186a0|186A0|0303240|0x186a0|0X186A0|0x000186a0|
This section discusses the conversion specifications for floating-point numbers: the `%f', `%e', `%E', `%g', and `%G' conversions.
The `%f' conversion prints its argument in fixed-point notation,
producing output of the form
[-]ddd.ddd,
where the number of digits following the decimal point is controlled
by the precision you specify.
The `%e' conversion prints its argument in exponential notation,
producing output of the form
[-]d.ddde[+|-]dd.
Again, the number of digits following the decimal point is controlled by
the precision. The exponent always contains at least two digits. The
`%E' conversion is similar but the exponent is marked with the letter
`E' instead of `e'.
The `%g' and `%G' conversions print the argument in the style of `%e' or `%E' (respectively) if the exponent would be less than -4 or greater than or equal to the precision; otherwise they use the `%f' style. Trailing zeros are removed from the fractional portion of the result and a decimal-point character appears only if it is followed by a digit.
The following flags can be used to modify the behavior:
LC_NUMERIC category;
see section Generic Numeric Formatting Parameters. This flag is a GNU extension.
The precision specifies how many digits follow the decimal-point
character for the `%f', `%e', and `%E' conversions. For
these conversions, the default precision is 6. If the precision
is explicitly 0, this suppresses the decimal point character
entirely. For the `%g' and `%G' conversions, the precision
specifies how many significant digits to print. Significant digits are
the first digit before the decimal point, and all the digits after it.
If the precision 0 or not specified for `%g' or `%G',
it is treated like a value of 1. If the value being printed
cannot be expressed accurately in the specified number of digits, the
value is rounded to the nearest number that fits.
Without a type modifier, the floating-point conversions use an argument
of type double. (By the default argument promotions, any
float arguments are automatically converted to double.)
The following type modifier is supported:
long
double.
Here are some examples showing how numbers print using the various floating-point conversions. All of the numbers were printed using this template string:
"|%12.4f|%12.4e|%12.4g|\n"
Here is the output:
| 0.0000| 0.0000e+00| 0| | 1.0000| 1.0000e+00| 1| | -1.0000| -1.0000e+00| -1| | 100.0000| 1.0000e+02| 100| | 1000.0000| 1.0000e+03| 1000| | 10000.0000| 1.0000e+04| 1e+04| | 12345.0000| 1.2345e+04| 1.234e+04| | 100000.0000| 1.0000e+05| 1e+05| | 123456.0000| 1.2346e+05| 1.234e+05|
Notice how the `%g' conversion drops trailing zeros.
This section describes miscellaneous conversions for printf.
The `%c' conversion prints a single character. The int
argument is first converted to an unsigned char. The `-'
flag can be used to specify left-justification in the field, but no
other flags are defined, and no precision or type modifier can be given.
For example:
printf ("%c%c%c%c%c", 'h', 'e', 'l', 'l', 'o');
prints `hello'.
The `%s' conversion prints a string. The corresponding argument
must be of type char * (or const char *). A precision can
be specified to indicate the maximum number of characters to write;
otherwise characters in the string up to but not including the
terminating null character are written to the output stream. The
`-' flag can be used to specify left-justification in the field,
but no other flags or type modifiers are defined for this conversion.
For example:
printf ("%3s%-6s", "no", "where");
prints ` nowhere '.
If you accidentally pass a null pointer as the argument for a `%s' conversion, the GNU library prints it as `(null)'. We think this is more useful than crashing. But it's not good practice to pass a null argument intentionally.
The `%m' conversion prints the string corresponding to the error
code in errno. See section Error Messages. Thus:
fprintf (stderr, "can't open `%s': %m\n", filename);
is equivalent to:
fprintf (stderr, "can't open `%s': %s\n", filename, strerror (errno));
The `%m' conversion is a GNU C library extension.
The `%p' conversion prints a pointer value. The corresponding
argument must be of type void *. In practice, you can use any
type of pointer.
In the GNU system, non-null pointers are printed as unsigned integers, as if a `%#x' conversion were used. Null pointers print as `(nil)'. (Pointers might print differently in other systems.)
For example:
printf ("%p", "testing");
prints `0x' followed by a hexadecimal number--the address of the
string constant "testing". It does not print the word
`testing'.
You can supply the `-' flag with the `%p' conversion to specify left-justification, but no other flags, precision, or type modifiers are defined.
The `%n' conversion is unlike any of the other output conversions.
It uses an argument which must be a pointer to an int, but
instead of printing anything it stores the number of characters printed
so far by this call at that location. The `h' and `l' type
modifiers are permitted to specify that the argument is of type
short int * or long int * instead of int *, but no
flags, field width, or precision are permitted.
For example,
int nchar;
printf ("%d %s%n\n", 3, "bears", &nchar);
prints:
3 bears
and sets nchar to 7, because `3 bears' is seven
characters.
The `%%' conversion prints a literal `%' character. This conversion doesn't use an argument, and no flags, field width, precision, or type modifiers are permitted.
This section describes how to call printf and related functions.
Prototypes for these functions are in the header file `stdio.h'.
Because these functions take a variable number of arguments, you
must declare prototypes for them before using them. Of course,
the easiest way to make sure you have all the right prototypes is to
just include `stdio.h'.
printf function prints the optional arguments under the
control of the template string template to the stream
stdout. It returns the number of characters printed, or a
negative value if there was an output error.
printf, except that the output is
written to the stream stream instead of stdout.
printf, except that the output is stored in the character
array s instead of written to a stream. A null character is written
to mark the end of the string.
The sprintf function returns the number of characters stored in
the array s, not including the terminating null character.
The behavior of this function is undefined if copying takes place between objects that overlap--for example, if s is also given as an argument to be printed under control of the `%s' conversion. See section Copying and Concatenation.
Warning: The sprintf function can be dangerous
because it can potentially output more characters than can fit in the
allocation size of the string s. Remember that the field width
given in a conversion specification is only a minimum value.
To avoid this problem, you can use snprintf or asprintf,
described below.
snprintf function is similar to sprintf, except that
the size argument specifies the maximum number of characters to
produce. The trailing null character is counted towards this limit, so
you should allocate at least size characters for the string s.
The return value is the number of characters stored, not including the
terminating null. If this value equals size - 1, then
there was not enough space in s for all the output. You should
try again with a bigger output string. Here is an example of doing
this:
/* Construct a message describing the value of a variable
whose name is name and whose value is value. */
char *
make_message (char *name, char *value)
{
/* Guess we need no more than 100 chars of space. */
int size = 100;
char *buffer = (char *) xmalloc (size);
while (1)
{
/* Try to print in the allocated space. */
int nchars = snprintf (buffer, size,
"value of %s is %s",
name, value);
/* If that worked, return the string. */
if (nchars < size)
return buffer;
/* Else try again with twice as much space. */
size *= 2;
buffer = (char *) xrealloc (size, buffer);
}
}
In practice, it is often easier just to use asprintf, below.
The functions in this section do formatted output and place the results in dynamically allocated memory.
sprintf, except that it dynamically
allocates a string (as with malloc; see section Unconstrained Allocation) to hold the output, instead of putting the output in a
buffer you allocate in advance. The ptr argument should be the
address of a char * object, and asprintf stores a pointer
to the newly allocated string at that location.
Here is how to use asprintf to get the same result as the
snprintf example, but more easily:
/* Construct a message describing the value of a variable
whose name is name and whose value is value. */
char *
make_message (char *name, char *value)
{
char *result;
asprintf (&result, "value of %s is %s", name, value);
return result;
}
asprintf, except that it uses the
obstack obstack to allocate the space. See section Obstacks.
The characters are written onto the end of the current object.
To get at them, you must finish the object with obstack_finish
(see section Growing Objects).
The functions vprintf and friends are provided so that you can
define your own variadic printf-like functions that make use of
the same internals as the built-in formatted output functions.
The most natural way to define such functions would be to use a language
construct to say, "Call printf and pass this template plus all
of my arguments after the first five." But there is no way to do this
in C, and it would be hard to provide a way, since at the C language
level there is no way to tell how many arguments your function received.
Since that method is impossible, we provide alternative functions, the
vprintf series, which lets you pass a va_list to describe
"all of my arguments after the first five."
When it is sufficient to define a macro rather than a real function, the GNU C compiler provides a way to do this much more easily with macros. For example:
#define myprintf(a, b, c, d, e, rest...) printf (mytemplate , ## rest...)
See section `Macros with Variable Numbers of Arguments' in Using GNU CC, for details. But this is limited to macros, and does not apply to real functions at all.
Before calling vprintf or the other functions listed in this
section, you must call va_start (see section Variadic Functions) to initialize a pointer to the variable arguments. Then you
can call va_arg to fetch the arguments that you want to handle
yourself. This advances the pointer past those arguments.
Once your va_list pointer is pointing at the argument of your
choice, you are ready to call vprintf. That argument and all
subsequent arguments that were passed to your function are used by
vprintf along with the template that you specified separately.
In some other systems, the va_list pointer may become invalid
after the call to vprintf, so you must not use va_arg
after you call vprintf. Instead, you should call va_end
to retire the pointer from service. However, you can safely call
va_start on another pointer variable and begin fetching the
arguments again through that pointer. Calling vprintf does not
destroy the argument list of your function, merely the particular
pointer that you passed to it.
GNU C does not have such restrictions. You can safely continue to fetch
arguments from a va_list pointer after passing it to
vprintf, and va_end is a no-op. (Note, however, that
subsequent va_arg calls will fetch the same arguments which
vprintf previously used.)
Prototypes for these functions are declared in `stdio.h'.
printf except that, instead of taking
a variable number of arguments directly, it takes an argument list
pointer ap.
fprintf with the variable argument list
specified directly as for vprintf.
sprintf with the variable argument list
specified directly as for vprintf.
snprintf with the variable argument list
specified directly as for vprintf.
vasprintf function is the equivalent of asprintf with the
variable argument list specified directly as for vprintf.
obstack_vprintf function is the equivalent of
obstack_printf with the variable argument list specified directly
as for vprintf.
Here's an example showing how you might use vfprintf. This is a
function that prints error messages to the stream stderr, along
with a prefix indicating the name of the program
(see section Error Messages, for a description of
program_invocation_short_name).
#include <stdio.h>
#include <stdarg.h>
void
eprintf (const char *template, ...)
{
va_list ap;
extern char *program_invocation_short_name;
fprintf (stderr, "%s: ", program_invocation_short_name);
va_start (ap, count);
vfprintf (stderr, template, ap);
va_end (ap);
}
You could call eprintf like this:
eprintf ("file `%s' does not exist\n", filename);
In GNU C, there is a special construct you can use to let the compiler
know that a function uses a printf-style format string. Then it
can check the number and types of arguments in each call to the
function, and warn you when they do not match the format string.
For example, take this declaration of eprintf:
void eprintf (const char *template, ...)
__attribute__ ((format (printf, 1, 2)));
This tells the compiler that eprintf uses a format string like
printf (as opposed to scanf; see section Formatted Input);
the format string appears as the first argument;
and the arguments to satisfy the format begin with the second.
See section `Declaring Attributes of Functions' in Using GNU CC, for more information.
You can use the function parse_printf_format to obtain
information about the number and types of arguments that are expected by
a given template string. This function permits interpreters that
provide interfaces to printf to avoid passing along invalid
arguments from the user's program, which could cause a crash.
All the symbols described in this section are declared in the header file `printf.h'.
printf template string template.
The information is stored in the array argtypes; each element of
this array describes one argument. This information is encoded using
the various `PA_' macros, listed below.
The n argument specifies the number of elements in the array
argtypes. This is the most elements that
parse_printf_format will try to write.
parse_printf_format returns the total number of arguments required
by template. If this number is greater than n, then the
information returned describes only the first n arguments. If you
want information about more than that many arguments, allocate a bigger
array and call parse_printf_format again.
The argument types are encoded as a combination of a basic type and modifier flag bits.
(argtypes[i] & PA_FLAG_MASK) to extract just the
flag bits for an argument, or (argtypes[i] & ~PA_FLAG_MASK) to
extract just the basic type code.
Here are symbolic constants that represent the basic types; they stand for integer values.
PA_INT
int.
PA_CHAR
int, cast to char.
PA_STRING
char *, a null-terminated string.
PA_POINTER
void *, an arbitrary pointer.
PA_FLOAT
float.
PA_DOUBLE
double.
PA_LAST
PA_LAST. For example, if you have data types `foo'
and `bar' with their own specialized printf conversions,
you could define encodings for these types as:
#define PA_FOO PA_LAST #define PA_BAR (PA_LAST + 1)
Here are the flag bits that modify a basic type. They are combined with the code for the basic type using inclusive-or.
PA_FLAG_PTR
PA_FLAG_SHORT
short. (This corresponds to the `h' type modifier.)
PA_FLAG_LONG
long. (This corresponds to the `l' type modifier.)
PA_FLAG_LONG_LONG
long long. (This corresponds to the `L' type modifier.)
PA_FLAG_LONG_DOUBLE
PA_FLAG_LONG_LONG, used by convention with
a base type of PA_DOUBLE to indicate a type of long double.
Here is an example of decoding argument types for a format string. We
assume this is part of an interpreter which contains arguments of type
NUMBER, CHAR, STRING and STRUCTURE (and
perhaps others which are not valid here).
/* Test whether the nargs specified objects
in the vector args are valid
for the format string format:
if so, return 1.
If not, return 0 after printing an error message. */
int
validate_args (char *format, int nargs, OBJECT *args)
{
int *argtypes;
int nwanted;
/* Get the information about the arguments.
Each conversion specification must be at least two characters
long, so there cannot be more specifications than half the
length of the string. */
argtypes = (int *) alloca (strlen (format) / 2 * sizeof (int));
nwanted = parse_printf_format (string, nelts, argtypes);
/* Check the number of arguments. */
if (nwanted > nargs)
{
error ("too few arguments (at least %d required)", nwanted);
return 0;
}
/* Check the C type wanted for each argument
and see if the object given is suitable. */
for (i = 0; i < nwanted; i++)
{
int wanted;
if (argtypes[i] & PA_FLAG_PTR)
wanted = STRUCTURE;
else
switch (argtypes[i] & ~PA_FLAG_MASK)
{
case PA_INT:
case PA_FLOAT:
case PA_DOUBLE:
wanted = NUMBER;
break;
case PA_CHAR:
wanted = CHAR;
break;
case PA_STRING:
wanted = STRING;
break;
case PA_POINTER:
wanted = STRUCTURE;
break;
}
if (TYPE (args[i]) != wanted)
{
error ("type mismatch for arg number %d", i);
return 0;
}
}
return 1;
}
printf
The GNU C library lets you define your own custom conversion specifiers
for printf template strings, to teach printf clever ways
to print the important data structures of your program.
The way you do this is by registering the conversion with the function
register_printf_function; see section Registering New Conversions.
One of the arguments you pass to this function is a pointer to a handler
function that produces the actual output; see section Defining the Output Handler, for information on how to write this function.
You can also install a function that just returns information about the number and type of arguments expected by the conversion specifier. See section Parsing a Template String, for information about this.
The facilities of this section are declared in the header file `printf.h'.
Portability Note: The ability to extend the syntax of
printf template strings is a GNU extension. ISO standard C has
nothing similar.
The function to register a new output conversion is
register_printf_function, declared in `printf.h'.
'z', it defines the conversion `%z'.
You can redefine the built-in conversions like `%s', but flag
characters like `#' and type modifiers like `l' can never be
used as conversions; calling register_printf_function for those
characters has no effect.
The handler-function is the function called by printf and
friends when this conversion appears in a template string.
See section Defining the Output Handler, for information about how to define
a function to pass as this argument. If you specify a null pointer, any
existing handler function for spec is removed.
The arginfo-function is the function called by
parse_printf_format when this conversion appears in a
template string. See section Parsing a Template String, for information
about this.
Attention: In the GNU C library version before 2.0 the
arginfo-function function did not need to be installed unless
the user uses the parse_printf_format function. This changed.
Now a call to any of the printf functions will call this
function when this format specifier appears in the format string.
The return value is 0 on success, and -1 on failure
(which occurs if spec is out of range).
You can redefine the standard output conversions, but this is probably not a good idea because of the potential for confusion. Library routines written by other people could break if you do this.
If you define a meaning for `%A', what if the template contains `%+23A' or `%-#A'? To implement a sensible meaning for these, the handler when called needs to be able to get the options specified in the template.
Both the handler-function and arginfo-function arguments
to register_printf_function accept an argument that points to a
struct printf_info, which contains information about the options
appearing in an instance of the conversion specifier. This data type
is declared in the header file `printf.h'.
printf template
string to the handler and arginfo functions for that specifier. It
contains the following members:
int prec
-1 if no precision
was specified. If the precision was given as `*', the
printf_info structure passed to the handler function contains the
actual value retrieved from the argument list. But the structure passed
to the arginfo function contains a value of INT_MIN, since the
actual value is not known.
int width
0 if no
width was specified. If the field width was given as `*', the
printf_info structure passed to the handler function contains the
actual value retrieved from the argument list. But the structure passed
to the arginfo function contains a value of INT_MIN, since the
actual value is not known.
wchar_t spec
unsigned int is_long_double
long long int, as opposed to long double for floating
point conversions.
unsigned int is_short
unsigned int is_long
unsigned int alt
unsigned int space
unsigned int left
unsigned int showsign
unsigned int group
unsigned int extra
printf function this variable always contains the value
0.
wchar_t pad
'0' if the `0' flag was specified, and
' ' otherwise.
Now let's look at how to define the handler and arginfo functions
which are passed as arguments to register_printf_function.
Compatibility Note: The interface change in the GNU libc
version 2.0. Previously the third argument was of type
va_list *.
You should define your handler functions with a prototype like:
int function (FILE *stream, const struct printf_info *info,
const void *const *args)
The stream argument passed to the handler function is the stream to which it should write output.
The info argument is a pointer to a structure that contains information about the various options that were included with the conversion in the template string. You should not modify this structure inside your handler function. See section Conversion Specifier Options, for a description of this data structure.
The args is a vector of pointers to the arguments data. The number of arguments were determined by calling the argument information function provided by the user.
Your handler function should return a value just like printf
does: it should return the number of characters it has written, or a
negative value to indicate an error.
If you are going to use parse_printf_format in your
application, you must also define a function to pass as the
arginfo-function argument for each new conversion you install with
register_printf_function.
You have to define these functions with a prototype like:
int function (const struct printf_info *info,
size_t n, int *argtypes)
The return value from the function should be the number of arguments the
conversion expects. The function should also fill in no more than
n elements of the argtypes array with information about the
types of each of these arguments. This information is encoded using the
various `PA_' macros. (You will notice that this is the same
calling convention parse_printf_format itself uses.)
printf Extension Example
Here is an example showing how to define a printf handler function.
This program defines a data structure called a Widget and
defines the `%W' conversion to print information about Widget *
arguments, including the pointer value and the name stored in the data
structure. The `%W' conversion supports the minimum field width and
left-justification options, but ignores everything else.
#include <stdio.h>
#include <printf.h>
#include <stdarg.h>
typedef struct
{
char *name;
} Widget;
int
print_widget (FILE *stream, const struct printf_info *info, va_list *app)
{
Widget *w;
char *buffer;
int len;
/* Format the output into a string. */
w = va_arg (*app, Widget *);
len = asprintf (&buffer, "<Widget %p: %s>", w, w->name);
if (len == -1)
return -1;
/* Pad to the minimum field width and print to the stream. */
len = fprintf (stream, "%*s",
(info->left ? - info->width : info->width),
buffer);
/* Clean up and return. */
free (buffer);
return len;
}
int
print_widget_arginfo (const struct printf_info *info, size_t n,
int *argtypes)
{
/* We always take exactly one argument and this is a pointer to the
structure.. */
if (n > 0)
argtypes[0] = PA_POINTER;
return 1;
}
int
main (void)
{
/* Make a widget to print. */
Widget mywidget;
mywidget.name = "mywidget";
/* Register the print function for widgets. */
register_printf_function ('W', print_widget, print_widget_arginfo);
/* Now print the widget. */
printf ("|%W|\n", &mywidget);
printf ("|%35W|\n", &mywidget);
printf ("|%-35W|\n", &mywidget);
return 0;
}
The output produced by this program looks like:
|<Widget 0xffeffb7c: mywidget>| | <Widget 0xffeffb7c: mywidget>| |<Widget 0xffeffb7c: mywidget> |
The functions described in this section (scanf and related
functions) provide facilities for formatted input analogous to the
formatted output facilities. These functions provide a mechanism for
reading arbitrary values under the control of a format string or
template string.
Calls to scanf are superficially similar to calls to
printf in that arbitrary arguments are read under the control of
a template string. While the syntax of the conversion specifications in
the template is very similar to that for printf, the
interpretation of the template is oriented more towards free-format
input and simple pattern matching, rather than fixed-field formatting.
For example, most scanf conversions skip over any amount of
"white space" (including spaces, tabs, and newlines) in the input
file, and there is no concept of precision for the numeric input
conversions as there is for the corresponding output conversions.
Ordinarily, non-whitespace characters in the template are expected to
match characters in the input stream exactly, but a matching failure is
distinct from an input error on the stream.
Another area of difference between scanf and printf is
that you must remember to supply pointers rather than immediate values
as the optional arguments to scanf; the values that are read are
stored in the objects that the pointers point to. Even experienced
programmers tend to forget this occasionally, so if your program is
getting strange errors that seem to be related to scanf, you
might want to double-check this.
When a matching failure occurs, scanf returns immediately,
leaving the first non-matching character as the next character to be
read from the stream. The normal return value from scanf is the
number of values that were assigned, so you can use this to determine if
a matching error happened before all the expected values were read.
The scanf function is typically used for things like reading in
the contents of tables. For example, here is a function that uses
scanf to initialize an array of double:
void
readarray (double *array, int n)
{
int i;
for (i=0; i<n; i++)
if (scanf (" %lf", &(array[i])) != 1)
invalid_input_error ();
}
The formatted input functions are not used as frequently as the formatted output functions. Partly, this is because it takes some care to use them properly. Another reason is that it is difficult to recover from a matching error.
If you are trying to read input that doesn't match a single, fixed
pattern, you may be better off using a tool such as Flex to generate a
lexical scanner, or Bison to generate a parser, rather than using
scanf. For more information about these tools, see section `' in Flex: The Lexical Scanner Generator, and section `' in The Bison Reference Manual.
A scanf template string is a string that contains ordinary
multibyte characters interspersed with conversion specifications that
start with `%'.
Any whitespace character (as defined by the isspace function;
see section Classification of Characters) in the template causes any number
of whitespace characters in the input stream to be read and discarded.
The whitespace characters that are matched need not be exactly the same
whitespace characters that appear in the template string. For example,
write ` , ' in the template to recognize a comma with optional
whitespace before and after.
Other characters in the template string that are not part of conversion specifications must match characters in the input stream exactly; if this is not the case, a matching failure occurs.
The conversion specifications in a scanf template string
have the general form:
% flags width type conversion
In more detail, an input conversion specification consists of an initial `%' character followed in sequence by:
scanf finds a conversion
specification that uses this flag, it reads input as directed by the
rest of the conversion specification, but it discards this input, does
not use a pointer argument, and does not increment the count of
successful assignments.
long int
rather than a pointer to an int.
The exact options that are permitted and how they are interpreted vary between the different conversion specifiers. See the descriptions of the individual conversions for information about the particular options that they allow.
With the `-Wformat' option, the GNU C compiler checks calls to
scanf and related functions. It examines the format string and
verifies that the correct number and types of arguments are supplied.
There is also a GNU C syntax to tell the compiler that a function you
write uses a scanf-style format string.
See section `Declaring Attributes of Functions' in Using GNU CC, for more information.
Here is a table that summarizes the various conversion specifications:
printf. See section Other Input Conversions.
If the syntax of a conversion specification is invalid, the behavior is undefined. If there aren't enough function arguments provided to supply addresses for all the conversion specifications in the template strings that perform assignments, or if the arguments are not of the correct types, the behavior is also undefined. On the other hand, extra arguments are simply ignored.
This section describes the scanf conversions for reading numeric
values.
The `%d' conversion matches an optionally signed integer in decimal
radix. The syntax that is recognized is the same as that for the
strtol function (see section Parsing of Integers) with the value
10 for the base argument.
The `%i' conversion matches an optionally signed integer in any of
the formats that the C language defines for specifying an integer
constant. The syntax that is recognized is the same as that for the
strtol function (see section Parsing of Integers) with the value
0 for the base argument. (You can print integers in this
syntax with printf by using the `#' flag character with the
`%x', `%o', or `%d' conversion. See section Integer Conversions.)
For example, any of the strings `10', `0xa', or `012'
could be read in as integers under the `%i' conversion. Each of
these specifies a number with decimal value 10.
The `%o', `%u', and `%x' conversions match unsigned
integers in octal, decimal, and hexadecimal radices, respectively. The
syntax that is recognized is the same as that for the strtoul
function (see section Parsing of Integers) with the appropriate value
(8, 10, or 16) for the base argument.
The `%X' conversion is identical to the `%x' conversion. They both permit either uppercase or lowercase letters to be used as digits.
The default type of the corresponding argument for the %d and
%i conversions is int *, and unsigned int * for the
other integer conversions. You can use the following type modifiers to
specify other sizes of integer:
short int * or unsigned
short int *.
long int * or unsigned
long int *. Two `l' characters is like the `L' modifier, below.
long long int * or unsigned long long int *. (The long long type is an extension supported by the
GNU C compiler. For systems that don't provide extra-long integers, this
is the same as long int.)
The `q' modifier is another name for the same thing, which comes
from 4.4 BSD; a long long int is sometimes called a "quad"
int.
All of the `%e', `%f', `%g', `%E', and `%G'
input conversions are interchangeable. They all match an optionally
signed floating point number, in the same syntax as for the
strtod function (see section Parsing of Floats).
For the floating-point input conversions, the default argument type is
float *. (This is different from the corresponding output
conversions, where the default type is double; remember that
float arguments to printf are converted to double
by the default argument promotions, but float * arguments are
not promoted to double *.) You can specify other sizes of float
using these type modifiers:
double *.
long double *.
For all the above number parsing formats there is an additional optional
flag `''. When this flag is given the scanf function
expects the number represented in the input string to be formatted
according to the grouping rules of the currently selected locale
(see section Generic Numeric Formatting Parameters).
If the "C" or "POSIX" locale is selected there is no
difference. But for a locale which specifies values for the appropriate
fields in the locale the input must have the correct form in the input.
Otherwise the longest prefix with a correct form is processed.
This section describes the scanf input conversions for reading
string and character values: `%s', `%[', and `%c'.
You have two options for how to receive the input from these conversions:
char *.
Warning: To make a robust program, you must make sure that the
input (plus its terminating null) cannot possibly exceed the size of the
buffer you provide. In general, the only way to do this is to specify a
maximum field width one less than the buffer size. If you
provide the buffer, always specify a maximum field width to prevent
overflow.
scanf to allocate a big enough buffer, by specifying the
`a' flag character. This is a GNU extension. You should provide
an argument of type char ** for the buffer address to be stored
in. See section Dynamically Allocating String Conversions.
The `%c' conversion is the simplest: it matches a fixed number of characters, always. The maximum field with says how many characters to read; if you don't specify the maximum, the default is 1. This conversion doesn't append a null character to the end of the text it reads. It also does not skip over initial whitespace characters. It reads precisely the next n characters, and fails if it cannot get that many. Since there is always a maximum field width with `%c' (whether specified, or 1 by default), you can always prevent overflow by making the buffer long enough.
The `%s' conversion matches a string of non-whitespace characters. It skips and discards initial whitespace, but stops when it encounters more whitespace after having read something. It stores a null character at the end of the text that it reads.
For example, reading the input:
hello, world
with the conversion `%10c' produces " hello, wo", but
reading the same input with the conversion `%10s' produces
"hello,".
Warning: If you do not specify a field width for `%s', then the number of characters read is limited only by where the next whitespace character appears. This almost certainly means that invalid input can make your program crash--which is a bug.
To read in characters that belong to an arbitrary set of your choice, use the `%[' conversion. You specify the set between the `[' character and a following `]' character, using the same syntax used in regular expressions. As special cases:
The `%[' conversion does not skip over initial whitespace characters.
Here are some examples of `%[' conversions and what they mean:
One more reminder: the `%s' and `%[' conversions are dangerous if you don't specify a maximum width or use the `a' flag, because input too long would overflow whatever buffer you have provided for it. No matter how long your buffer is, a user could supply input that is longer. A well-written program reports invalid input with a comprehensible error message, not with a crash.
A GNU extension to formatted input lets you safely read a string with no
maximum size. Using this feature, you don't supply a buffer; instead,
scanf allocates a buffer big enough to hold the data and gives
you its address. To use this feature, write `a' as a flag
character, as in `%as' or `%a[0-9a-z]'.
The pointer argument you supply for where to store the input should have
type char **. The scanf function allocates a buffer and
stores its address in the word that the argument points to. You should
free the buffer with free when you no longer need it.
Here is an example of using the `a' flag with the `%[...]' conversion specification to read a "variable assignment" of the form `variable = value'.
{
char *variable, *value;
if (2 > scanf ("%a[a-zA-Z0-9] = %a[^\n]\n",
&variable, &value))
{
invalid_input_error ();
return 0;
}
...
}
This section describes the miscellaneous input conversions.
The `%p' conversion is used to read a pointer value. It recognizes
the same syntax as is used by the `%p' output conversion for
printf (see section Other Output Conversions); that is, a hexadecimal
number just as the `%x' conversion accepts. The corresponding
argument should be of type void **; that is, the address of a
place to store a pointer.
The resulting pointer value is not guaranteed to be valid if it was not originally written during the same program execution that reads it in.
The `%n' conversion produces the number of characters read so far
by this call. The corresponding argument should be of type int *.
This conversion works in the same way as the `%n' conversion for
printf; see section Other Output Conversions, for an example.
The `%n' conversion is the only mechanism for determining the
success of literal matches or conversions with suppressed assignments.
If the `%n' follows the locus of a matching failure, then no value
is stored for it since scanf returns before processing the
`%n'. If you store -1 in that argument slot before calling
scanf, the presence of -1 after scanf indicates an
error occurred before the `%n' was reached.
Finally, the `%%' conversion matches a literal `%' character in the input stream, without using an argument. This conversion does not permit any flags, field width, or type modifier to be specified.
Here are the descriptions of the functions for performing formatted input. Prototypes for these functions are in the header file `stdio.h'.
scanf function reads formatted input from the stream
stdin under the control of the template string template.
The optional arguments are pointers to the places which receive the
resulting values.
The return value is normally the number of successful assignments. If
an end-of-file condition is detected before any matches are performed
(including matches against whitespace and literal characters in the
template), then EOF is returned.
scanf, except that the input is read
from the stream stream instead of stdin.
scanf, except that the characters are taken from the
null-terminated string s instead of from a stream. Reaching the
end of the string is treated as an end-of-file condition.
The behavior of this function is undefined if copying takes place between objects that overlap--for example, if s is also given as an argument to receive a string read under control of the `%s' conversion.
The functions vscanf and friends are provided so that you can
define your own variadic scanf-like functions that make use of
the same internals as the built-in formatted output functions.
These functions are analogous to the vprintf series of output
functions. See section Variable Arguments Output Functions, for important
information on how to use them.
Portability Note: The functions listed in this section are GNU extensions.
scanf except that, instead of taking
a variable number of arguments directly, it takes an argument list
pointer ap of type va_list (see section Variadic Functions).
fscanf with the variable argument list
specified directly as for vscanf.
sscanf with the variable argument list
specified directly as for vscanf.
In GNU C, there is a special construct you can use to let the compiler
know that a function uses a scanf-style format string. Then it
can check the number and types of arguments in each call to the
function, and warn you when they do not match the format string.
See section `Declaring Attributes of Functions' in Using GNU CC, for details.
Many of the functions described in this chapter return the value of the
macro EOF to indicate unsuccessful completion of the operation.
Since EOF is used to report both end of file and random errors,
it's often better to use the feof function to check explicitly
for end of file and ferror to check for errors. These functions
check indicators that are part of the internal state of the stream
object, indicators set if the appropriate condition was detected by a
previous I/O operation on that stream.
These symbols are declared in the header file `stdio.h'.
EOF is -1. In other libraries, its
value may be some other negative number.
The file positioning functions (see section File Positioning) also clear the end-of-file indicator for the stream.
feof function returns nonzero if and only if the end-of-file
indicator for the stream stream is set.
ferror function returns nonzero if and only if the error
indicator for the stream stream is set, indicating that an error
has occurred on a previous operation on the stream.
In addition to setting the error indicator associated with the stream,
the functions that operate on streams also set errno in the same
way as the corresponding low-level functions that operate on file
descriptors. For example, all of the functions that perform output to a
stream--such as fputc, printf, and fflush---are
implemented in terms of write, and all of the errno error
conditions defined for write are meaningful for these functions.
For more information about the descriptor-level I/O functions, see
section Low-Level Input/Output.
The GNU system and other POSIX-compatible operating systems organize all files as uniform sequences of characters. However, some other systems make a distinction between files containing text and files containing binary data, and the input and output facilities of ISO C provide for this distinction. This section tells you how to write programs portable to such systems.
When you open a stream, you can specify either a text stream or a
binary stream. You indicate that you want a binary stream by
specifying the `b' modifier in the opentype argument to
fopen; see section Opening Streams. Without this
option, fopen opens the file as a text stream.
Text and binary streams differ in several ways:
'\n') characters, while a binary stream is
simply a long series of characters. A text stream might on some systems
fail to handle lines more than 254 characters long (including the
terminating newline character).
Since a binary stream is always more capable and more predictable than a text stream, you might wonder what purpose text streams serve. Why not simply always use binary streams? The answer is that on these operating systems, text and binary streams use different file formats, and the only way to read or write "an ordinary file of text" that can work with other text-oriented programs is through a text stream.
In the GNU library, and on all POSIX systems, there is no difference between text streams and binary streams. When you open a stream, you get the same kind of stream regardless of whether you ask for binary. This stream can handle any file content, and has none of the restrictions that text streams sometimes have.
The file position of a stream describes where in the file the stream is currently reading or writing. I/O on the stream advances the file position through the file. In the GNU system, the file position is represented as an integer, which counts the number of bytes from the beginning of the file. See section File Position.
During I/O to an ordinary disk file, you can change the file position whenever you wish, so as to read or write any portion of the file. Some other kinds of files may also permit this. Files which support changing the file position are sometimes referred to as random-access files.
You can use the functions in this section to examine or modify the file position indicator associated with a stream. The symbols listed below are declared in the header file `stdio.h'.
This function can fail if the stream doesn't support file positioning,
or if the file position can't be represented in a long int, and
possibly for other reasons as well. If a failure occurs, a value of
-1 is returned.
fseek function is used to change the file position of the
stream stream. The value of whence must be one of the
constants SEEK_SET, SEEK_CUR, or SEEK_END, to
indicate whether the offset is relative to the beginning of the
file, the current file position, or the end of the file, respectively.
This function returns a value of zero if the operation was successful,
and a nonzero value to indicate failure. A successful call also clears
the end-of-file indicator of stream and discards any characters
that were "pushed back" by the use of ungetc.
fseek either flushes any buffered output before setting the file
position or else remembers it so it will be written later in its proper
place in the file.
Portability Note: In non-POSIX systems, ftell and
fseek might work reliably only on binary streams. See section Text and Binary Streams.
The following symbolic constants are defined for use as the whence
argument to fseek. They are also used with the lseek
function (see section Input and Output Primitives) and to specify offsets for file locks
(see section Control Operations on Files).
fseek function, specifies that the offset
provided is relative to the beginning of the file.
fseek function, specifies that the offset
provided is relative to the current file position.
fseek function, specifies that the offset
provided is relative to the end of the file.
rewind function positions the stream stream at the
begining of the file. It is equivalent to calling fseek on the
stream with an offset argument of 0L and a
whence argument of SEEK_SET, except that the return
value is discarded and the error indicator for the stream is reset.
These three aliases for the `SEEK_...' constants exist for the sake of compatibility with older BSD systems. They are defined in two different header files: `fcntl.h' and `sys/file.h'.
L_SET
SEEK_SET.
L_INCR
SEEK_CUR.
L_XTND
SEEK_END.
On the GNU system, the file position is truly a character count. You
can specify any character count value as an argument to fseek and
get reliable results for any random access file. However, some ISO C
systems do not represent file positions in this way.
On some systems where text streams truly differ from binary streams, it is impossible to represent the file position of a text stream as a count of characters from the beginning of the file. For example, the file position on some systems must encode both a record offset within the file, and a character offset within the record.
As a consequence, if you want your programs to be portable to these systems, you must observe certain rules:
ftell on a text stream has no predictable
relationship to the number of characters you have read so far. The only
thing you can rely on is that you can use it subsequently as the
offset argument to fseek to move back to the same file
position.
fseek on a text stream, either the offset must
either be zero; or whence must be SEEK_SET and the
offset must be the result of an earlier call to ftell on
the same stream.
ungetc
that haven't been read or discarded. See section Unreading.
But even if you observe these rules, you may still have trouble for long
files, because ftell and fseek use a long int value
to represent the file position. This type may not have room to encode
all the file positions in a large file.
So if you do want to support systems with peculiar encodings for the
file positions, it is better to use the functions fgetpos and
fsetpos instead. These functions represent the file position
using the data type fpos_t, whose internal representation varies
from system to system.
These symbols are declared in the header file `stdio.h'.
fgetpos and
fsetpos.
In the GNU system, fpos_t is equivalent to off_t or
long int. In other systems, it might have a different internal
representation.
fpos_t object pointed to by
position. If successful, fgetpos returns zero; otherwise
it returns a nonzero value and stores an implementation-defined positive
value in errno.
fgetpos on the same stream. If successful, fsetpos
clears the end-of-file indicator on the stream, discards any characters
that were "pushed back" by the use of ungetc, and returns a value
of zero. Otherwise, fsetpos returns a nonzero value and stores
an implementation-defined positive value in errno.
Characters that are written to a stream are normally accumulated and transmitted asynchronously to the file in a block, instead of appearing as soon as they are output by the application program. Similarly, streams often retrieve input from the host environment in blocks rather than on a character-by-character basis. This is called buffering.
If you are writing programs that do interactive input and output using streams, you need to understand how buffering works when you design the user interface to your program. Otherwise, you might find that output (such as progress or prompt messages) doesn't appear when you intended it to, or other unexpected behavior.
This section deals only with controlling when characters are transmitted between the stream and the file or device, and not with how things like echoing, flow control, and the like are handled on specific classes of devices. For information on common control operations on terminal devices, see section Low-Level Terminal Interface.
You can bypass the stream buffering facilities altogether by using the low-level input and output functions that operate on file descriptors instead. See section Low-Level Input/Output.
There are three different kinds of buffering strategies:
Newly opened streams are normally fully buffered, with one exception: a stream connected to an interactive device such as a terminal is initially line buffered. See section Controlling Which Kind of Buffering, for information on how to select a different kind of buffering. Usually the automatic selection gives you the most convenient kind of buffering for the file or device you open.
The use of line buffering for interactive devices implies that output
messages ending in a newline will appear immediately--which is usually
what you want. Output that doesn't end in a newline might or might not
show up immediately, so if you want them to appear immediately, you
should flush buffered output explicitly with fflush, as described
in section Flushing Buffers.
Flushing output on a buffered stream means transmitting all accumulated characters to the file. There are many circumstances when buffered output on a stream is flushed automatically:
exit.
See section Normal Termination.
If you want to flush the buffered output at another time, call
fflush, which is declared in the header file `stdio.h'.
fflush causes buffered output on all open output streams
to be flushed.
This function returns EOF if a write error occurs, or zero
otherwise.
Compatibility Note: Some brain-damaged operating systems have been known to be so thoroughly fixated on line-oriented input and output that flushing a line buffered stream causes a newline to be written! Fortunately, this "feature" seems to be becoming less common. You do not need to worry about this in the GNU system.
After opening a stream (but before any other operations have been
performed on it), you can explicitly specify what kind of buffering you
want it to have using the setvbuf function.
The facilities listed in this section are declared in the header file `stdio.h'.
_IOFBF
(for full buffering), _IOLBF (for line buffering), or
_IONBF (for unbuffered input/output).
If you specify a null pointer as the buf argument, then setvbuf
allocates a buffer itself using malloc. This buffer will be freed
when you close the stream.
Otherwise, buf should be a character array that can hold at least
size characters. You should not free the space for this array as
long as the stream remains open and this array remains its buffer. You
should usually either allocate it statically, or malloc
(see section Unconstrained Allocation) the buffer. Using an automatic array
is not a good idea unless you close the file before exiting the block
that declares the array.
While the array remains a stream buffer, the stream I/O functions will use the buffer for their internal purposes. You shouldn't try to access the values in the array directly while the stream is using it for buffering.
The setvbuf function returns zero on success, or a nonzero value
if the value of mode is not valid or if the request could not
be honored.
setvbuf function to
specify that the stream should be fully buffered.
setvbuf function to
specify that the stream should be line buffered.
setvbuf function to
specify that the stream should be unbuffered.
setvbuf. This value is
guaranteed to be at least 256.
The value of BUFSIZ is chosen on each system so as to make stream
I/O efficient. So it is a good idea to use BUFSIZ as the size
for the buffer when you call setvbuf.
Actually, you can get an even better value to use for the buffer size
by means of the fstat system call: it is found in the
st_blksize field of the file attributes. See section What the File Attribute Values Mean.
Sometimes people also use BUFSIZ as the allocation size of
buffers used for related purposes, such as strings used to receive a
line of input with fgets (see section Character Input). There is no
particular reason to use BUFSIZ for this instead of any other
integer, except that it might lead to doing I/O in chunks of an
efficient size.
setvbuf with a mode argument of
_IONBF. Otherwise, it is equivalent to calling setvbuf
with buf, and a mode of _IOFBF and a size
argument of BUFSIZ.
The setbuf function is provided for compatibility with old code;
use setvbuf in all new programs.
This function is provided for compatibility with old BSD code. Use
setvbuf instead.
This function is provided for compatibility with old BSD code. Use
setvbuf instead.
The GNU library provides ways for you to define additional kinds of streams that do not necessarily correspond to an open file.
One such type of stream takes input from or writes output to a string.
These kinds of streams are used internally to implement the
sprintf and sscanf functions. You can also create such a
stream explicitly, using the functions described in section String Streams.
More generally, you can define streams that do input/output to arbitrary objects using functions supplied by your program. This protocol is discussed in section Programming Your Own Custom Streams.
Portability Note: The facilities described in this section are specific to GNU. Other systems or C implementations might or might not provide equivalent functionality.
The fmemopen and open_memstream functions allow you to do
I/O to a string or memory buffer. These facilities are declared in
`stdio.h'.
If you specify a null pointer as the buf argument, fmemopen
dynamically allocates (as with malloc; see section Unconstrained Allocation) an array size bytes long. This is really only useful
if you are going to write things to the buffer and then read them back
in again, because you have no way of actually getting a pointer to the
buffer (for this, try open_memstream, below). The buffer is
freed when the stream is open.
The argument opentype is the same as in fopen
(See section Opening Streams). If the opentype specifies
append mode, then the initial file position is set to the first null
character in the buffer. Otherwise the initial file position is at the
beginning of the buffer.
When a stream open for writing is flushed or closed, a null character (zero byte) is written at the end of the buffer if it fits. You should add an extra byte to the size argument to account for this. Attempts to write more than size bytes to the buffer result in an error.
For a stream open for reading, null characters (zero bytes) in the buffer do not count as "end of file". Read operations indicate end of file only when the file position advances past size bytes. So, if you want to read characters from a null-terminated string, you should supply the length of the string as the size argument.
Here is an example of using fmemopen to create a stream for
reading from a string:
#include <stdio.h>
static char buffer[] = "foobar";
int
main (void)
{
int ch;
FILE *stream;
stream = fmemopen (buffer, strlen (buffer), "r");
while ((ch = fgetc (stream)) != EOF)
printf ("Got %c\n", ch);
fclose (stream);
return 0;
}
This program produces the following output:
Got f Got o Got o Got b Got a Got r
malloc; see section Unconstrained Allocation) and grown as necessary.
When the stream is closed with fclose or flushed with
fflush, the locations ptr and sizeloc are updated to
contain the pointer to the buffer and its size. The values thus stored
remain valid only as long as no further output on the stream takes
place. If you do more output, you must flush the stream again to store
new values before you use them again.
A null character is written at the end of the buffer. This null character is not included in the size value stored at sizeloc.
You can move the stream's file position with fseek (see section File Positioning). Moving the file position past the end of the data
already written fills the intervening space with zeroes.
Here is an example of using open_memstream:
#include <stdio.h>
int
main (void)
{
char *bp;
size_t size;
FILE *stream;
stream = open_memstream (&bp, &size);
fprintf (stream, "hello");
fflush (stream);
printf ("buf = `%s', size = %d\n", bp, size);
fprintf (stream, ", world");
fclose (stream);
printf ("buf = `%s', size = %d\n", bp, size);
return 0;
}
This program produces the following output:
buf = `hello', size = 5 buf = `hello, world', size = 12
You can open an output stream that puts it data in an obstack. See section Obstacks.
Calling fflush on this stream updates the current size of the
object to match the amount of data that has been written. After a call
to fflush, you can examine the object temporarily.
You can move the file position of an obstack stream with fseek
(see section File Positioning). Moving the file position past the end of
the data written fills the intervening space with zeros.
To make the object permanent, update the obstack with fflush, and
then use obstack_finish to finalize the object and get its address.
The following write to the stream starts a new object in the obstack,
and later writes add to that object until you do another fflush
and obstack_finish.
But how do you find out how long the object is? You can get the length
in bytes by calling obstack_object_size (see section Status of an Obstack), or you can null-terminate the object like this:
obstack_1grow (obstack, 0);
Whichever one you do, you must do it before calling
obstack_finish. (You can do both if you wish.)
Here is a sample function that uses open_obstack_stream:
char *
make_message_string (const char *a, int b)
{
FILE *stream = open_obstack_stream (&message_obstack);
output_task (stream);
fprintf (stream, ": ");
fprintf (stream, a, b);
fprintf (stream, "\n");
fclose (stream);
obstack_1grow (&message_obstack, 0);
return obstack_finish (&message_obstack);
}
This section describes how you can make a stream that gets input from an arbitrary data source or writes output to an arbitrary data sink programmed by you. We call these custom streams.
Inside every custom stream is a special object called the cookie.
This is an object supplied by you which records where to fetch or store
the data read or written. It is up to you to define a data type to use
for the cookie. The stream functions in the library never refer
directly to its contents, and they don't even know what the type is;
they record its address with type void *.
To implement a custom stream, you must specify how to fetch or store the data in the specified place. You do this by defining hook functions to read, write, change "file position", and close the stream. All four of these functions will be passed the stream's cookie so they can tell where to fetch or store the data. The library functions don't know what's inside the cookie, but your functions will know.
When you create a custom stream, you must specify the cookie pointer,
and also the four hook functions stored in a structure of type
cookie_io_functions_t.
These facilities are declared in `stdio.h'.
cookie_read_function_t *read
EOF.
cookie_write_function_t *write
cookie_seek_function_t *seek
fseek on this stream can only seek to locations within the
buffer; any attempt to seek outside the buffer will return an
ESPIPE error.
cookie_close_function_t *close
fopen;
see section Opening Streams. (But note that the "truncate on
open" option is ignored.) The new stream is fully buffered.
The fopencookie function returns the newly created stream, or a null
pointer in case of an error.
Here are more details on how you should define the four hook functions that a custom stream needs.
You should define the function to read data from the cookie as:
ssize_t reader (void *cookie, void *buffer, size_t size)
This is very similar to the read function; see section Input and Output Primitives. Your function should transfer up to size bytes into
the buffer, and return the number of bytes read, or zero to
indicate end-of-file. You can return a value of -1 to indicate
an error.
You should define the function to write data to the cookie as:
ssize_t writer (void *cookie, const void *buffer, size_t size)
This is very similar to the write function; see section Input and Output Primitives. Your function should transfer up to size bytes from
the buffer, and return the number of bytes written. You can return a
value of -1 to indicate an error.
You should define the function to perform seek operations on the cookie as:
int seeker (void *cookie, fpos_t *position, int whence)
For this function, the position and whence arguments are
interpreted as for fgetpos; see section Portable File-Position Functions. In
the GNU library, fpos_t is equivalent to off_t or
long int, and simply represents the number of bytes from the
beginning of the file.
After doing the seek operation, your function should store the resulting
file position relative to the beginning of the file in position.
Your function should return a value of 0 on success and -1
to indicate an error.
You should define the function to do cleanup operations on the cookie appropriate for closing the stream as:
int cleaner (void *cookie)
Your function should return -1 to indicate an error, and 0
otherwise.
This chapter describes functions for performing low-level input/output operations on file descriptors. These functions include the primitives for the higher-level I/O functions described in section Input/Output on Streams, as well as functions for performing low-level control operations for which there are no equivalents on streams.
Stream-level I/O is more flexible and usually more convenient; therefore, programmers generally use the descriptor-level functions only when necessary. These are some of the usual reasons:
fileno to get the descriptor
corresponding to a stream.)
This section describes the primitives for opening and closing files
using file descriptors. The open and creat functions are
declared in the header file `fcntl.h', while close is
declared in `unistd.h'.
open function creates and returns a new file descriptor
for the file named by filename. Initially, the file position
indicator for the file is at the beginning of the file. The argument
mode is used only when a file is created, but it doesn't hurt
to supply the argument in any case.
The flags argument controls how the file is to be opened. This is a bit mask; you create the value by the bitwise OR of the appropriate parameters (using the `|' operator in C). See section File Status Flags, for the parameters available.
The normal return value from open is a non-negative integer file
descriptor. In the case of an error, a value of -1 is returned
instead. In addition to the usual file name errors (see section File Name Errors), the following errno error conditions are defined
for this function:
EACCES
EEXIST
O_CREAT and O_EXCL are set, and the named file already
exists.
EINTR
open operation was interrupted by a signal.
See section Primitives Interrupted by Signals.
EISDIR
EMFILE
RLIMIT_NOFILE resource limit; see section Limiting Resource Usage.
ENFILE
ENOENT
O_CREAT is not specified.
ENOSPC
ENXIO
O_NONBLOCK and O_WRONLY are both set in the flags
argument, the file named by filename is a FIFO (see section Pipes and FIFOs), and no process has the file open for reading.
EROFS
O_WRONLY,
O_RDWR, and O_TRUNC are set in the flags argument,
or O_CREAT is set and the file does not already exist.
The open function is the underlying primitive for the fopen
and freopen functions, that create streams.
creat (filename, mode)
is equivalent to:
open (filename, O_WRONLY | O_CREAT | O_TRUNC, mode)
close closes the file descriptor filedes.
Closing a file has the following consequences:
The normal return value from close is 0; a value of -1
is returned in case of failure. The following errno error
conditions are defined for this function:
EBADF
EINTR
close call was interrupted by a signal.
See section Primitives Interrupted by Signals.
Here is an example of how to handle EINTR properly:
TEMP_FAILURE_RETRY (close (desc));
ENOSPC
EIO
EDQUOT
write can sometimes
not be detected until close. See section Input and Output Primitives, for details
on their meaning.
To close a stream, call fclose (see section Closing Streams) instead
of trying to close its underlying file descriptor with close.
This flushes any buffered output and updates the stream object to
indicate that it is closed.
This section describes the functions for performing primitive input and
output operations on file descriptors: read, write, and
lseek. These functions are declared in the header file
`unistd.h'.
size_t,
but must be a signed type.
read function reads up to size bytes from the file
with descriptor filedes, storing the results in the buffer.
(This is not necessarily a character string and there is no terminating
null character added.)
The return value is the number of bytes actually read. This might be less than size; for example, if there aren't that many bytes left in the file or if there aren't that many bytes immediately available. The exact behavior depends on what kind of file it is. Note that reading less than size bytes is not an error.
A value of zero indicates end-of-file (except if the value of the
size argument is also zero). This is not considered an error.
If you keep calling read while at end-of-file, it will keep
returning zero and doing nothing else.
If read returns at least one character, there is no way you can
tell whether end-of-file was reached. But if you did reach the end, the
next read will return zero.
In case of an error, read returns -1. The following
errno error conditions are defined for this function:
EAGAIN
read waits for
some input. But if the O_NONBLOCK flag is set for the file
(see section File Status Flags), read returns immediately without
reading any data, and reports this error.
Compatibility Note: Most versions of BSD Unix use a different
error code for this: EWOULDBLOCK. In the GNU library,
EWOULDBLOCK is an alias for EAGAIN, so it doesn't matter
which name you use.
On some systems, reading a large amount of data from a character special
file can also fail with EAGAIN if the kernel cannot find enough
physical memory to lock down the user's pages. This is limited to
devices that transfer with direct memory access into the user's memory,
which means it does not include terminals, since they always use
separate buffers inside the kernel. This problem never happens in the
GNU system.
Any condition that could result in EAGAIN can instead result in a
successful read which returns fewer bytes than requested.
Calling read again immediately would result in EAGAIN.
EBADF
EINTR
read was interrupted by a signal while it was waiting for input.
See section Primitives Interrupted by Signals. A signal will not necessary cause
read to return EINTR; it may instead result in a
successful read which returns fewer bytes than requested.
EIO
EIO also occurs when a background process tries to read from the
controlling terminal, and the normal action of stopping the process by
sending it a SIGTTIN signal isn't working. This might happen if
signal is being blocked or ignored, or because the process group is
orphaned. See section Job Control, for more information about job control,
and section Signal Handling, for information about signals.
The read function is the underlying primitive for all of the
functions that read from streams, such as fgetc.
write function writes up to size bytes from
buffer to the file with descriptor filedes. The data in
buffer is not necessarily a character string and a null character is
output like any other character.
The return value is the number of bytes actually written. This may be
size, but can always be smaller. Your program should always call
write in a loop, iterating until all the data is written.
Once write returns, the data is enqueued to be written and can be
read back right away, but it is not necessarily written out to permanent
storage immediately. You can use fsync when you need to be sure
your data has been permanently stored before continuing. (It is more
efficient for the system to batch up consecutive writes and do them all
at once when convenient. Normally they will always be written to disk
within a minute or less.)
You can use the O_FSYNC open mode to make write always
store the data to disk before returning; see section I/O Operating Modes.
In the case of an error, write returns -1. The following
errno error conditions are defined for this function:
EAGAIN
write blocks until the write operation is complete.
But if the O_NONBLOCK flag is set for the file (see section Control Operations on Files), it returns immediately without writing any data, and
reports this error. An example of a situation that might cause the
process to block on output is writing to a terminal device that supports
flow control, where output has been suspended by receipt of a STOP
character.
Compatibility Note: Most versions of BSD Unix use a different
error code for this: EWOULDBLOCK. In the GNU library,
EWOULDBLOCK is an alias for EAGAIN, so it doesn't matter
which name you use.
On some systems, writing a large amount of data from a character special
file can also fail with EAGAIN if the kernel cannot find enough
physical memory to lock down the user's pages. This is limited to
devices that transfer with direct memory access into the user's memory,
which means it does not include terminals, since they always use
separate buffers inside the kernel. This problem does not arise in the
GNU system.
EBADF
EFBIG
EINTR
write operation was interrupted by a signal while it was
blocked waiting for completion. A signal will not necessary cause
write to return EINTR; it may instead result in a
successful write which writes fewer bytes than requested.
See section Primitives Interrupted by Signals.
EIO
ENOSPC
EPIPE
SIGPIPE
signal is also sent to the process; see section Signal Handling.
Unless you have arranged to prevent EINTR failures, you should
check errno after each failing call to write, and if the
error was EINTR, you should simply repeat the call.
See section Primitives Interrupted by Signals. The easy way to do this is with the
macro TEMP_FAILURE_RETRY, as follows:
nbytes = TEMP_FAILURE_RETRY (write (desc, buffer, count));
The write function is the underlying primitive for all of the
functions that write to streams, such as fputc.
Just as you can set the file position of a stream with fseek, you
can set the file position of a descriptor with lseek. This
specifies the position in the file for the next read or
write operation. See section File Positioning, for more information
on the file position and what it means.
To read the current file position value from a descriptor, use
lseek (desc, 0, SEEK_CUR).
lseek function is used to change the file position of the
file with descriptor filedes.
The whence argument specifies how the offset should be
interpreted in the same way as for the fseek function, and must be
one of the symbolic constants SEEK_SET, SEEK_CUR, or
SEEK_END.
SEEK_SET
SEEK_CUR
SEEK_END
lseek is normally the resulting file
position, measured in bytes from the beginning of the file.
You can use this feature together with SEEK_CUR to read the
current file position.
If you want to append to the file, setting the file position to the
current end of file with SEEK_END is not sufficient. Another
process may write more data after you seek but before you write,
extending the file so the position you write onto clobbers their data.
Instead, use the O_APPEND operating mode; see section I/O Operating Modes.
You can set the file position past the current end of the file. This
does not by itself make the file longer; lseek never changes the
file. But subsequent output at that position will extend the file.
Characters between the previous end of file and the new position are
filled with zeros. Extending the file in this way can create a
"hole": the blocks of zeros are not actually allocated on disk, so the
file takes up less space than it appears so; it is then called a
"sparse file".
If the file position cannot be changed, or the operation is in some way
invalid, lseek returns a value of -1. The following
errno error conditions are defined for this function:
EBADF
EINVAL
ESPIPE
ESPIPE if the object is not seekable.)
lseek function is the underlying primitive for the
fseek, ftell and rewind functions, which operate on
streams instead of file descriptors.
dup.
Descriptors that come from separate calls to open have independent
file positions; using lseek on one descriptor has no effect on the
other. For example,
{
int d1, d2;
char buf[4];
d1 = open ("foo", O_RDONLY);
d2 = open ("foo", O_RDONLY);
lseek (d1, 1024, SEEK_SET);
read (d2, buf, 4);
}
will read the first four characters of the file `foo'. (The
error-checking code necessary for a real program has been omitted here
for brevity.)
By contrast, descriptors made by duplication share a common file
position with the original descriptor that was duplicated. Anything
which alters the file position of one of the duplicates, including
reading or writing data, affects all of them alike. Thus, for example,
{
int d1, d2, d3;
char buf1[4], buf2[4];
d1 = open ("foo", O_RDONLY);
d2 = dup (d1);
d3 = dup (d2);
lseek (d3, 1024, SEEK_SET);
read (d1, buf1, 4);
read (d2, buf2, 4);
}
will read four characters starting with the 1024'th character of
`foo', and then four more characters starting with the 1028'th
character.
fpos_t or long int.
L_SET
SEEK_SET.
L_INCR
SEEK_CUR.
L_XTND
SEEK_END.
Given an open file descriptor, you can create a stream for it with the
fdopen function. You can get the underlying file descriptor for
an existing stream with the fileno function. These functions are
declared in the header file `stdio.h'.
fdopen function returns a new stream for the file descriptor
filedes.
The opentype argument is interpreted in the same way as for the
fopen function (see section Opening Streams), except that
the `b' option is not permitted; this is because GNU makes no
distinction between text and binary files. Also, "w" and
"w+" do not cause truncation of the file; these have affect only
when opening a file, and in this case the file has already been opened.
You must make sure that the opentype argument matches the actual
mode of the open file descriptor.
The return value is the new stream. If the stream cannot be created (for example, if the modes for the file indicated by the file descriptor do not permit the access specified by the opentype argument), a null pointer is returned instead.
In some other systems, fdopen may fail to detect that the modes
for file descriptor do not permit the access specified by
opentype. The GNU C library always checks for this.
For an example showing the use of the fdopen function,
see section Creating a Pipe.
fileno returns -1.
There are also symbolic constants defined in `unistd.h' for the
file descriptors belonging to the standard streams stdin,
stdout, and stderr; see section Standard Streams.
STDIN_FILENO
0, which is the file descriptor for
standard input.
STDOUT_FILENO
1, which is the file descriptor for
standard output.
STDERR_FILENO
2, which is the file descriptor for
standard error output.
You can have multiple file descriptors and streams (let's call both streams and descriptors "channels" for short) connected to the same file, but you must take care to avoid confusion between channels. There are two cases to consider: linked channels that share a single file position value, and independent channels that have their own file positions.
It's best to use just one channel in your program for actual data
transfer to any given file, except when all the access is for input.
For example, if you open a pipe (something you can only do at the file
descriptor level), either do all I/O with the descriptor, or construct a
stream from the descriptor with fdopen and then do all I/O with
the stream.
Channels that come from a single opening share the same file position;
we call them linked channels. Linked channels result when you
make a stream from a descriptor using fdopen, when you get a
descriptor from a stream with fileno, when you copy a descriptor
with dup or dup2, and when descriptors are inherited
during fork. For files that don't support random access, such as
terminals and pipes, all channels are effectively linked. On
random-access files, all append-type output streams are effectively
linked to each other.
If you have been using a stream for I/O, and you want to do I/O using another channel (either a stream or a descriptor) that is linked to it, you must first clean up the stream that you have been using. See section Cleaning Streams.
Terminating a process, or executing a new program in the process, destroys all the streams in the process. If descriptors linked to these streams persist in other processes, their file positions become undefined as a result. To prevent this, you must clean up the streams before destroying them.
When you open channels (streams or descriptors) separately on a seekable file, each channel has its own file position. These are called independent channels.
The system handles each channel independently. Most of the time, this is quite predictable and natural (especially for input): each channel can read or write sequentially at its own place in the file. However, if some of the channels are streams, you must take these precautions:
If you do output to one channel at the end of the file, this will certainly leave the other independent channels positioned somewhere before the new end. You cannot reliably set their file positions to the new end of file before writing, because the file can always be extended by another process between when you set the file position and when you write the data. Instead, use an append-type descriptor or stream; they always output at the current end of the file. In order to make the end-of-file position accurate, you must clean the output channel you were using, if it is a stream.
It's impossible for two channels to have separate file pointers for a file that doesn't support random access. Thus, channels for reading or writing such files are always linked, never independent. Append-type channels are also always linked. For these channels, follow the rules for linked channels; see section Linked Channels.
On the GNU system, you can clean up any stream with fclean:
On other systems, you can use fflush to clean a stream in most
cases.
You can skip the fclean or fflush if you know the stream
is already clean. A stream is clean whenever its buffer is empty. For
example, an unbuffered stream is always clean. An input stream that is
at end-of-file is clean. A line-buffered stream is clean when the last
character output was a newline.
There is one case in which cleaning a stream is impossible on most
systems. This is when the stream is doing input from a file that is not
random-access. Such streams typically read ahead, and when the file is
not random access, there is no way to give back the excess data already
read. When an input stream reads from a random-access file,
fflush does clean the stream, but leaves the file pointer at an
unpredictable place; you must set the file pointer before doing any
further I/O. On the GNU system, using fclean avoids both of
these problems.
Closing an output-only stream also does fflush, so this is a
valid way of cleaning an output stream. On the GNU system, closing an
input stream does fclean.
You need not clean a stream before using its descriptor for control operations such as setting terminal modes; these operations don't affect the file position and are not affected by it. You can use any descriptor for these operations, and all channels are affected simultaneously. However, text already "output" to a stream but still buffered by the stream will be subject to the new terminal modes when subsequently flushed. To make sure "past" output is covered by the terminal settings that were in effect at the time, flush the output streams for that terminal before setting the modes. See section Terminal Modes.
Sometimes a program needs to accept input on multiple input channels whenever input arrives. For example, some workstations may have devices such as a digitizing tablet, function button box, or dial box that are connected via normal asynchronous serial interfaces; good user interface style requires responding immediately to input on any device. Another example is a program that acts as a server to several other processes via pipes or sockets.
You cannot normally use read for this purpose, because this
blocks the program until input is available on one particular file
descriptor; input on other channels won't wake it up. You could set
nonblocking mode and poll each file descriptor in turn, but this is very
inefficient.
A better solution is to use the select function. This blocks the
program until input or output is ready on a specified set of file
descriptors, or until a timer expires, whichever comes first. This
facility is declared in the header file `sys/types.h'.
In the case of a server socket (see section Listening for Connections), we say that
"input" is available when there are pending connections that could be
accepted (see section Accepting Connections). accept for server
sockets blocks and interacts with select just as read does
for normal input.
The file descriptor sets for the select function are specified
as fd_set objects. Here is the description of the data type
and some macros for manipulating these objects.
fd_set data type represents file descriptor sets for the
select function. It is actually a bit array.
fd_set object can hold information about. On systems with a
fixed maximum number, FD_SETSIZE is at least that number. On
some systems, including GNU, there is no absolute limit on the number of
descriptors open, but this macro still has a constant value which
controls the number of bits in an fd_set; if you get a file
descriptor with a value as high as FD_SETSIZE, you cannot put
that descriptor into an fd_set.
Next, here is the description of the select function itself.
select function blocks the calling process until there is
activity on any of the specified sets of file descriptors, or until the
timeout period has expired.
The file descriptors specified by the read-fds argument are checked to see if they are ready for reading; the write-fds file descriptors are checked to see if they are ready for writing; and the except-fds file descriptors are checked for exceptional conditions. You can pass a null pointer for any of these arguments if you are not interested in checking for that kind of condition.
A file descriptor is considered ready for reading if it is at end of
file. A server socket is considered ready for reading if there is a
pending connection which can be accepted with accept;
see section Accepting Connections. A client socket is ready for writing when
its connection is fully established; see section Making a Connection.
"Exceptional conditions" does not mean errors--errors are reported immediately when an erroneous system call is executed, and do not constitute a state of the descriptor. Rather, they include conditions such as the presence of an urgent message on a socket. (See section Sockets, for information on urgent messages.)
The select function checks only the first nfds file
descriptors. The usual thing is to pass FD_SETSIZE as the value
of this argument.
The timeout specifies the maximum time to wait. If you pass a
null pointer for this argument, it means to block indefinitely until one
of the file descriptors is ready. Otherwise, you should provide the
time in struct timeval format; see section High-Resolution Calendar. Specify zero as the time (a struct timeval containing
all zeros) if you want to find out which descriptors are ready without
waiting if none are ready.
The normal return value from select is the total number of ready file
descriptors in all of the sets. Each of the argument sets is overwritten
with information about the descriptors that are ready for the corresponding
operation. Thus, to see if a particular descriptor desc has input,
use FD_ISSET (desc, read-fds) after select returns.
If select returns because the timeout period expires, it returns
a value of zero.
Any signal will cause select to return immediately. So if your
program uses signals, you can't rely on select to keep waiting
for the full time specified. If you want to be sure of waiting for a
particular amount of time, you must check for EINTR and repeat
the select with a newly calculated timeout based on the current
time. See the example below. See also section Primitives Interrupted by Signals.
If an error occurs, select returns -1 and does not modify
the argument file descriptor sets. The following errno error
conditions are defined for this function:
EBADF
EINTR
EINVAL
Portability Note: The select function is a BSD Unix
feature.
Here is an example showing how you can use select to establish a
timeout period for reading from a file descriptor. The input_timeout
function blocks the calling process until input is available on the
file descriptor, or until the timeout period expires.
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/time.h>
int
input_timeout (int filedes, unsigned int seconds)
{
fd_set set;
struct timeval timeout;
/* Initialize the file descriptor set. */
FD_ZERO (&set);
FD_SET (filedes, &set);
/* Initialize the timeout data structure. */
timeout.tv_sec = seconds;
timeout.tv_usec = 0;
/* select returns 0 if timeout, 1 if input available, -1 if error. */
return TEMP_FAILURE_RETRY (select (FD_SETSIZE,
&set, NULL, NULL,
&timeout));
}
int
main (void)
{
fprintf (stderr, "select returned %d.\n",
input_timeout (STDIN_FILENO, 5));
return 0;
}
There is another example showing the use of select to multiplex
input from multiple sockets in section Byte Stream Connection Server Example.
This section describes how you can perform various other operations on
file descriptors, such as inquiring about or setting flags describing
the status of the file descriptor, manipulating record locks, and the
like. All of these operations are performed by the function fcntl.
The second argument to the fcntl function is a command that
specifies which operation to perform. The function and macros that name
various flags that are used with it are declared in the header file
`fcntl.h'. Many of these flags are also used by the open
function; see section Opening and Closing Files.
fcntl function performs the operation specified by
command on the file descriptor filedes. Some commands
require additional arguments to be supplied. These additional arguments
and the return value and error conditions are given in the detailed
descriptions of the individual commands.
Briefly, here is a list of what the various commands are.
F_DUPFD
F_GETFD
F_SETFD
F_GETFL
F_SETFL
F_GETLK
F_SETLK
F_SETLKW
F_SETLK, but wait for completion. See section File Locks.
F_GETOWN
SIGIO signals.
See section Interrupt-Driven Input.
F_SETOWN
SIGIO signals.
See section Interrupt-Driven Input.
You can duplicate a file descriptor, or allocate another file descriptor that refers to the same open file as the original. Duplicate descriptors share one file position and one set of file status flags (see section File Status Flags), but each has its own set of file descriptor flags (see section File Descriptor Flags).
The major use of duplicating a file descriptor is to implement redirection of input or output: that is, to change the file or pipe that a particular file descriptor corresponds to.
You can perform this operation using the fcntl function with the
F_DUPFD command, but there are also convenient functions
dup and dup2 for duplicating descriptors.
The fcntl function and flags are declared in `fcntl.h',
while prototypes for dup and dup2 are in the header file
`unistd.h'.
fcntl (old, F_DUPFD, 0).
If old is an invalid descriptor, then dup2 does nothing; it
does not close new. Otherwise, the new duplicate of old
replaces any previous meaning of descriptor new, as if new
were closed first.
If old and new are different numbers, and old is a
valid descriptor number, then dup2 is equivalent to:
close (new); fcntl (old, F_DUPFD, new)
However, dup2 does this atomically; there is no instant in the
middle of calling dup2 at which new is closed and not yet a
duplicate of old.
fcntl, to
copy the file descriptor given as the first argument.
The form of the call in this case is:
fcntl (old, F_DUPFD, next-filedes)
The next-filedes argument is of type int and specifies that
the file descriptor returned should be the next available one greater
than or equal to this value.
The return value from fcntl with this command is normally the value
of the new file descriptor. A return value of -1 indicates an
error. The following errno error conditions are defined for
this command:
EBADF
EINVAL
EMFILE
RLIMIT_NOFILE limit.
ENFILE is not a possible error code for dup2 because
dup2 does not create a new opening of a file; duplicate
descriptors do not count toward the limit which ENFILE
indicates. EMFILE is possible because it refers to the limit on
distinct descriptor numbers in use in one process.
Here is an example showing how to use dup2 to do redirection.
Typically, redirection of the standard streams (like stdin) is
done by a shell or shell-like program before calling one of the
exec functions (see section Executing a File) to execute a new
program in a child process. When the new program is executed, it
creates and initializes the standard streams to point to the
corresponding file descriptors, before its main function is
invoked.
So, to redirect standard input to a file, the shell could do something like:
pid = fork ();
if (pid == 0)
{
char *filename;
char *program;
int file;
...
file = TEMP_FAILURE_RETRY (open (filename, O_RDONLY));
dup2 (file, STDIN_FILENO);
TEMP_FAILURE_RETRY (close (file));
execv (program, NULL);
}
There is also a more detailed example showing how to implement redirection in the context of a pipeline of processes in section Launching Jobs.
File descriptor flags are miscellaneous attributes of a file descriptor. These flags are associated with particular file descriptors, so that if you have created duplicate file descriptors from a single opening of a file, each descriptor has its own set of flags.
Currently there is just one file descriptor flag: FD_CLOEXEC,
which causes the descriptor to be closed if you use any of the
exec... functions (see section Executing a File).
The symbols in this section are defined in the header file `fcntl.h'.
fcntl, to
specify that it should return the file descriptor flags associated
with the filedes argument.
The normal return value from fcntl with this command is a
nonnegative number which can be interpreted as the bitwise OR of the
individual flags (except that currently there is only one flag to use).
In case of an error, fcntl returns -1. The following
errno error conditions are defined for this command:
EBADF
fcntl, to
specify that it should set the file descriptor flags associated with the
filedes argument. This requires a third int argument to
specify the new flags, so the form of the call is:
fcntl (filedes, F_SETFD, new-flags)
The normal return value from fcntl with this command is an
unspecified value other than -1, which indicates an error.
The flags and error conditions are the same as for the F_GETFD
command.
The following macro is defined for use as a file descriptor flag with
the fcntl function. The value is an integer constant usable
as a bit mask value.
exec function is invoked; see section Executing a File. When
a file descriptor is allocated (as with open or dup),
this bit is initially cleared on the new file descriptor, meaning that
descriptor will survive into the new program after exec.
If you want to modify the file descriptor flags, you should get the
current flags with F_GETFD and modify the value. Don't assume
that the flags listed here are the only ones that are implemented; your
program may be run years from now and more flags may exist then. For
example, here is a function to set or clear the flag FD_CLOEXEC
without altering any other flags:
/* Set theFD_CLOEXECflag of desc if value is nonzero, or clear the flag if value is 0. Return 0 on success, or -1 on error witherrnoset. */ int set_cloexec_flag (int desc, int value) { int oldflags = fcntl (desc, F_GETFD, 0); /* If reading the flags failed, return error indication now. if (oldflags < 0) return oldflags; /* Set just the flag we want to set. */ if (value != 0) oldflags |= FD_CLOEXEC; else oldflags &= ~FD_CLOEXEC; /* Store modified flag word in the descriptor. */ return fcntl (desc, F_SETFD, oldflags); }
File status flags are used to specify attributes of the opening of a
file. Unlike the file descriptor flags discussed in section File Descriptor Flags, the file status flags are shared by duplicated file descriptors
resulting from a single opening of the file. The file status flags are
specified with the flags argument to open;
see section Opening and Closing Files.
File status flags fall into three categories, which are described in the following sections.
open and are
returned by fcntl, but cannot be changed.
open will do.
These flags are not preserved after the open call.
read and
write are done. They are set by open, and can be fetched or
changed with fcntl.
The symbols in this section are defined in the header file `fcntl.h'.
The file access modes allow a file descriptor to be used for reading, writing, or both. (In the GNU system, they can also allow none of these, and allow execution of the file as a program.) The access modes are chosen when the file is opened, and never change.
In the GNU system (and not in other systems), O_RDONLY and
O_WRONLY are independent bits that can be bitwise-ORed together,
and it is valid for either bit to be set or clear. This means that
O_RDWR is the same as O_RDONLY|O_WRONLY. A file access
mode of zero is permissible; it allows no operations that do input or
output to the file, but does allow other operations such as
fchmod. On the GNU system, since "read-only" or "write-only"
is a misnomer, `fcntl.h' defines additional names for the file
access modes. These names are preferred when writing GNU-specific code.
But most programs will want to be portable to other POSIX.1 systems and
should use the POSIX.1 names above instead.
O_RDWR; only defined on GNU.
O_WRONLY; only defined on GNU.
To determine the file access mode with fcntl, you must extract
the access mode bits from the retrieved file status flags. In the GNU
system, you can just test the O_READ and O_WRITE bits in
the flags word. But in other POSIX.1 systems, reading and writing
access modes are not stored as distinct bit flags. The portable way to
extract the file access mode bits is with O_ACCMODE.
O_RDONLY, O_WRONLY, or O_RDWR.
(In the GNU system it could also be zero, and it never includes the
O_EXEC bit.)
The open-time flags specify options affecting how open will behave.
These options are not preserved once the file is open. The exception to
this is O_NONBLOCK, which is also an I/O operating mode and so it
is saved. See section Opening and Closing Files, for how to call
open.
There are two sorts of options specified by open-time flags.
open looks up the
file name to locate the file, and whether the file can be created.
open will
perform on the file once it is open.
Here are the file name translation flags.
O_CREAT and O_EXCL are set, then open fails
if the specified file already exists. This is guaranteed to never
clobber an existing file.
open from blocking for a "long time" to open the
file. This is only meaningful for some kinds of files, usually devices
such as serial ports; when it is not meaningful, it is harmless and
ignored. Often opening a port to a modem blocks until the modem reports
carrier detection; if O_NONBLOCK is specified, open will
return immediately without a carrier.
Note that the O_NONBLOCK flag is overloaded as both an I/O operating
mode and a file name translation flag. This means that specifying
O_NONBLOCK in open also sets nonblocking I/O mode;
see section I/O Operating Modes. To open the file without blocking but do normal
I/O that blocks, you must call open with O_NONBLOCK set and
then call fcntl to turn the bit off.
In the GNU system and 4.4 BSD, opening a file never makes it the
controlling terminal and O_NOCTTY is zero. However, other
systems may use a nonzero value for O_NOCTTY and set the
controlling terminal when you open a file that is a terminal device; so
to be portable, use O_NOCTTY when it is important to avoid this.
The following three file name translation flags exist only in the GNU system.
fstat on the new file descriptor will
return the information returned by lstat on the link's name.)
The open-time action flags tell open to do additional operations
which are not really related to opening the file. The reason to do them
as part of open instead of in separate calls is that open
can do them atomically.
O_TRUNC. In
BSD and GNU you must have permission to write the file to truncate it,
but you need not open for write access.
This is the only open-time action flag specified by POSIX.1. There is
no good reason for truncation to be done by open, instead of by
calling ftruncate afterwards. The O_TRUNC flag existed in
Unix before ftruncate was invented, and is retained for backward
compatibility.
flock.
See section File Locks.
If O_CREAT is specified, the locking is done atomically when
creating the file. You are guaranteed that no other process will get
the lock on the new file first.
flock.
See section File Locks. This is atomic like O_SHLOCK.
The operating modes affect how input and output operations using a file
descriptor work. These flags are set by open and can be fetched
and changed with fcntl.
write operations write the data at the end of the file, extending
it, regardless of the current file position. This is the only reliable
way to append to a file. In append mode, you are guaranteed that the
data you write will always go to the current end of the file, regardless
of other processes writing to the file. Conversely, if you simply set
the file position to the end of file and write, then another process can
extend the file after you set the file position but before you write,
resulting in your data appearing someplace before the real end of file.
read requests on the file can return immediately with a failure
status if there is no input immediately available, instead of blocking.
Likewise, write requests can also return immediately with a
failure status if the output can't be written immediately.
Note that the O_NONBLOCK flag is overloaded as both an I/O
operating mode and a file name translation flag; see section Open-time Flags.
O_NONBLOCK, provided for
compatibility with BSD. It is not defined by the POSIX.1 standard.
The remaining operating modes are BSD and GNU extensions. They exist only on some systems. On other systems, these macros are not defined.
SIGIO
signals will be generated when input is available. See section Interrupt-Driven Input.
Asynchronous input mode is a BSD feature.
write call will make sure the data is reliably stored on disk before
returning.
Synchronous writing is a BSD feature.
O_FSYNC. They have the same value.
read will not update the access time of the
file. See section File Times. This is used by programs that do backups, so
that backing a file up does not count as reading it.
Only the owner of the file or the superuser may use this bit.
This is a GNU extension.
The fcntl function can fetch or change file status flags.
fcntl, to
read the file status flags for the open file with descriptor
filedes.
The normal return value from fcntl with this command is a
nonnegative number which can be interpreted as the bitwise OR of the
individual flags. Since the file access modes are not single-bit values,
you can mask off other bits in the returned flags with O_ACCMODE
to compare them.
In case of an error, fcntl returns -1. The following
errno error conditions are defined for this command:
EBADF
fcntl, to set
the file status flags for the open file corresponding to the
filedes argument. This command requires a third int
argument to specify the new flags, so the call looks like this:
fcntl (filedes, F_SETFL, new-flags)
You can't change the access mode for the file in this way; that is, whether the file descriptor was opened for reading or writing.
The normal return value from fcntl with this command is an
unspecified value other than -1, which indicates an error. The
error conditions are the same as for the F_GETFL command.
If you want to modify the file status flags, you should get the current
flags with F_GETFL and modify the value. Don't assume that the
flags listed here are the only ones that are implemented; your program
may be run years from now and more flags may exist then. For example,
here is a function to set or clear the flag O_NONBLOCK without
altering any other flags:
/* Set theO_NONBLOCKflag of desc if value is nonzero, or clear the flag if value is 0. Return 0 on success, or -1 on error witherrnoset. */ int set_nonblock_flag (int desc, int value) { int oldflags = fcntl (desc, F_GETFL, 0); /* If reading the flags failed, return error indication now. */ if (oldflags == -1) return -1; /* Set just the flag we want to set. */ if (value != 0) oldflags |= O_NONBLOCK; else oldflags &= ~O_NONBLOCK; /* Store modified flag word in the descriptor. */ return fcntl (desc, F_SETFL, oldflags); }
The remaining fcntl commands are used to support record
locking, which permits multiple cooperating programs to prevent each
other from simultaneously accessing parts of a file in error-prone
ways.
An exclusive or write lock gives a process exclusive access for writing to the specified part of the file. While a write lock is in place, no other process can lock that part of the file.
A shared or read lock prohibits any other process from requesting a write lock on the specified part of the file. However, other processes can request read locks.
The read and write functions do not actually check to see
whether there are any locks in place. If you want to implement a
locking protocol for a file shared by multiple processes, your application
must do explicit fcntl calls to request and clear locks at the
appropriate points.
Locks are associated with processes. A process can only have one kind
of lock set for each byte of a given file. When any file descriptor for
that file is closed by the process, all of the locks that process holds
on that file are released, even if the locks were made using other
descriptors that remain open. Likewise, locks are released when a
process exits, and are not inherited by child processes created using
fork (see section Creating a Process).
When making a lock, use a struct flock to specify what kind of
lock and where. This data type and the associated macros for the
fcntl function are declared in the header file `fcntl.h'.
fcntl function to describe a file
lock. It has these members:
short int l_type
F_RDLCK, F_WRLCK, or
F_UNLCK.
short int l_whence
fseek or
lseek, and specifies what the offset is relative to. Its value
can be one of SEEK_SET, SEEK_CUR, or SEEK_END.
off_t l_start
l_whence member.
off_t l_len
0 is treated specially; it means the region extends to the end of
the file.
pid_t l_pid
fcntl with
the F_GETLK command, but is ignored when making a lock.
fcntl, to
specify that it should get information about a lock. This command
requires a third argument of type struct flock * to be passed
to fcntl, so that the form of the call is:
fcntl (filedes, F_GETLK, lockp)
If there is a lock already in place that would block the lock described
by the lockp argument, information about that lock overwrites
*lockp. Existing locks are not reported if they are
compatible with making a new lock as specified. Thus, you should
specify a lock type of F_WRLCK if you want to find out about both
read and write locks, or F_RDLCK if you want to find out about
write locks only.
There might be more than one lock affecting the region specified by the
lockp argument, but fcntl only returns information about
one of them. The l_whence member of the lockp structure is
set to SEEK_SET and the l_start and l_len fields
set to identify the locked region.
If no lock applies, the only change to the lockp structure is to
update the l_type to a value of F_UNLCK.
The normal return value from fcntl with this command is an
unspecified value other than -1, which is reserved to indicate an
error. The following errno error conditions are defined for
this command:
EBADF
EINVAL
fcntl, to
specify that it should set or clear a lock. This command requires a
third argument of type struct flock * to be passed to
fcntl, so that the form of the call is:
fcntl (filedes, F_SETLK, lockp)
If the process already has a lock on any part of the region, the old lock
on that part is replaced with the new lock. You can remove a lock
by specifying a lock type of F_UNLCK.
If the lock cannot be set, fcntl returns immediately with a value
of -1. This function does not block waiting for other processes
to release locks. If fcntl succeeds, it return a value other
than -1.
The following errno error conditions are defined for this
function:
EAGAIN
EACCES
EAGAIN in this case, and other systems
use EACCES; your program should treat them alike, after
F_SETLK. (The GNU system always uses EAGAIN.)
EBADF
EINVAL
ENOLCK
fcntl, to
specify that it should set or clear a lock. It is just like the
F_SETLK command, but causes the process to block (or wait)
until the request can be specified.
This command requires a third argument of type struct flock *, as
for the F_SETLK command.
The fcntl return values and errors are the same as for the
F_SETLK command, but these additional errno error conditions
are defined for this command:
EINTR
EDEADLK
The following macros are defined for use as values for the l_type
member of the flock structure. The values are integer constants.
F_RDLCK
F_WRLCK
F_UNLCK
As an example of a situation where file locking is useful, consider a program that can be run simultaneously by several different users, that logs status information to a common file. One example of such a program might be a game that uses a file to keep track of high scores. Another example might be a program that records usage or accounting information for billing purposes.
Having multiple copies of the program simultaneously writing to the file could cause the contents of the file to become mixed up. But you can prevent this kind of problem by setting a write lock on the file before actually writing to the file.
If the program also needs to read the file and wants to make sure that the contents of the file are in a consistent state, then it can also use a read lock. While the read lock is set, no other process can lock that part of the file for writing.
Remember that file locks are only a voluntary protocol for controlling access to a file. There is still potential for access to the file by programs that don't use the lock protocol.
If you set the O_ASYNC status flag on a file descriptor
(see section File Status Flags), a SIGIO signal is sent whenever
input or output becomes possible on that file descriptor. The process
or process group to receive the signal can be selected by using the
F_SETOWN command to the fcntl function. If the file
descriptor is a socket, this also selects the recipient of SIGURG
signals that are delivered when out-of-band data arrives on that socket;
see section Out-of-Band Data. (SIGURG is sent in any situation
where select would report the socket as having an "exceptional
condition". See section Waiting for Input or Output.)
If the file descriptor corresponds to a terminal device, then SIGIO
signals are sent to the foreground process group of the terminal.
See section Job Control.
The symbols in this section are defined in the header file `fcntl.h'.
fcntl, to
specify that it should get information about the process or process
group to which SIGIO signals are sent. (For a terminal, this is
actually the foreground process group ID, which you can get using
tcgetpgrp; see section Functions for Controlling Terminal Access.)
The return value is interpreted as a process ID; if negative, its absolute value is the process group ID.
The following errno error condition is defined for this command:
EBADF
fcntl, to
specify that it should set the process or process group to which
SIGIO signals are sent. This command requires a third argument
of type pid_t to be passed to fcntl, so that the form of
the call is:
fcntl (filedes, F_SETOWN, pid)
The pid argument should be a process ID. You can also pass a negative number whose absolute value is a process group ID.
The return value from fcntl with this command is -1
in case of error and some other value if successful. The following
errno error conditions are defined for this command:
EBADF
ESRCH
This chapter describes the GNU C library's functions for manipulating files. Unlike the input and output functions described in section Input/Output on Streams and section Low-Level Input/Output, these functions are concerned with operating on the files themselves, rather than on their contents.
Among the facilities described in this chapter are functions for examining or modifying directories, functions for renaming and deleting files, and functions for examining and setting file attributes such as access permissions and modification times.
Each process has associated with it a directory, called its current working directory or simply working directory, that is used in the resolution of relative file names (see section File Name Resolution).
When you log in and begin a new session, your working directory is
initially set to the home directory associated with your login account
in the system user database. You can find any user's home directory
using the getpwuid or getpwnam functions; see section User Database.
Users can change the working directory using shell commands like
cd. The functions described in this section are the primitives
used by those commands and by other programs for examining and changing
the working directory.
Prototypes for these functions are declared in the header file `unistd.h'.
getcwd function returns an absolute file name representing
the current working directory, storing it in the character array
buffer that you provide. The size argument is how you tell
the system the allocation size of buffer.
The GNU library version of this function also permits you to specify a
null pointer for the buffer argument. Then getcwd
allocates a buffer automatically, as with malloc
(see section Unconstrained Allocation). If the size is greater than
zero, then the buffer is that large; otherwise, the buffer is as large
as necessary to hold the result.
The return value is buffer on success and a null pointer on failure.
The following errno error conditions are defined for this function:
EINVAL
ERANGE
EACCES
Here is an example showing how you could implement the behavior of GNU's
getcwd (NULL, 0) using only the standard behavior of
getcwd:
char *
gnu_getcwd ()
{
int size = 100;
char *buffer = (char *) xmalloc (size);
while (1)
{
char *value = getcwd (buffer, size);
if (value != 0)
return buffer;
size *= 2;
free (buffer);
buffer = (char *) xmalloc (size);
}
}
See section Examples of malloc, for information about xmalloc, which is
not a library function but is a customary name used in most GNU
software.
getcwd, but has no way to specify the size of
the buffer. The GNU library provides getwd only
for backwards compatibility with BSD.
The buffer argument should be a pointer to an array at least
PATH_MAX bytes long (see section Limits on File System Capacity). In the GNU
system there is no limit to the size of a file name, so this is not
necessarily enough space to contain the directory name. That is why
this function is deprecated.
The normal, successful return value from chdir is 0. A
value of -1 is returned to indicate an error. The errno
error conditions defined for this function are the usual file name
syntax errors (see section File Name Errors), plus ENOTDIR if the
file filename is not a directory.
The facilities described in this section let you read the contents of a directory file. This is useful if you want your program to list all the files in a directory, perhaps as part of a menu.
The opendir function opens a directory stream whose
elements are directory entries. You use the readdir function on
the directory stream to retrieve these entries, represented as
struct dirent objects. The name of the file for each entry is
stored in the d_name member of this structure. There are obvious
parallels here to the stream facilities for ordinary files, described in
section Input/Output on Streams.
This section describes what you find in a single directory entry, as you might obtain it from a directory stream. All the symbols are declared in the header file `dirent.h'.
char d_name[]
ino_t d_fileno
d_ino. In the GNU system and most POSIX
systems, for most files this the same as the st_ino member that
stat will return for the file. See section File Attributes.
unsigned char d_namlen
unsigned char because that is the integer
type of the appropriate size
unsigned char d_type
DT_UNKNOWN
DT_REG
DT_DIR
DT_FIFO
DT_SOCK
DT_CHR
DT_BLK
st_mode member of
struct statbuf. These two macros convert between d_type
values and st_mode values:
d_type value corresponding to mode.
st_mode value corresponding to dirtype.
This structure may contain additional members in the future.
When a file has multiple names, each name has its own directory entry.
The only way you can tell that the directory entries belong to a
single file is that they have the same value for the d_fileno
field.
File attributes such as size, modification times, and the like are part of the file itself, not any particular directory entry. See section File Attributes.
This section describes how to open a directory stream. All the symbols are declared in the header file `dirent.h'.
DIR data type represents a directory stream.
You shouldn't ever allocate objects of the struct dirent or
DIR data types, since the directory access functions do that for
you. Instead, you refer to these objects using the pointers returned by
the following functions.
opendir function opens and returns a directory stream for
reading the directory whose file name is dirname. The stream has
type DIR *.
If unsuccessful, opendir returns a null pointer. In addition to
the usual file name errors (see section File Name Errors), the
following errno error conditions are defined for this function:
EACCES
dirname.
EMFILE
ENFILE
The DIR type is typically implemented using a file descriptor,
and the opendir function in terms of the open function.
See section Low-Level Input/Output. Directory streams and the underlying
file descriptors are closed on exec (see section Executing a File).
This section describes how to read directory entries from a directory stream, and how to close the stream when you are done with it. All the symbols are declared in the header file `dirent.h'.
Portability Note: On some systems, readdir may not
return entries for `.' and `..', even though these are always
valid file names in any directory. See section File Name Resolution.
If there are no more entries in the directory or an error is detected,
readdir returns a null pointer. The following errno error
conditions are defined for this function:
EBADF
readdir is not thread safe. Multiple threads using
readdir on the same dirstream may overwrite the return
value. Use readdir_r when this is critical.
readdir. Like
readdir it returns the next entry from the directory. But to
prevent conflicts for simultaneously running threads the result is not
stored in some internal memory. Instead the argument entry has to
point to a place where the result is stored.
The return value is 0 in case the next entry was read
successfully. In this case a pointer to the result is returned in
*result. It is not required that *result is the same as
entry. If something goes wrong while executing readdir_r
the function returns -1. The errno variable is set like
described for readdir.
Portability Note: On some systems, readdir_r may not
return a terminated string as the file name even if no d_reclen
element is available in struct dirent and the file name as the
maximal allowed size. Modern systems all have the d_reclen field
and on old systems multi threading is not critical. In any case, there
is no such problem with the readdir function so that even on
systems without d_reclen field one could use multiple threads by
using external locking.
0 on success and -1 on failure.
The following errno error conditions are defined for this
function:
EBADF
Here's a simple program that prints the names of the files in the current working directory:
#include <stddef.h>
#include <stdio.h>
#include <sys/types.h>
#include <dirent.h>
int
main (void)
{
DIR *dp;
struct dirent *ep;
dp = opendir ("./");
if (dp != NULL)
{
while (ep = readdir (dp))
puts (ep->d_name);
(void) closedir (dp);
}
else
puts ("Couldn't open the directory.");
return 0;
}
The order in which files appear in a directory tends to be fairly random. A more useful program would sort the entries (perhaps by alphabetizing them) before printing them; see section Scanning the Content of a Directory and section Array Sort Function.
This section describes how to reread parts of a directory that you have already read from an open directory stream. All the symbols are declared in the header file `dirent.h'.
rewinddir function is used to reinitialize the directory
stream dirstream, so that if you call readdir it
returns information about the first entry in the directory again. This
function also notices if files have been added or removed to the
directory since it was opened with opendir. (Entries for these
files might or might not be returned by readdir if they were
added or removed since you last called opendir or
rewinddir.)
telldir function returns the file position of the directory
stream dirstream. You can use this value with seekdir to
restore the directory stream to that position.
seekdir function sets the file position of the directory
stream dirstream to pos. The value pos must be the
result of a previous call to telldir on this particular stream;
closing and reopening the directory can invalidate values returned by
telldir.
A higher-level interface to the directory handling functions is the
scandir function. With its help one can select a subset of the
entries in a directory, possibly sort them and get as the result a list
of names.
The scandir function scans the contents of the directory selected
by dir. The result in namelist is an array of pointers to
structure of type struct dirent which describe all selected
directory entries and which is allocated using malloc. Instead
of always getting all directory entries returned, the user supplied
function selector can be used to decide which entries are in the
result. Only the entries for which selector returns a nonzero
value are selected.
Finally the entries in the namelist are sorted using the user
supplied function cmp. The arguments of the cmp function
are of type struct dirent **. I.e., one cannot directly use the
strcmp or strcoll function; see the function
alphasort below.
The return value of the function gives the number of entries placed in
namelist. If it is -1 an error occurred and the global
variable errno contains more information on the error.
As said above the fourth argument to the scandir function must be
a pointer to a sorting function. For the convenience of the programmer
the GNU C library contains an implementation of a function which is very
helpful for this purpose.
alphasort function behaves like the strcmp function
(see section String/Array Comparison). The difference is that the arguments
are not string pointers but instead they are of type
struct dirent **.
Return value of is less than, equal to, or greater than zero depending on the order of the two entries a and b.
Here is a revised version of the directory lister found above
(see section Simple Program to List a Directory). Using the scandir function we
can avoid using the functions which directly work with the directory
contents. After the call the found entries are available for direct
used.
#include <stdio.h>
#include <dirent.h>
static int
one (struct dirent *unused)
{
return 1;
}
int
main (void)
{
struct dirent **eps;
int n;
n = scandir ("./", &eps, one, alphasort);
if (n >= 0)
{
int cnt;
for (cnt = 0; cnt < n; ++cnt)
puts (eps[cnt]->d_name);
}
else
perror ("Couldn't open the directory");
return 0;
}
Please note the simple selector function for this example. Since
we want to see all directory entries we always return 1.
In POSIX systems, one file can have many names at the same time. All of the names are equally real, and no one of them is preferred to the others.
To add a name to a file, use the link function. (The new name is
also called a hard link to the file.) Creating a new link to a
file does not copy the contents of the file; it simply makes a new name
by which the file can be known, in addition to the file's existing name
or names.
One file can have names in several directories, so the the organization of the file system is not a strict hierarchy or tree.
In most implementations, it is not possible to have hard links to the
same file in multiple file systems. link reports an error if you
try to make a hard link to the file from another file system when this
cannot be done.
The prototype for the link function is declared in the header
file `unistd.h'.
link function makes a new link to the existing file named by
oldname, under the new name newname.
This function returns a value of 0 if it is successful and
-1 on failure. In addition to the usual file name errors
(see section File Name Errors) for both oldname and newname, the
following errno error conditions are defined for this function:
EACCES
EEXIST
EMLINK
LINK_MAX; see
section Limits on File System Capacity.)
ENOENT
ENOSPC
EPERM
EROFS
EXDEV
EIO
The GNU system supports soft links or symbolic links. This is a kind of "file" that is essentially a pointer to another file name. Unlike hard links, symbolic links can be made to directories or across file systems with no restrictions. You can also make a symbolic link to a name which is not the name of any file. (Opening this link will fail until a file by that name is created.) Likewise, if the symbolic link points to an existing file which is later deleted, the symbolic link continues to point to the same file name even though the name no longer names any file.
The reason symbolic links work the way they do is that special things
happen when you try to open the link. The open function realizes
you have specified the name of a link, reads the file name contained in
the link, and opens that file name instead. The stat function
likewise operates on the file that the symbolic link points to, instead
of on the link itself.
By contrast, other operations such as deleting or renaming the file
operate on the link itself. The functions readlink and
lstat also refrain from following symbolic links, because their
purpose is to obtain information about the link. So does link,
the function that makes a hard link--it makes a hard link to the
symbolic link, which one rarely wants.
Prototypes for the functions listed in this section are in `unistd.h'.
symlink function makes a symbolic link to oldname named
newname.
The normal return value from symlink is 0. A return value
of -1 indicates an error. In addition to the usual file name
syntax errors (see section File Name Errors), the following errno
error conditions are defined for this function:
EEXIST
EROFS
ENOSPC
EIO
readlink function gets the value of the symbolic link
filename. The file name that the link points to is copied into
buffer. This file name string is not null-terminated;
readlink normally returns the number of characters copied. The
size argument specifies the maximum number of characters to copy,
usually the allocation size of buffer.
If the return value equals size, you cannot tell whether or not
there was room to return the entire name. So make a bigger buffer and
call readlink again. Here is an example:
char *
readlink_malloc (char *filename)
{
int size = 100;
while (1)
{
char *buffer = (char *) xmalloc (size);
int nchars = readlink (filename, buffer, size);
if (nchars < size)
return buffer;
free (buffer);
size *= 2;
}
}
A value of -1 is returned in case of error. In addition to the
usual file name errors (see section File Name Errors), the following
errno error conditions are defined for this function:
EINVAL
EIO
You can delete a file with the functions unlink or remove.
Deletion actually deletes a file name. If this is the file's only name, then the file is deleted as well. If the file has other names as well (see section Hard Links), it remains accessible under its other names.
unlink function deletes the file name filename. If
this is a file's sole name, the file itself is also deleted. (Actually,
if any process has the file open when this happens, deletion is
postponed until all processes have closed the file.)
The function unlink is declared in the header file `unistd.h'.
This function returns 0 on successful completion, and -1
on error. In addition to the usual file name errors
(see section File Name Errors), the following errno error conditions are
defined for this function:
EACCES
EBUSY
ENOENT
EPERM
unlink cannot be used to delete the name of a
directory, or can only be used this way by a privileged user.
To avoid such problems, use rmdir to delete directories.
(In the GNU system unlink can never delete the name of a directory.)
EROFS
rmdir function deletes a directory. The directory must be
empty before it can be removed; in other words, it can only contain
entries for `.' and `..'.
In most other respects, rmdir behaves like unlink. There
are two additional errno error conditions defined for
rmdir:
ENOTEMPTY
EEXIST
These two error codes are synonymous; some systems use one, and some use
the other. The GNU system always uses ENOTEMPTY.
The prototype for this function is declared in the header file `unistd.h'.
unlink for files and like rmdir for directories.
remove is declared in `stdio.h'.
The rename function is used to change a file's name.
rename function renames the file name oldname with
newname. The file formerly accessible under the name
oldname is afterward accessible as newname instead. (If the
file had any other names aside from oldname, it continues to have
those names.)
The directory containing the name newname must be on the same file system as the file (as indicated by the name oldname).
One special case for rename is when oldname and
newname are two names for the same file. The consistent way to
handle this case is to delete oldname. However, POSIX requires
that in this case rename do nothing and report success--which is
inconsistent. We don't know what your operating system will do.
If the oldname is not a directory, then any existing file named
newname is removed during the renaming operation. However, if
newname is the name of a directory, rename fails in this
case.
If the oldname is a directory, then either newname must not
exist or it must name a directory that is empty. In the latter case,
the existing directory named newname is deleted first. The name
newname must not specify a subdirectory of the directory
oldname which is being renamed.
One useful feature of rename is that the meaning of the name
newname changes "atomically" from any previously existing file
by that name to its new meaning (the file that was called
oldname). There is no instant at which newname is
nonexistent "in between" the old meaning and the new meaning. If
there is a system crash during the operation, it is possible for both
names to still exist; but newname will always be intact if it
exists at all.
If rename fails, it returns -1. In addition to the usual
file name errors (see section File Name Errors), the following
errno error conditions are defined for this function:
EACCES
EBUSY
ENOTEMPTY
EEXIST
ENOTEMPTY for this, but some other systems return EEXIST.
EINVAL
EISDIR
EMLINK
ENOENT
ENOSPC
EROFS
EXDEV
Directories are created with the mkdir function. (There is also
a shell command mkdir which does the same thing.)
mkdir function creates a new, empty directory whose name is
filename.
The argument mode specifies the file permissions for the new directory file. See section The Mode Bits for Access Permission, for more information about this.
A return value of 0 indicates successful completion, and
-1 indicates failure. In addition to the usual file name syntax
errors (see section File Name Errors), the following errno error
conditions are defined for this function:
EACCES
EEXIST
EMLINK
ENOSPC
EROFS
To use this function, your program should include the header file `sys/stat.h'.
When you issue an `ls -l' shell command on a file, it gives you information about the size of the file, who owns it, when it was last modified, and the like. This kind of information is called the file attributes; it is associated with the file itself and not a particular one of its names.
This section contains information about how you can inquire about and modify these attributes of files.
When you read the attributes of a file, they come back in a structure
called struct stat. This section describes the names of the
attributes, their data types, and what they mean. For the functions
to read the attributes of a file, see section Reading the Attributes of a File.
The header file `sys/stat.h' declares all the symbols defined in this section.
stat structure type is used to return information about the
attributes of a file. It contains at least the following members:
mode_t st_mode
ino_t st_ino
dev_t st_dev
st_ino and
st_dev, taken together, uniquely identify the file. The
st_dev value is not necessarily consistent across reboots or
system crashes, however.
nlink_t st_nlink
uid_t st_uid
gid_t st_gid
off_t st_size
time_t st_atime
unsigned long int st_atime_usec
time_t st_mtime
unsigned long int st_mtime_usec
time_t st_ctime
unsigned long int st_ctime_usec
unsigned int st_blocks
st_size, like this:
(st.st_blocks * 512 < st.st_size)This test is not perfect because a file that is just slightly sparse might not be detected as sparse at all. For practical applications, this is not a problem.
unsigned int st_blksize
st_blocks.)
Some of the file attributes have special data type names which exist specifically for those attributes. (They are all aliases for well-known integer types that you know and love.) These typedef names are defined in the header file `sys/types.h' as well as in `sys/stat.h'. Here is a list of them.
unsigned int.
unsigned long int.
int.
unsigned short int.
To examine the attributes of files, use the functions stat,
fstat and lstat. They return the attribute information in
a struct stat object. All three functions are declared in the
header file `sys/stat.h'.
stat function returns information about the attributes of the
file named by filename in the structure pointed at by buf.
If filename is the name of a symbolic link, the attributes you get
describe the file that the link points to. If the link points to a
nonexistent file name, then stat fails, reporting a nonexistent
file.
The return value is 0 if the operation is successful, and -1
on failure. In addition to the usual file name errors
(see section File Name Errors, the following errno error conditions
are defined for this function:
ENOENT
fstat function is like stat, except that it takes an
open file descriptor as an argument instead of a file name.
See section Low-Level Input/Output.
Like stat, fstat returns 0 on success and -1
on failure. The following errno error conditions are defined for
fstat:
EBADF
lstat function is like stat, except that it does not
follow symbolic links. If filename is the name of a symbolic
link, lstat returns information about the link itself; otherwise,
lstat works like stat. See section Symbolic Links.
The file mode, stored in the st_mode field of the file
attributes, contains two kinds of information: the file type code, and
the access permission bits. This section discusses only the type code,
which you can use to tell whether the file is a directory, whether it is
a socket, and so on. For information about the access permission,
section The Mode Bits for Access Permission.
There are two predefined ways you can access the file type portion of the file mode. First of all, for each type of file, there is a predicate macro which examines a file mode value and returns true or false--is the file of that type, or not. Secondly, you can mask out the rest of the file mode to get just a file type code. You can compare this against various constants for the supported file types.
All of the symbols listed in this section are defined in the header file `sys/stat.h'.
The following predicate macros test the type of a file, given the value
m which is the st_mode field returned by stat on
that file:
An alterate non-POSIX method of testing the file type is supported for
compatibility with BSD. The mode can be bitwise ANDed with
S_IFMT to extract the file type code, and compared to the
appropriate type code constant. For example,
S_ISCHR (mode)
is equivalent to:
((mode & S_IFMT) == S_IFCHR)
These are the symbolic names for the different file type codes:
S_IFDIR
S_IFCHR
S_IFBLK
S_IFREG
S_IFLNK
S_IFSOCK
S_IFIFO
Every file has an owner which is one of the registered user names defined on the system. Each file also has a group, which is one of the defined groups. The file owner can often be useful for showing you who edited the file (especially when you edit with GNU Emacs), but its main purpose is for access control.
The file owner and group play a role in determining access because the file has one set of access permission bits for the user that is the owner, another set that apply to users who belong to the file's group, and a third set of bits that apply to everyone else. See section How Your Access to a File is Decided, for the details of how access is decided based on this data.
When a file is created, its owner is set from the effective user ID of the process that creates it (see section The Persona of a Process). The file's group ID may be set from either effective group ID of the process, or the group ID of the directory that contains the file, depending on the system where the file is stored. When you access a remote file system, it behaves according to its own rule, not according to the system your program is running on. Thus, your program must be prepared to encounter either kind of behavior, no matter what kind of system you run it on.
You can change the owner and/or group owner of an existing file using
the chown function. This is the primitive for the chown
and chgrp shell commands.
The prototype for this function is declared in `unistd.h'.
chown function changes the owner of the file filename to
owner, and its group owner to group.
Changing the owner of the file on certain systems clears the set-user-ID and set-group-ID bits of the file's permissions. (This is because those bits may not be appropriate for the new owner.) The other file permission bits are not changed.
The return value is 0 on success and -1 on failure.
In addition to the usual file name errors (see section File Name Errors),
the following errno error conditions are defined for this function:
EPERM
_POSIX_CHOWN_RESTRICTED macro.
EROFS
chown, except that it changes the owner of the file
with open file descriptor filedes.
The return value from fchown is 0 on success and -1
on failure. The following errno error codes are defined for this
function:
EBADF
EINVAL
EPERM
chmod, above.
EROFS
The file mode, stored in the st_mode field of the file
attributes, contains two kinds of information: the file type code, and
the access permission bits. This section discusses only the access
permission bits, which control who can read or write the file.
See section Testing the Type of a File, for information about the file type code.
All of the symbols listed in this section are defined in the header file `sys/stat.h'.
These symbolic constants are defined for the file mode bits that control access permission for the file:
S_IRUSR
S_IREAD
S_IREAD is an obsolete synonym provided for BSD
compatibility.
S_IWUSR
S_IWRITE
S_IWRITE is an obsolete synonym provided for BSD compatibility.
S_IXUSR
S_IEXEC
S_IEXEC is an obsolete
synonym provided for BSD compatibility.
S_IRWXU
S_IRGRP
S_IWGRP
S_IXGRP
S_IRWXG
S_IROTH
S_IWOTH
S_IXOTH
S_IRWXO
S_ISUID
S_ISGID
S_ISVTX
chmod fails with EFTYPE;
see section Assigning File Permissions.
Some systems (particularly SunOS) have yet another use for the sticky
bit. If the sticky bit is set on a file that is not executable,
it means the opposite: never cache the pages of this file at all. The
main use of this is for the files on an NFS server machine which are
used as the swap area of diskless client machines. The idea is that the
pages of the file will be cached in the client's memory, so it is a
waste of the server's memory to cache them a second time. In this use
the sticky bit also says that the filesystem may fail to record the
file's modification time onto disk reliably (the idea being that noone
cares for a swap file).
The actual bit values of the symbols are listed in the table above so you can decode file mode values when debugging your programs. These bit values are correct for most systems, but they are not guaranteed.
Warning: Writing explicit numbers for file permissions is bad practice. It is not only nonportable, it also requires everyone who reads your program to remember what the bits mean. To make your program clean, use the symbolic names.
Recall that the operating system normally decides access permission for a file based on the effective user and group IDs of the process, and its supplementary group IDs, together with the file's owner, group and permission bits. These concepts are discussed in detail in section The Persona of a Process.
If the effective user ID of the process matches the owner user ID of the file, then permissions for read, write, and execute/search are controlled by the corresponding "user" (or "owner") bits. Likewise, if any of the effective group ID or supplementary group IDs of the process matches the group owner ID of the file, then permissions are controlled by the "group" bits. Otherwise, permissions are controlled by the "other" bits.
Privileged users, like `root', can access any file, regardless of its file permission bits. As a special case, for a file to be executable even for a privileged user, at least one of its execute bits must be set.
The primitive functions for creating files (for example, open or
mkdir) take a mode argument, which specifies the file
permissions for the newly created file. But the specified mode is
modified by the process's file creation mask, or umask,
before it is used.
The bits that are set in the file creation mask identify permissions that are always to be disabled for newly created files. For example, if you set all the "other" access bits in the mask, then newly created files are not accessible at all to processes in the "other" category, even if the mode argument specified to the creation function would permit such access. In other words, the file creation mask is the complement of the ordinary access permissions you want to grant.
Programs that create files typically specify a mode argument that includes all the permissions that make sense for the particular file. For an ordinary file, this is typically read and write permission for all classes of users. These permissions are then restricted as specified by the individual user's own file creation mask.
To change the permission of an existing file given its name, call
chmod. This function ignores the file creation mask; it uses
exactly the specified permission bits.
In normal use, the file creation mask is initialized in the user's login
shell (using the umask shell command), and inherited by all
subprocesses. Application programs normally don't need to worry about
the file creation mask. It will do automatically what it is supposed to
do.
When your program should create a file and bypass the umask for its
access permissions, the easiest way to do this is to use fchmod
after opening the file, rather than changing the umask.
In fact, changing the umask is usually done only by shells. They use
the umask function.
The functions in this section are declared in `sys/stat.h'.
umask function sets the file creation mask of the current
process to mask, and returns the previous value of the file
creation mask.
Here is an example showing how to read the mask with umask
without changing it permanently:
mode_t
read_umask (void)
{
mask = umask (0);
umask (mask);
}
However, it is better to use getumask if you just want to read
the mask value, because that is reentrant (at least if you use the GNU
operating system).
chmod function sets the access permission bits for the file
named by filename to mode.
If the filename names a symbolic link, chmod changes the
permission of the file pointed to by the link, not those of the link
itself.
This function returns 0 if successful and -1 if not. In
addition to the usual file name errors (see section File Name Errors), the following errno error conditions are defined for
this function:
ENOENT
EPERM
EROFS
EFTYPE
S_ISVTX bit (the "sticky bit") set,
and the named file is not a directory. Some systems do not allow setting the
sticky bit on non-directory files, and some do (and only some of those
assign a useful meaning to the bit for non-directory files).
You only get EFTYPE on systems where the sticky bit has no useful
meaning for non-directory files, so it is always safe to just clear the
bit in mode and call chmod again. See section The Mode Bits for Access Permission,
for full details on the sticky bit.
chmod, except that it changes the permissions of
the file currently open via descriptor filedes.
The return value from fchmod is 0 on success and -1
on failure. The following errno error codes are defined for this
function:
EBADF
EINVAL
EPERM
EROFS
When a program runs as a privileged user, this permits it to access
files off-limits to ordinary users--for example, to modify
`/etc/passwd'. Programs designed to be run by ordinary users but
access such files use the setuid bit feature so that they always run
with root as the effective user ID.
Such a program may also access files specified by the user, files which
conceptually are being accessed explicitly by the user. Since the
program runs as root, it has permission to access whatever file
the user specifies--but usually the desired behavior is to permit only
those files which the user could ordinarily access.
The program therefore must explicitly check whether the user would have the necessary access to a file, before it reads or writes the file.
To do this, use the function access, which checks for access
permission based on the process's real user ID rather than the
effective user ID. (The setuid feature does not alter the real user ID,
so it reflects the user who actually ran the program.)
There is another way you could check this access, which is easy to
describe, but very hard to use. This is to examine the file mode bits
and mimic the system's own access computation. This method is
undesirable because many systems have additional access control
features; your program cannot portably mimic them, and you would not
want to try to keep track of the diverse features that different systems
have. Using access is simple and automatically does whatever is
appropriate for the system you are using.
access is only only appropriate to use in setuid programs.
A non-setuid program will always use the effective ID rather than the
real ID.
The symbols in this section are declared in `unistd.h'.
access function checks to see whether the file named by
filename can be accessed in the way specified by the how
argument. The how argument either can be the bitwise OR of the
flags R_OK, W_OK, X_OK, or the existence test
F_OK.
This function uses the real user and group ID's of the calling
process, rather than the effective ID's, to check for access
permission. As a result, if you use the function from a setuid
or setgid program (see section How an Application Can Change Persona), it gives
information relative to the user who actually ran the program.
The return value is 0 if the access is permitted, and -1
otherwise. (In other words, treated as a predicate function,
access returns true if the requested access is denied.)
In addition to the usual file name errors (see section File Name Errors), the following errno error conditions are defined for
this function:
EACCES
ENOENT
EROFS
These macros are defined in the header file `unistd.h' for use
as the how argument to the access function. The values
are integer constants.
Each file has three timestamps associated with it: its access time,
its modification time, and its attribute modification time. These
correspond to the st_atime, st_mtime, and st_ctime
members of the stat structure; see section File Attributes.
All of these times are represented in calendar time format, as
time_t objects. This data type is defined in `time.h'.
For more information about representation and manipulation of time
values, see section Calendar Time.
Reading from a file updates its access time attribute, and writing updates its modification time. When a file is created, all three timestamps for that file are set to the current time. In addition, the attribute change time and modification time fields of the directory that contains the new entry are updated.
Adding a new name for a file with the link function updates the
attribute change time field of the file being linked, and both the
attribute change time and modification time fields of the directory
containing the new name. These same fields are affected if a file name
is deleted with unlink, remove, or rmdir. Renaming
a file with rename affects only the attribute change time and
modification time fields of the two parent directories involved, and not
the times for the file being renamed.
Changing attributes of a file (for example, with chmod) updates
its attribute change time field.
You can also change some of the timestamps of a file explicitly using
the utime function--all except the attribute change time. You
need to include the header file `utime.h' to use this facility.
utimbuf structure is used with the utime function to
specify new access and modification times for a file. It contains the
following members:
time_t actime
time_t modtime
If times is a null pointer, then the access and modification times
of the file are set to the current time. Otherwise, they are set to the
values from the actime and modtime members (respectively)
of the utimbuf structure pointed at by times.
The attribute modification time for the file is set to the current time in either case (since changing the timestamps is itself a modification of the file attributes).
The utime function returns 0 if successful and -1
on failure. In addition to the usual file name errors
(see section File Name Errors), the following errno error conditions
are defined for this function:
EACCES
ENOENT
EPERM
EROFS
Each of the three time stamps has a corresponding microsecond part,
which extends its resolution. These fields are called
st_atime_usec, st_mtime_usec, and st_ctime_usec;
each has a value between 0 and 999,999, which indicates the time in
microseconds. They correspond to the tv_usec field of a
timeval structure; see section High-Resolution Calendar.
The utimes function is like utime, but also lets you specify
the fractional part of the file times. The prototype for this function is
in the header file `sys/time.h'.
tvp[0], and the new modification time by
tvp[1]. This function comes from BSD.
The return values and error conditions are the same as for the utime
function.
The mknod function is the primitive for making special files,
such as files that correspond to devices. The GNU library includes
this function for compatibility with BSD.
The prototype for mknod is declared in `sys/stat.h'.
mknod function makes a special file with name filename.
The mode specifies the mode of the file, and may include the various
special file bits, such as S_IFCHR (for a character special file)
or S_IFBLK (for a block special file). See section Testing the Type of a File.
The dev argument specifies which device the special file refers to. Its exact interpretation depends on the kind of special file being created.
The return value is 0 on success and -1 on error. In addition
to the usual file name errors (see section File Name Errors), the
following errno error conditions are defined for this function:
EPERM
ENOSPC
EROFS
EEXIST
If you need to use a temporary file in your program, you can use the
tmpfile function to open it. Or you can use the tmpnam
(better: tmpnam_r) function make a name for a temporary file and
then open it in the usual way with fopen.
The tempnam function is like tmpnam but lets you choose
what directory temporary files will go in, and something about what
their file names will look like. Important for multi threaded programs
is that tempnam is reentrant while tmpnam is not since it
returns a pointer to a static buffer.
These facilities are declared in the header file `stdio.h'.
fopen with mode "wb+". The file is deleted
automatically when it is closed or when the program terminates. (On
some other ISO C systems the file may fail to be deleted if the program
terminates abnormally).
This function is reentrant.
L_tmpnam characters,
and the result is written into that array.
It is possible for tmpnam to fail if you call it too many times
without removing previously created files. This is because the fixed
length of a temporary file name gives room for only a finite number of
different names. If tmpnam fails, it returns a null pointer.
tmpnam function. But it
does not allow result to be a null pointer. In the later case a
null pointer is returned.
This function is reentrant because the non-reentrant situation of
tmpnam cannot happen here.
tmpnam function.
TMP_MAX is a lower bound for how many temporary names
you can create with tmpnam. You can rely on being able to call
tmpnam at least this many times before it might fail saying you
have made too many temporary file names.
With the GNU library, you can create a very large number of temporary
file names--if you actually create the files, you will probably run out
of disk space before you run out of names. Some other systems have a
fixed, small limit on the number of temporary files. The limit is never
less than 25.
malloc; you should release its storage with free when
it is no longer needed.
Because the string is dynamically allocated this function is reentrant.
The directory prefix for the temporary file name is determined by testing each of the following, in sequence. The directory must exist and be writable.
TMPDIR, if it is defined. For security
reasons this only happens if the program is not SUID or SGID enabled.
P_tmpdir macro.
This function is defined for SVID compatibility.
Older Unix systems did not have the functions just described. Instead
they used mktemp and mkstemp. Both of these functions
work by modifying a file name template string you pass. The last six
characters of this string must be `XXXXXX'. These six `X's
are replaced with six characters which make the whole string a unique
file name. Usually the template string is something like
`/tmp/prefixXXXXXX', and each program uses a unique prefix.
Note: Because mktemp and mkstemp modify the
template string, you must not pass string constants to them.
String constants are normally in read-only storage, so your program
would crash when mktemp or mkstemp tried to modify the
string.
mktemp function generates a unique file name by modifying
template as described above. If successful, it returns
template as modified. If mktemp cannot find a unique file
name, it makes template an empty string and returns that. If
template does not end with `XXXXXX', mktemp returns a
null pointer.
mkstemp function generates a unique file name just as
mktemp does, but it also opens the file for you with open
(see section Opening and Closing Files). If successful, it modifies
template in place and returns a file descriptor open on that file
for reading and writing. If mkstemp cannot create a
uniquely-named file, it makes template an empty string and returns
-1. If template does not end with `XXXXXX',
mkstemp returns -1 and does not modify template.
Unlike mktemp, mkstemp is actually guaranteed to create a
unique file that cannot possibly clash with any other program trying to
create a temporary file. This is because it works by calling
open with the O_EXCL flag bit, which says you want to
always create a new file, and get an error if the file already exists.
A pipe is a mechanism for interprocess communication; data written to the pipe by one process can be read by another process. The data is handled in a first-in, first-out (FIFO) order. The pipe has no name; it is created for one use and both ends must be inherited from the single process which created the pipe.
A FIFO special file is similar to a pipe, but instead of being an anonymous, temporary connection, a FIFO has a name or names like any other file. Processes open the FIFO by name in order to communicate through it.
A pipe or FIFO has to be open at both ends simultaneously. If you read
from a pipe or FIFO file that doesn't have any processes writing to it
(perhaps because they have all closed the file, or exited), the read
returns end-of-file. Writing to a pipe or FIFO that doesn't have a
reading process is treated as an error condition; it generates a
SIGPIPE signal, and fails with error code EPIPE if the
signal is handled or blocked.
Neither pipes nor FIFO special files allow file positioning. Both reading and writing operations happen sequentially; reading from the beginning of the file and writing at the end.
The primitive for creating a pipe is the pipe function. This
creates both the reading and writing ends of the pipe. It is not very
useful for a single process to use a pipe to talk to itself. In typical
use, a process creates a pipe just before it forks one or more child
processes (see section Creating a Process). The pipe is then used for
communication either between the parent or child processes, or between
two sibling processes.
The pipe function is declared in the header file
`unistd.h'.
pipe function creates a pipe and puts the file descriptors
for the reading and writing ends of the pipe (respectively) into
filedes[0] and filedes[1].
An easy way to remember that the input end comes first is that file
descriptor 0 is standard input, and file descriptor 1 is
standard output.
If successful, pipe returns a value of 0. On failure,
-1 is returned. The following errno error conditions are
defined for this function:
EMFILE
ENFILE
ENFILE. This error never occurs in
the GNU system.
Here is an example of a simple program that creates a pipe. This program
uses the fork function (see section Creating a Process) to create
a child process. The parent process writes data to the pipe, which is
read by the child process.
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
/* Read characters from the pipe and echo them to stdout. */
void
read_from_pipe (int file)
{
FILE *stream;
int c;
stream = fdopen (file, "r");
while ((c = fgetc (stream)) != EOF)
putchar (c);
fclose (stream);
}
/* Write some random text to the pipe. */
void
write_to_pipe (int file)
{
FILE *stream;
stream = fdopen (file, "w");
fprintf (stream, "hello, world!\n");
fprintf (stream, "goodbye, world!\n");
fclose (stream);
}
int
main (void)
{
pid_t pid;
int mypipe[2];
/* Create the pipe. */
if (pipe (mypipe))
{
fprintf (stderr, "Pipe failed.\n");
return EXIT_FAILURE;
}
/* Create the child process. */
pid = fork ();
if (pid == (pid_t) 0)
{
/* This is the child process. */
read_from_pipe (mypipe[0]);
return EXIT_SUCCESS;
}
else if (pid < (pid_t) 0)
{
/* The fork failed. */
fprintf (stderr, "Fork failed.\n");
return EXIT_FAILURE;
}
else
{
/* This is the parent process. */
write_to_pipe (mypipe[1]);
return EXIT_SUCCESS;
}
}
A common use of pipes is to send data to or receive data from a program
being run as subprocess. One way of doing this is by using a combination of
pipe (to create the pipe), fork (to create the subprocess),
dup2 (to force the subprocess to use the pipe as its standard input
or output channel), and exec (to execute the new program). Or,
you can use popen and pclose.
The advantage of using popen and pclose is that the
interface is much simpler and easier to use. But it doesn't offer as
much flexibility as using the low-level functions directly.
popen function is closely related to the system
function; see section Running a Command. It executes the shell command
command as a subprocess. However, instead of waiting for the
command to complete, it creates a pipe to the subprocess and returns a
stream that corresponds to that pipe.
If you specify a mode argument of "r", you can read from the
stream to retrieve data from the standard output channel of the subprocess.
The subprocess inherits its standard input channel from the parent process.
Similarly, if you specify a mode argument of "w", you can
write to the stream to send data to the standard input channel of the
subprocess. The subprocess inherits its standard output channel from
the parent process.
In the event of an error, popen returns a null pointer. This
might happen if the pipe or stream cannot be created, if the subprocess
cannot be forked, or if the program cannot be executed.
pclose function is used to close a stream created by popen.
It waits for the child process to terminate and returns its status value,
as for the system function.
Here is an example showing how to use popen and pclose to
filter output through another program, in this case the paging program
more.
#include <stdio.h>
#include <stdlib.h>
void
write_data (FILE * stream)
{
int i;
for (i = 0; i < 100; i++)
fprintf (stream, "%d\n", i);
if (ferror (stream))
{
fprintf (stderr, "Output to stream failed.\n");
exit (EXIT_FAILURE);
}
}
int
main (void)
{
FILE *output;
output = popen ("more", "w");
if (!output)
{
fprintf (stderr, "Could not run more.\n");
return EXIT_FAILURE;
}
write_data (output);
pclose (output);
return EXIT_SUCCESS;
}
A FIFO special file is similar to a pipe, except that it is created in a
different way. Instead of being an anonymous communications channel, a
FIFO special file is entered into the file system by calling
mkfifo.
Once you have created a FIFO special file in this way, any process can open it for reading or writing, in the same way as an ordinary file. However, it has to be open at both ends simultaneously before you can proceed to do any input or output operations on it. Opening a FIFO for reading normally blocks until some other process opens the same FIFO for writing, and vice versa.
The mkfifo function is declared in the header file
`sys/stat.h'.
mkfifo function makes a FIFO special file with name
filename. The mode argument is used to set the file's
permissions; see section Assigning File Permissions.
The normal, successful return value from mkfifo is 0. In
the case of an error, -1 is returned. In addition to the usual
file name errors (see section File Name Errors), the following
errno error conditions are defined for this function:
EEXIST
ENOSPC
EROFS
Reading or writing pipe data is atomic if the size of data written
is not greater than PIPE_BUF. This means that the data transfer
seems to be an instantaneous unit, in that nothing else in the system
can observe a state in which it is partially complete. Atomic I/O may
not begin right away (it may need to wait for buffer space or for data),
but once it does begin, it finishes immediately.
Reading or writing a larger amount of data may not be atomic; for
example, output data from other processes sharing the descriptor may be
interspersed. Also, once PIPE_BUF characters have been written,
further writes will block until some characters are read.
See section Limits on File System Capacity, for information about the PIPE_BUF
parameter.
This chapter describes the GNU facilities for interprocess communication using sockets.
A socket is a generalized interprocess communication channel.
Like a pipe, a socket is represented as a file descriptor. But,
unlike pipes, sockets support communication between unrelated
processes, and even between processes running on different machines
that communicate over a network. Sockets are the primary means of
communicating with other machines; telnet, rlogin,
ftp, talk, and the other familiar network programs use
sockets.
Not all operating systems support sockets. In the GNU library, the header file `sys/socket.h' exists regardless of the operating system, and the socket functions always exist, but if the system does not really support sockets, these functions always fail.
Incomplete: We do not currently document the facilities for broadcast messages or for configuring Internet interfaces.
When you create a socket, you must specify the style of communication you want to use and the type of protocol that should implement it. The communication style of a socket defines the user-level semantics of sending and receiving data on the socket. Choosing a communication style specifies the answers to questions such as these:
You must also choose a namespace for naming the socket. A socket name ("address") is meaningful only in the context of a particular namespace. In fact, even the data type to use for a socket name may depend on the namespace. Namespaces are also called "domains", but we avoid that word as it can be confused with other usage of the same term. Each namespace has a symbolic name that starts with `PF_'. A corresponding symbolic name starting with `AF_' designates the address format for that namespace.
Finally you must choose the protocol to carry out the communication. The protocol determines what low-level mechanism is used to transmit and receive data. Each protocol is valid for a particular namespace and communication style; a namespace is sometimes called a protocol family because of this, which is why the namespace names start with `PF_'.
The rules of a protocol apply to the data passing between two programs, perhaps on different computers; most of these rules are handled by the operating system, and you need not know about them. What you do need to know about protocols is this:
Throughout the following description at various places
variables/parameters to denote sizes are required. And here the trouble
starts. In the first implementations the type of these variables was
simply int. This type was on almost all machines of this time 32
bits wide and so a de-factor standard required 32 bit variables. This
is important since references to variables of this type are passed to
the kernel.
But now the POSIX people came and unified the interface with their words
"all size values are of type size_t". But on 64 bit machines
size_t is 64 bits wide and so variable references are not anymore
possible.
A solution provides the Unix98 specification which finally introduces a
type socklen_t. This type is used in all of the cases in
previously changed to use size_t. The only requirement of this
type is that it is an unsigned type of at least 32 bits. Therefore,
implementations which require references to 32 bit variables be passed
can be as happy as implementations which right from the start of 64 bit
values.
The GNU library includes support for several different kinds of sockets, each with different characteristics. This section describes the supported socket types. The symbolic constants listed here are defined in `sys/socket.h'.
SOCK_STREAM style is like a pipe (see section Pipes and FIFOs);
it operates over a connection with a particular remote socket, and
transmits data reliably as a stream of bytes.
Use of this style is covered in detail in section Using Sockets with Connections.
SOCK_DGRAM style is used for sending
individually-addressed packets, unreliably.
It is the diametrical opposite of SOCK_STREAM.
Each time you write data to a socket of this kind, that data becomes
one packet. Since SOCK_DGRAM sockets do not have connections,
you must specify the recipient address with each packet.
The only guarantee that the system makes about your requests to transmit data is that it will try its best to deliver each packet you send. It may succeed with the sixth packet after failing with the fourth and fifth packets; the seventh packet may arrive before the sixth, and may arrive a second time after the sixth.
The typical use for SOCK_DGRAM is in situations where it is
acceptable to simply resend a packet if no response is seen in a
reasonable amount of time.
See section Datagram Socket Operations, for detailed information about how to use datagram sockets.
The name of a socket is normally called an address. The functions and symbols for dealing with socket addresses were named inconsistently, sometimes using the term "name" and sometimes using "address". You can regard these terms as synonymous where sockets are concerned.
A socket newly created with the socket function has no
address. Other processes can find it for communication only if you
give it an address. We call this binding the address to the
socket, and the way to do it is with the bind function.
You need be concerned with the address of a socket if other processes are to find it and start communicating with it. You can specify an address for other sockets, but this is usually pointless; the first time you send data from a socket, or use it to initiate a connection, the system assigns an address automatically if you have not specified one.
Occasionally a client needs to specify an address because the server
discriminates based on addresses; for example, the rsh and rlogin
protocols look at the client's socket address and don't bypass password
checking unless it is less than IPPORT_RESERVED (see section Internet Ports).
The details of socket addresses vary depending on what namespace you are using. See section The File Namespace, or section The Internet Namespace, for specific information.
Regardless of the namespace, you use the same functions bind and
getsockname to set and examine a socket's address. These
functions use a phony data type, struct sockaddr *, to accept the
address. In practice, the address lives in a structure of some other
data type appropriate to the address format you are using, but you cast
its address to struct sockaddr * when you pass it to
bind.
The functions bind and getsockname use the generic data
type struct sockaddr * to represent a pointer to a socket
address. You can't use this data type effectively to interpret an
address or construct one; for that, you must use the proper data type
for the socket's namespace.
Thus, the usual practice is to construct an address in the proper
namespace-specific type, then cast a pointer to struct sockaddr *
when you call bind or getsockname.
The one piece of information that you can get from the struct
sockaddr data type is the address format designator which tells
you which data type to use to understand the address fully.
The symbols in this section are defined in the header file `sys/socket.h'.
struct sockaddr type itself has the following members:
short int sa_family
char sa_data[14]
sa_data is essentially arbitrary.
Each address format has a symbolic name which starts with `AF_'. Each of them corresponds to a `PF_' symbol which designates the corresponding namespace. Here is a list of address format names:
AF_FILE
PF_FILE is the name of that namespace.) See section Details of File Namespace, for information about this address format.
AF_UNIX
AF_FILE, for compatibility.
(PF_UNIX is likewise a synonym for PF_FILE.)
AF_INET
PF_INET is the name of that namespace.)
See section Internet Socket Address Formats.
AF_INET6
AF_INET, but refers to the IPv6 protocol.
(PF_INET6 is the name of the corresponding namespace.)
AF_UNSPEC
PF_UNSPEC exists
for completeness, but there is no reason to use it in a program.
`sys/socket.h' defines symbols starting with `AF_' for many different kinds of networks, all or most of which are not actually implemented. We will document those that really work, as we receive information about how to use them.
Use the bind function to assign an address to a socket. The
prototype for bind is in the header file `sys/socket.h'.
For examples of use, see section The File Namespace, or see section Internet Socket Example.
bind function assigns an address to the socket
socket. The addr and length arguments specify the
address; the detailed format of the address depends on the namespace.
The first part of the address is always the format designator, which
specifies a namespace, and says that the address is in the format for
that namespace.
The return value is 0 on success and -1 on failure. The
following errno error conditions are defined for this function:
EBADF
ENOTSOCK
EADDRNOTAVAIL
EADDRINUSE
EINVAL
EACCES
IPPORT_RESERVED minus one; see
section Internet Ports.)
Additional conditions may be possible depending on the particular namespace of the socket.
Use the function getsockname to examine the address of an
Internet socket. The prototype for this function is in the header file
`sys/socket.h'.
getsockname function returns information about the
address of the socket socket in the locations specified by the
addr and length-ptr arguments. Note that the
length-ptr is a pointer; you should initialize it to be the
allocation size of addr, and on return it contains the actual
size of the address data.
The format of the address data depends on the socket namespace. The
length of the information is usually fixed for a given namespace, so
normally you can know exactly how much space is needed and can provide
that much. The usual practice is to allocate a place for the value
using the proper data type for the socket's namespace, then cast its
address to struct sockaddr * to pass it to getsockname.
The return value is 0 on success and -1 on error. The
following errno error conditions are defined for this function:
EBADF
ENOTSOCK
ENOBUFS
You can't read the address of a socket in the file namespace. This is consistent with the rest of the system; in general, there's no way to find a file's name from a descriptor for that file.
This section describes the details of the file namespace, whose
symbolic name (required when you create a socket) is PF_FILE.
In the file namespace, socket addresses are file names. You can specify any file name you want as the address of the socket, but you must have write permission on the directory containing it. In order to connect to a socket, you must have read permission for it. It's common to put these files in the `/tmp' directory.
One peculiarity of the file namespace is that the name is only used when opening the connection; once that is over with, the address is not meaningful and may not exist.
Another peculiarity is that you cannot connect to such a socket from another machine--not even if the other machine shares the file system which contains the name of the socket. You can see the socket in a directory listing, but connecting to it never succeeds. Some programs take advantage of this, such as by asking the client to send its own process ID, and using the process IDs to distinguish between clients. However, we recommend you not use this method in protocols you design, as we might someday permit connections from other machines that mount the same file systems. Instead, send each new client an identifying number if you want it to have one.
After you close a socket in the file namespace, you should delete the
file name from the file system. Use unlink or remove to
do this; see section Deleting Files.
The file namespace supports just one protocol for any communication
style; it is protocol number 0.
To create a socket in the file namespace, use the constant
PF_FILE as the namespace argument to socket or
socketpair. This constant is defined in `sys/socket.h'.
PF_FILE, for compatibility's sake.
The structure for specifying socket names in the file namespace is defined in the header file `sys/un.h':
short int sun_family
AF_FILE to designate the file
namespace. See section Socket Addresses.
char sun_path[108]
alloca to allocate an appropriate amount of storage based on
the length of the filename.
You should compute the length parameter for a socket address in
the file namespace as the sum of the size of the sun_family
component and the string length (not the allocation size!) of
the file name string.
Here is an example showing how to create and name a socket in the file namespace.
#include <stddef.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/un.h>
int
make_named_socket (const char *filename)
{
struct sockaddr_un name;
int sock;
size_t size;
/* Create the socket. */
sock = socket (PF_UNIX, SOCK_DGRAM, 0);
if (sock < 0)
{
perror ("socket");
exit (EXIT_FAILURE);
}
/* Bind a name to the socket. */
name.sun_family = AF_FILE;
strcpy (name.sun_path, filename);
/* The size of the address is
the offset of the start of the filename,
plus its length,
plus one for the terminating null byte. */
size = (offsetof (struct sockaddr_un, sun_path)
+ strlen (name.sun_path) + 1);
if (bind (sock, (struct sockaddr *) &name, size) < 0)
{
perror ("bind");
exit (EXIT_FAILURE);
}
return sock;
}
This section describes the details the protocols and socket naming conventions used in the Internet namespace.
To create a socket in the Internet namespace, use the symbolic name
PF_INET of this namespace as the namespace argument to
socket or socketpair. This macro is defined in
`sys/socket.h'.
A socket address for the Internet namespace includes the following components:
You must ensure that the address and port number are represented in a canonical format called network byte order. See section Byte Order Conversion, for information about this.
In the Internet namespace, for both IPv4 (AF_INET) and IPv6
(AF_INET6), a socket address consists of a host address
and a port on that host. In addition, the protocol you choose serves
effectively as a part of the address because local port numbers are
meaningful only within a particular protocol.
The data types for representing socket addresses in the Internet namespace are defined in the header file `netinet/in.h'.
short int sin_family
AF_INET in this member.
See section Socket Addresses.
struct in_addr sin_addr
unsigned short int sin_port
When you call bind or getsockname, you should specify
sizeof (struct sockaddr_in) as the length parameter if
you are using an Internet namespace socket address.
short int sin6_family
AF_INET6 in this member.
See section Socket Addresses.
struct in6_addr sin6_addr
uint32_t sin6_flowinfo
uint16_t sin6_port
Each computer on the Internet has one or more Internet addresses, numbers which identify that computer among all those on the Internet. Users typically write IPv4 numeric host addresses as sequences of four numbers, separated by periods, as in `128.52.46.32', and IPv6 numeric host addresses as sequences of up to eight numbers seperated by colons, as in `5f03:1200:836f:c100::1'.
Each computer also has one or more host names, which are strings of words separated by periods, as in `churchy.gnu.ai.mit.edu'.
Programs that let the user specify a host typically accept both numeric addresses and host names. But the program needs a numeric address to open a connection; to use a host name, you must convert it to the numeric address it stands for.
An Internet host address is a number containing four bytes of data. These are divided into two parts, a network number and a local network address number within that network. The network number consists of the first one, two or three bytes; the rest of the bytes are the local address.
Network numbers are registered with the Network Information Center (NIC), and are divided into three classes--A, B, and C. The local network address numbers of individual machines are registered with the administrator of the particular network.
Class A networks have single-byte numbers in the range 0 to 127. There are only a small number of Class A networks, but they can each support a very large number of hosts. Medium-sized Class B networks have two-byte network numbers, with the first byte in the range 128 to 191. Class C networks are the smallest; they have three-byte network numbers, with the first byte in the range 192-255. Thus, the first 1, 2, or 3 bytes of an Internet address specifies a network. The remaining bytes of the Internet address specify the address within that network.
The Class A network 0 is reserved for broadcast to all networks. In addition, the host number 0 within each network is reserved for broadcast to all hosts in that network.
The Class A network 127 is reserved for loopback; you can always use the Internet address `127.0.0.1' to refer to the host machine.
Since a single machine can be a member of multiple networks, it can have multiple Internet host addresses. However, there is never supposed to be more than one machine with the same host address.
There are four forms of the standard numbers-and-dots notation for Internet addresses:
a.b.c.d
a.b.c
a.b.
a.b
a
Within each part of the address, the usual C conventions for specifying the radix apply. In other words, a leading `0x' or `0X' implies hexadecimal radix; a leading `0' implies octal; and otherwise decimal radix is assumed.
Internet host addresses are represented in some contexts as integers
(type unsigned long int). In other contexts, the integer is
packaged inside a structure of type struct in_addr. It would
be better if the usage were made consistent, but it is not hard to extract
the integer from the structure or put the integer into a structure.
The following basic definitions for Internet addresses appear in the header file `netinet/in.h':
s_addr, which records the
host address number as an unsigned long int.
INADDR_LOOPBACK
specially, avoiding any network traffic for the case of one machine
talking to itself.
sin_addr member of struct
sockaddr_in when you want to accept Internet connections.
IN6ADDR_LOOPBACK_INIT is provided to allow you to initialise your
own variables to this value.
IN6ADDR_ANY_INIT is provided to allow you to initialise your
own variables to this value.
These additional functions for manipulating Internet addresses are declared in `arpa/inet.h'. They represent Internet addresses in network byte order; they represent network numbers and local-address-within-network numbers in host byte order. See section Byte Order Conversion, for an explanation of network and host byte order.
struct in_addr that addr points to.
inet_aton returns nonzero if the address is valid, zero if not.
inet_addr returns INADDR_NONE. This is an
obsolete interface to inet_aton, described immediately above; it
is obsolete because INADDR_NONE is a valid address
(255.255.255.255), and inet_aton provides a cleaner way to
indicate error return.
inet_network returns -1.
In multi-threaded programs each thread has an own statically-allocated
buffer. But still subsequent calls of inet_ntoa in the same
thread will overwrite the result of the last call.
AF_INET or AF_INET6, as appropriate for the type of
address being converted. cp is a pointer to the input string, and
buf is a pointer to a buffer for the result. It is the caller's
responsibility to make sure the buffer is large enough.
AF_INET or AF_INET6, as appropriate. cp is a
pointer to the address to be converted. buf should be a pointer
to a buffer to hold the result, and len is the length of this
buffer. The return value from the function will be this buffer address.
Besides the standard numbers-and-dots notation for Internet addresses, you can also refer to a host by a symbolic name. The advantage of a symbolic name is that it is usually easier to remember. For example, the machine with Internet address `128.52.46.32' is also known as `churchy.gnu.ai.mit.edu'; and other machines in the `gnu.ai.mit.edu' domain can refer to it simply as `churchy'.
Internally, the system uses a database to keep track of the mapping between host names and host numbers. This database is usually either the file `/etc/hosts' or an equivalent provided by a name server. The functions and other symbols for accessing this database are declared in `netdb.h'. They are BSD features, defined unconditionally if you include `netdb.h'.
char *h_name
char **h_aliases
int h_addrtype
AF_INET or AF_INET6, with the latter being used for IPv6
hosts. In principle other kinds of addresses could be represented in
the data base as well as Internet addresses; if this were done, you
might find a value in this field other than AF_INET or
AF_INET6. See section Socket Addresses.
int h_length
char **h_addr_list
char *h_addr
h_addr_list[0]; in other words, it is the
first host address.
As far as the host database is concerned, each address is just a block
of memory h_length bytes long. But in other contexts there is an
implicit assumption that you can convert this to a struct in_addr or
an unsigned long int. Host addresses in a struct hostent
structure are always given in network byte order; see section Byte Order Conversion.
You can use gethostbyname, gethostbyname2 or
gethostbyaddr to search the hosts database for information about
a particular host. The information is returned in a
statically-allocated structure; you must copy the information if you
need to save it across calls. You can also use getaddrinfo and
getnameinfo to obtain this information.
gethostbyname function returns information about the host
named name. If the lookup fails, it returns a null pointer.
gethostbyname2 function is like gethostbyname, but
allows the caller to specify the desired address family (e.g.
AF_INET or AF_INET6) for the result.
gethostbyaddr function returns information about the host
with Internet address addr. The length argument is the
size (in bytes) of the address at addr. format specifies
the address format; for an Internet address, specify a value of
AF_INET.
If the lookup fails, gethostbyaddr returns a null pointer.
If the name lookup by gethostbyname or gethostbyaddr
fails, you can find out the reason by looking at the value of the
variable h_errno. (It would be cleaner design for these
functions to set errno, but use of h_errno is compatible
with other systems.) Before using h_errno, you must declare it
like this:
extern int h_errno;
Here are the error codes that you may find in h_errno:
HOST_NOT_FOUND
TRY_AGAIN
NO_RECOVERY
NO_ADDRESS
You can also scan the entire hosts database one entry at a time using
sethostent, gethostent, and endhostent. Be careful
in using these functions, because they are not reentrant.
gethostent to read the entries.
If the stayopen argument is nonzero, this sets a flag so that
subsequent calls to gethostbyname or gethostbyaddr will
not close the database (as they usually would). This makes for more
efficiency if you call those functions several times, by avoiding
reopening the database for each call.
A socket address in the Internet namespace consists of a machine's Internet address plus a port number which distinguishes the sockets on a given machine (for a given protocol). Port numbers range from 0 to 65,535.
Port numbers less than IPPORT_RESERVED are reserved for standard
servers, such as finger and telnet. There is a database
that keeps track of these, and you can use the getservbyname
function to map a service name onto a port number; see section The Services Database.
If you write a server that is not one of the standard ones defined in
the database, you must choose a port number for it. Use a number
greater than IPPORT_USERRESERVED; such numbers are reserved for
servers and won't ever be generated automatically by the system.
Avoiding conflicts with servers being run by other users is up to you.
When you use a socket without specifying its address, the system
generates a port number for it. This number is between
IPPORT_RESERVED and IPPORT_USERRESERVED.
On the Internet, it is actually legitimate to have two different
sockets with the same port number, as long as they never both try to
communicate with the same socket address (host address plus port
number). You shouldn't duplicate a port number except in special
circumstances where a higher-level protocol requires it. Normally,
the system won't let you do it; bind normally insists on
distinct port numbers. To reuse a port number, you must set the
socket option SO_REUSEADDR. See section Socket-Level Options.
These macros are defined in the header file `netinet/in.h'.
IPPORT_RESERVED are reserved for
superuser use.
IPPORT_USERRESERVED are
reserved for explicit use; they will never be allocated automatically.
The database that keeps track of "well-known" services is usually either the file `/etc/services' or an equivalent from a name server. You can use these utilities, declared in `netdb.h', to access the services database.
char *s_name
char **s_aliases
int s_port
char *s_proto
To get information about a particular service, use the
getservbyname or getservbyport functions. The information
is returned in a statically-allocated structure; you must copy the
information if you need to save it across calls.
getservbyname function returns information about the
service named name using protocol proto. If it can't find
such a service, it returns a null pointer.
This function is useful for servers as well as for clients; servers use it to determine which port they should listen on (see section Listening for Connections).
getservbyport function returns information about the
service at port port using protocol proto. If it can't
find such a service, it returns a null pointer.
You can also scan the services database using setservent,
getservent, and endservent. Be careful in using these
functions, because they are not reentrant.
If the stayopen argument is nonzero, this sets a flag so that
subsequent calls to getservbyname or getservbyport will
not close the database (as they usually would). This makes for more
efficiency if you call those functions several times, by avoiding
reopening the database for each call.
Different kinds of computers use different conventions for the ordering of bytes within a word. Some computers put the most significant byte within a word first (this is called "big-endian" order), and others put it last ("little-endian" order).
So that machines with different byte order conventions can communicate, the Internet protocols specify a canonical byte order convention for data transmitted over the network. This is known as the network byte order.
When establishing an Internet socket connection, you must make sure that
the data in the sin_port and sin_addr members of the
sockaddr_in structure are represented in the network byte order.
If you are encoding integer data in the messages sent through the
socket, you should convert this to network byte order too. If you don't
do this, your program may fail when running on or talking to other kinds
of machines.
If you use getservbyname and gethostbyname or
inet_addr to get the port number and host address, the values are
already in the network byte order, and you can copy them directly into
the sockaddr_in structure.
Otherwise, you have to convert the values explicitly. Use
htons and ntohs to convert values for the sin_port
member. Use htonl and ntohl to convert values for the
sin_addr member. (Remember, struct in_addr is equivalent
to unsigned long int.) These functions are declared in
`netinet/in.h'.
short integer hostshort from
host byte order to network byte order.
short integer netshort from
network byte order to host byte order.
long integer hostlong from
host byte order to network byte order.
long integer netlong from
network byte order to host byte order.
The communications protocol used with a socket controls low-level details of how data is exchanged. For example, the protocol implements things like checksums to detect errors in transmissions, and routing instructions for messages. Normal user programs have little reason to mess with these details directly.
The default communications protocol for the Internet namespace depends on the communication style. For stream communication, the default is TCP ("transmission control protocol"). For datagram communication, the default is UDP ("user datagram protocol"). For reliable datagram communication, the default is RDP ("reliable datagram protocol"). You should nearly always use the default.
Internet protocols are generally specified by a name instead of a
number. The network protocols that a host knows about are stored in a
database. This is usually either derived from the file
`/etc/protocols', or it may be an equivalent provided by a name
server. You look up the protocol number associated with a named
protocol in the database using the getprotobyname function.
Here are detailed descriptions of the utilities for accessing the protocols database. These are declared in `netdb.h'.
char *p_name
char **p_aliases
int p_proto
socket.
You can use getprotobyname and getprotobynumber to search
the protocols database for a specific protocol. The information is
returned in a statically-allocated structure; you must copy the
information if you need to save it across calls.
getprotobyname function returns information about the
network protocol named name. If there is no such protocol, it
returns a null pointer.
getprotobynumber function returns information about the
network protocol with number protocol. If there is no such
protocol, it returns a null pointer.
You can also scan the whole protocols database one protocol at a time by
using setprotoent, getprotoent, and endprotoent.
Be careful in using these functions, because they are not reentrant.
If the stayopen argument is nonzero, this sets a flag so that
subsequent calls to getprotobyname or getprotobynumber will
not close the database (as they usually would). This makes for more
efficiency if you call those functions several times, by avoiding
reopening the database for each call.
Here is an example showing how to create and name a socket in the
Internet namespace. The newly created socket exists on the machine that
the program is running on. Rather than finding and using the machine's
Internet address, this example specifies INADDR_ANY as the host
address; the system replaces that with the machine's actual address.
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
int
make_socket (unsigned short int port)
{
int sock;
struct sockaddr_in name;
/* Create the socket. */
sock = socket (PF_INET, SOCK_STREAM, 0);
if (sock < 0)
{
perror ("socket");
exit (EXIT_FAILURE);
}
/* Give the socket a name. */
name.sin_family = AF_INET;
name.sin_port = htons (port);
name.sin_addr.s_addr = htonl (INADDR_ANY);
if (bind (sock, (struct sockaddr *) &name, sizeof (name)) < 0)
{
perror ("bind");
exit (EXIT_FAILURE);
}
return sock;
}
Here is another example, showing how you can fill in a sockaddr_in
structure, given a host name string and a port number:
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
void
init_sockaddr (struct sockaddr_in *name,
const char *hostname,
unsigned short int port)
{
struct hostent *hostinfo;
name->sin_family = AF_INET;
name->sin_port = htons (port);
hostinfo = gethostbyname (hostname);
if (hostinfo == NULL)
{
fprintf (stderr, "Unknown host %s.\n", hostname);
exit (EXIT_FAILURE);
}
name->sin_addr = *(struct in_addr *) hostinfo->h_addr;
}
Certain other namespaces and associated protocol families are supported
but not documented yet because they are not often used. PF_NS
refers to the Xerox Network Software protocols. PF_ISO stands
for Open Systems Interconnect. PF_CCITT refers to protocols from
CCITT. `socket.h' defines these symbols and others naming protocols
not actually implemented.
PF_IMPLINK is used for communicating between hosts and Internet
Message Processors. For information on this, and on PF_ROUTE, an
occasionally-used local area routing protocol, see the GNU Hurd Manual
(to appear in the future).
This section describes the actual library functions for opening and closing sockets. The same functions work for all namespaces and connection styles.
The primitive for creating a socket is the socket function,
declared in `sys/socket.h'.
PF_FILE (see section The File Namespace) or
PF_INET (see section The Internet Namespace). protocol
designates the specific protocol (see section Socket Concepts); zero is
usually right for protocol.
The return value from socket is the file descriptor for the new
socket, or -1 in case of error. The following errno error
conditions are defined for this function:
EPROTONOSUPPORT
EMFILE
ENFILE
EACCESS
ENOBUFS
The file descriptor returned by the socket function supports both
read and write operations. But, like pipes, sockets do not support file
positioning operations.
For examples of how to call the socket function,
see section The File Namespace, or section Internet Socket Example.
When you are finished using a socket, you can simply close its
file descriptor with close; see section Opening and Closing Files.
If there is still data waiting to be transmitted over the connection,
normally close tries to complete this transmission. You
can control this behavior using the SO_LINGER socket option to
specify a timeout period; see section Socket Options.
You can also shut down only reception or only transmission on a
connection by calling shutdown, which is declared in
`sys/socket.h'.
shutdown function shuts down the connection of socket
socket. The argument how specifies what action to
perform:
0
1
2
The return value is 0 on success and -1 on failure. The
following errno error conditions are defined for this function:
EBADF
ENOTSOCK
ENOTCONN
A socket pair consists of a pair of connected (but unnamed)
sockets. It is very similar to a pipe and is used in much the same
way. Socket pairs are created with the socketpair function,
declared in `sys/socket.h'. A socket pair is much like a pipe; the
main difference is that the socket pair is bidirectional, whereas the
pipe has one input-only end and one output-only end (see section Pipes and FIFOs).
filedes[0] and filedes[1]. The socket pair
is a full-duplex communications channel, so that both reading and writing
may be performed at either end.
The namespace, style, and protocol arguments are
interpreted as for the socket function. style should be
one of the communication styles listed in section Communication Styles.
The namespace argument specifies the namespace, which must be
AF_FILE (see section The File Namespace); protocol specifies the
communications protocol, but zero is the only meaningful value.
If style specifies a connectionless communication style, then the two sockets you get are not connected, strictly speaking, but each of them knows the other as the default destination address, so they can send packets to each other.
The socketpair function returns 0 on success and -1
on failure. The following errno error conditions are defined
for this function:
EMFILE
EAFNOSUPPORT
EPROTONOSUPPORT
EOPNOTSUPP
The most common communication styles involve making a connection to a particular other socket, and then exchanging data with that socket over and over. Making a connection is asymmetric; one side (the client) acts to request a connection, while the other side (the server) makes a socket and waits for the connection request.
In making a connection, the client makes a connection while the server
waits for and accepts the connection. Here we discuss what the client
program must do, using the connect function, which is declared in
`sys/socket.h'.
connect function initiates a connection from the socket
with file descriptor socket to the socket whose address is
specified by the addr and length arguments. (This socket
is typically on another machine, and it must be already set up as a
server.) See section Socket Addresses, for information about how these
arguments are interpreted.
Normally, connect waits until the server responds to the request
before it returns. You can set nonblocking mode on the socket
socket to make connect return immediately without waiting
for the response. See section File Status Flags, for information about
nonblocking mode.
The normal return value from connect is 0. If an error
occurs, connect returns -1. The following errno
error conditions are defined for this function:
EBADF
ENOTSOCK
EADDRNOTAVAIL
EAFNOSUPPORT
EISCONN
ETIMEDOUT
ECONNREFUSED
ENETUNREACH
EADDRINUSE
EINPROGRESS
select; see section Waiting for Input or Output.
Another connect call on the same socket, before the connection is
completely established, will fail with EALREADY.
EALREADY
EINPROGRESS above).
Now let us consider what the server process must do to accept
connections on a socket. First it must use the listen function
to enable connection requests on the socket, and then accept each
incoming connection with a call to accept (see section Accepting Connections). Once connection requests are enabled on a server socket,
the select function reports when the socket has a connection
ready to be accepted (see section Waiting for Input or Output).
The listen function is not allowed for sockets using
connectionless communication styles.
You can write a network server that does not even start running until a
connection to it is requested. See section inetd Servers.
In the Internet namespace, there are no special protection mechanisms for controlling access to connect to a port; any process on any machine can make a connection to your server. If you want to restrict access to your server, make it examine the addresses associated with connection requests or implement some other handshaking or identification protocol.
In the File namespace, the ordinary file protection bits control who has access to connect to the socket.
listen function enables the socket socket to accept
connections, thus making it a server socket.
The argument n specifies the length of the queue for pending
connections. When the queue fills, new clients attempting to connect
fail with ECONNREFUSED until the server calls accept to
accept a connection from the queue.
The listen function returns 0 on success and -1
on failure. The following errno error conditions are defined
for this function:
EBADF
ENOTSOCK
EOPNOTSUPP
When a server receives a connection request, it can complete the
connection by accepting the request. Use the function accept
to do this.
A socket that has been established as a server can accept connection
requests from multiple clients. The server's original socket
does not become part of the connection; instead, accept
makes a new socket which participates in the connection.
accept returns the descriptor for this socket. The server's
original socket remains available for listening for further connection
requests.
The number of pending connection requests on a server socket is finite.
If connection requests arrive from clients faster than the server can
act upon them, the queue can fill up and additional requests are refused
with a ECONNREFUSED error. You can specify the maximum length of
this queue as an argument to the listen function, although the
system may also impose its own internal limit on the length of this
queue.
The accept function waits if there are no connections pending,
unless the socket socket has nonblocking mode set. (You can use
select to wait for a pending connection, with a nonblocking
socket.) See section File Status Flags, for information about nonblocking
mode.
The addr and length-ptr arguments are used to return information about the name of the client socket that initiated the connection. See section Socket Addresses, for information about the format of the information.
Accepting a connection does not make socket part of the
connection. Instead, it creates a new socket which becomes
connected. The normal return value of accept is the file
descriptor for the new socket.
After accept, the original socket socket remains open and
unconnected, and continues listening until you close it. You can
accept further connections with socket by calling accept
again.
If an error occurs, accept returns -1. The following
errno error conditions are defined for this function:
EBADF
ENOTSOCK
EOPNOTSUPP
EWOULDBLOCK
The accept function is not allowed for sockets using
connectionless communication styles.
getpeername function returns the address of the socket that
socket is connected to; it stores the address in the memory space
specified by addr and length-ptr. It stores the length of
the address in *length-ptr.
See section Socket Addresses, for information about the format of the
address. In some operating systems, getpeername works only for
sockets in the Internet domain.
The return value is 0 on success and -1 on error. The
following errno error conditions are defined for this function:
EBADF
ENOTSOCK
ENOTCONN
ENOBUFS
Once a socket has been connected to a peer, you can use the ordinary
read and write operations (see section Input and Output Primitives) to
transfer data. A socket is a two-way communications channel, so read
and write operations can be performed at either end.
There are also some I/O modes that are specific to socket operations.
In order to specify these modes, you must use the recv and
send functions instead of the more generic read and
write functions. The recv and send functions take
an additional argument which you can use to specify various flags to
control the special I/O modes. For example, you can specify the
MSG_OOB flag to read or write out-of-band data, the
MSG_PEEK flag to peek at input, or the MSG_DONTROUTE flag
to control inclusion of routing information on output.
The send function is declared in the header file
`sys/socket.h'. If your flags argument is zero, you can just
as well use write instead of send; see section Input and Output Primitives. If the socket was connected but the connection has broken,
you get a SIGPIPE signal for any use of send or
write (see section Miscellaneous Signals).
send function is like write, but with the additional
flags flags. The possible values of flags are described
in section Socket Data Options.
This function returns the number of bytes transmitted, or -1 on
failure. If the socket is nonblocking, then send (like
write) can return after sending just part of the data.
See section File Status Flags, for information about nonblocking mode.
Note, however, that a successful return value merely indicates that the message has been sent without error, not necessarily that it has been received without error.
The following errno error conditions are defined for this function:
EBADF
EINTR
ENOTSOCK
EMSGSIZE
EWOULDBLOCK
send blocks until the operation can be
completed.)
ENOBUFS
ENOTCONN
EPIPE
send generates a SIGPIPE signal first; if that
signal is ignored or blocked, or if its handler returns, then
send fails with EPIPE.
The recv function is declared in the header file
`sys/socket.h'. If your flags argument is zero, you can
just as well use read instead of recv; see section Input and Output Primitives.
recv function is like read, but with the additional
flags flags. The possible values of flags are described
In section Socket Data Options.
If nonblocking mode is set for socket, and no data is available to
be read, recv fails immediately rather than waiting. See section File Status Flags, for information about nonblocking mode.
This function returns the number of bytes received, or -1 on failure.
The following errno error conditions are defined for this function:
EBADF
ENOTSOCK
EWOULDBLOCK
recv blocks until there is input
available to be read.)
EINTR
ENOTCONN
The flags argument to send and recv is a bit
mask. You can bitwise-OR the values of the following macros together
to obtain a value for this argument. All are defined in the header
file `sys/socket.h'.
recv, not with
send.
Here is an example client program that makes a connection for a byte stream socket in the Internet namespace. It doesn't do anything particularly interesting once it has connected to the server; it just sends a text string to the server and exits.
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#define PORT 5555
#define MESSAGE "Yow!!! Are we having fun yet?!?"
#define SERVERHOST "churchy.gnu.ai.mit.edu"
void
write_to_server (int filedes)
{
int nbytes;
nbytes = write (filedes, MESSAGE, strlen (MESSAGE) + 1);
if (nbytes < 0)
{
perror ("write");
exit (EXIT_FAILURE);
}
}
int
main (void)
{
extern void init_sockaddr (struct sockaddr_in *name,
const char *hostname,
unsigned short int port);
int sock;
struct sockaddr_in servername;
/* Create the socket. */
sock = socket (PF_INET, SOCK_STREAM, 0);
if (sock < 0)
{
perror ("socket (client)");
exit (EXIT_FAILURE);
}
/* Connect to the server. */
init_sockaddr (&servername, SERVERHOST, PORT);
if (0 > connect (sock,
(struct sockaddr *) &servername,
sizeof (servername)))
{
perror ("connect (client)");
exit (EXIT_FAILURE);
}
/* Send data to the server. */
write_to_server (sock);
close (sock);
exit (EXIT_SUCCESS);
}
The server end is much more complicated. Since we want to allow
multiple clients to be connected to the server at the same time, it
would be incorrect to wait for input from a single client by simply
calling read or recv. Instead, the right thing to do is
to use select (see section Waiting for Input or Output) to wait for input on
all of the open sockets. This also allows the server to deal with
additional connection requests.
This particular server doesn't do anything interesting once it has gotten a message from a client. It does close the socket for that client when it detects an end-of-file condition (resulting from the client shutting down its end of the connection).
This program uses make_socket and init_sockaddr to set
up the socket address; see section Internet Socket Example.
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#define PORT 5555
#define MAXMSG 512
int
read_from_client (int filedes)
{
char buffer[MAXMSG];
int nbytes;
nbytes = read (filedes, buffer, MAXMSG);
if (nbytes < 0)
{
/* Read error. */
perror ("read");
exit (EXIT_FAILURE);
}
else if (nbytes == 0)
/* End-of-file. */
return -1;
else
{
/* Data read. */
fprintf (stderr, "Server: got message: `%s'\n", buffer);
return 0;
}
}
int
main (void)
{
extern int make_socket (unsigned short int port);
int sock;
fd_set active_fd_set, read_fd_set;
int i;
struct sockaddr_in clientname;
size_t size;
/* Create the socket and set it up to accept connections. */
sock = make_socket (PORT);
if (listen (sock, 1) < 0)
{
perror ("listen");
exit (EXIT_FAILURE);
}
/* Initialize the set of active sockets. */
FD_ZERO (&active_fd_set);
FD_SET (sock, &active_fd_set);
while (1)
{
/* Block until input arrives on one or more active sockets. */
read_fd_set = active_fd_set;
if (select (FD_SETSIZE, &read_fd_set, NULL, NULL, NULL) < 0)
{
perror ("select");
exit (EXIT_FAILURE);
}
/* Service all the sockets with input pending. */
for (i = 0; i < FD_SETSIZE; ++i)
if (FD_ISSET (i, &read_fd_set))
{
if (i == sock)
{
/* Connection request on original socket. */
int new;
size = sizeof (clientname);
new = accept (sock,
(struct sockaddr *) &clientname,
&size);
if (new < 0)
{
perror ("accept");
exit (EXIT_FAILURE);
}
fprintf (stderr,
"Server: connect from host %s, port %hd.\n",
inet_ntoa (clientname.sin_addr),
ntohs (clientname.sin_port));
FD_SET (new, &active_fd_set);
}
else
{
/* Data arriving on an already-connected socket. */
if (read_from_client (i) < 0)
{
close (i);
FD_CLR (i, &active_fd_set);
}
}
}
}
}
Streams with connections permit out-of-band data that is
delivered with higher priority than ordinary data. Typically the
reason for sending out-of-band data is to send notice of an
exceptional condition. The way to send out-of-band data is using
send, specifying the flag MSG_OOB (see section Sending Data).
Out-of-band data is received with higher priority because the
receiving process need not read it in sequence; to read the next
available out-of-band data, use recv with the MSG_OOB
flag (see section Receiving Data). Ordinary read operations do not read
out-of-band data; they read only the ordinary data.
When a socket finds that out-of-band data is on its way, it sends a
SIGURG signal to the owner process or process group of the
socket. You can specify the owner using the F_SETOWN command
to the fcntl function; see section Interrupt-Driven Input. You must
also establish a handler for this signal, as described in section Signal Handling, in order to take appropriate action such as reading the
out-of-band data.
Alternatively, you can test for pending out-of-band data, or wait
until there is out-of-band data, using the select function; it
can wait for an exceptional condition on the socket. See section Waiting for Input or Output, for more information about select.
Notification of out-of-band data (whether with SIGURG or with
select) indicates that out-of-band data is on the way; the data
may not actually arrive until later. If you try to read the
out-of-band data before it arrives, recv fails with an
EWOULDBLOCK error.
Sending out-of-band data automatically places a "mark" in the stream of ordinary data, showing where in the sequence the out-of-band data "would have been". This is useful when the meaning of out-of-band data is "cancel everything sent so far". Here is how you can test, in the receiving process, whether any ordinary data was sent before the mark:
success = ioctl (socket, SIOCATMARK, &result);
Here's a function to discard any ordinary data preceding the out-of-band mark:
int
discard_until_mark (int socket)
{
while (1)
{
/* This is not an arbitrary limit; any size will do. */
char buffer[1024];
int result, success;
/* If we have reached the mark, return. */
success = ioctl (socket, SIOCATMARK, &result);
if (success < 0)
perror ("ioctl");
if (result)
return;
/* Otherwise, read a bunch of ordinary data and discard it.
This is guaranteed not to read past the mark
if it starts before the mark. */
success = read (socket, buffer, sizeof buffer);
if (success < 0)
perror ("read");
}
}
If you don't want to discard the ordinary data preceding the mark, you
may need to read some of it anyway, to make room in internal system
buffers for the out-of-band data. If you try to read out-of-band data
and get an EWOULDBLOCK error, try reading some ordinary data
(saving it so that you can use it when you want it) and see if that
makes room. Here is an example:
struct buffer
{
char *buffer;
int size;
struct buffer *next;
};
/* Read the out-of-band data from SOCKET and return it
as a `struct buffer', which records the address of the data
and its size.
It may be necessary to read some ordinary data
in order to make room for the out-of-band data.
If so, the ordinary data is saved as a chain of buffers
found in the `next' field of the value. */
struct buffer *
read_oob (int socket)
{
struct buffer *tail = 0;
struct buffer *list = 0;
while (1)
{
/* This is an arbitrary limit.
Does anyone know how to do this without a limit? */
char *buffer = (char *) xmalloc (1024);
struct buffer *link;
int success;
int result;
/* Try again to read the out-of-band data. */
success = recv (socket, buffer, sizeof buffer, MSG_OOB);
if (success >= 0)
{
/* We got it, so return it. */
struct buffer *link
= (struct buffer *) xmalloc (sizeof (struct buffer));
link->buffer = buffer;
link->size = success;
link->next = list;
return link;
}
/* If we fail, see if we are at the mark. */
success = ioctl (socket, SIOCATMARK, &result);
if (success < 0)
perror ("ioctl");
if (result)
{
/* At the mark; skipping past more ordinary data cannot help.
So just wait a while. */
sleep (1);
continue;
}
/* Otherwise, read a bunch of ordinary data and save it.
This is guaranteed not to read past the mark
if it starts before the mark. */
success = read (socket, buffer, sizeof buffer);
if (success < 0)
perror ("read");
/* Save this data in the buffer list. */
{
struct buffer *link
= (struct buffer *) xmalloc (sizeof (struct buffer));
link->buffer = buffer;
link->size = success;
/* Add the new link to the end of the list. */
if (tail)
tail->next = link;
else
list = link;
tail = link;
}
}
}
This section describes how to use communication styles that don't use
connections (styles SOCK_DGRAM and SOCK_RDM). Using
these styles, you group data into packets and each packet is an
independent communication. You specify the destination for each
packet individually.
Datagram packets are like letters: you send each one independently, with its own destination address, and they may arrive in the wrong order or not at all.
The listen and accept functions are not allowed for
sockets using connectionless communication styles.
The normal way of sending data on a datagram socket is by using the
sendto function, declared in `sys/socket.h'.
You can call connect on a datagram socket, but this only
specifies a default destination for further data transmission on the
socket. When a socket has a default destination, then you can use
send (see section Sending Data) or even write (see section Input and Output Primitives) to send a packet there. You can cancel the default
destination by calling connect using an address format of
AF_UNSPEC in the addr argument. See section Making a Connection, for
more information about the connect function.
sendto function transmits the data in the buffer
through the socket socket to the destination address specified
by the addr and length arguments. The size argument
specifies the number of bytes to be transmitted.
The flags are interpreted the same way as for send; see
section Socket Data Options.
The return value and error conditions are also the same as for
send, but you cannot rely on the system to detect errors and
report them; the most common error is that the packet is lost or there
is no one at the specified address to receive it, and the operating
system on your machine usually does not know this.
It is also possible for one call to sendto to report an error
due to a problem related to a previous call.
The recvfrom function reads a packet from a datagram socket and
also tells you where it was sent from. This function is declared in
`sys/socket.h'.
recvfrom function reads one packet from the socket
socket into the buffer buffer. The size argument
specifies the maximum number of bytes to be read.
If the packet is longer than size bytes, then you get the first size bytes of the packet, and the rest of the packet is lost. There's no way to read the rest of the packet. Thus, when you use a packet protocol, you must always know how long a packet to expect.
The addr and length-ptr arguments are used to return the address where the packet came from. See section Socket Addresses. For a socket in the file domain, the address information won't be meaningful, since you can't read the address of such a socket (see section The File Namespace). You can specify a null pointer as the addr argument if you are not interested in this information.
The flags are interpreted the same way as for recv
(see section Socket Data Options). The return value and error conditions
are also the same as for recv.
You can use plain recv (see section Receiving Data) instead of
recvfrom if you know don't need to find out who sent the packet
(either because you know where it should come from or because you
treat all possible senders alike). Even read can be used if
you don't want to specify flags (see section Input and Output Primitives).
Here is a set of example programs that send messages over a datagram
stream in the file namespace. Both the client and server programs use the
make_named_socket function that was presented in section The File Namespace, to create and name their sockets.
First, here is the server program. It sits in a loop waiting for messages to arrive, bouncing each message back to the sender. Obviously, this isn't a particularly useful program, but it does show the general ideas involved.
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/un.h>
#define SERVER "/tmp/serversocket"
#define MAXMSG 512
int
main (void)
{
int sock;
char message[MAXMSG];
struct sockaddr_un name;
size_t size;
int nbytes;
/* Make the socket, then loop endlessly. */
sock = make_named_socket (SERVER);
while (1)
{
/* Wait for a datagram. */
size = sizeof (name);
nbytes = recvfrom (sock, message, MAXMSG, 0,
(struct sockaddr *) & name, &size);
if (nbytes < 0)
{
perror ("recfrom (server)");
exit (EXIT_FAILURE);
}
/* Give a diagnostic message. */
fprintf (stderr, "Server: got message: %s\n", message);
/* Bounce the message back to the sender. */
nbytes = sendto (sock, message, nbytes, 0,
(struct sockaddr *) & name, size);
if (nbytes < 0)
{
perror ("sendto (server)");
exit (EXIT_FAILURE);
}
}
}
Here is the client program corresponding to the server above.
It sends a datagram to the server and then waits for a reply. Notice that the socket for the client (as well as for the server) in this example has to be given a name. This is so that the server can direct a message back to the client. Since the socket has no associated connection state, the only way the server can do this is by referencing the name of the client.
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/un.h>
#define SERVER "/tmp/serversocket"
#define CLIENT "/tmp/mysocket"
#define MAXMSG 512
#define MESSAGE "Yow!!! Are we having fun yet?!?"
int
main (void)
{
extern int make_named_socket (const char *name);
int sock;
char message[MAXMSG];
struct sockaddr_un name;
size_t size;
int nbytes;
/* Make the socket. */
sock = make_named_socket (CLIENT);
/* Initialize the server socket address. */
name.sun_family = AF_UNIX;
strcpy (name.sun_path, SERVER);
size = strlen (name.sun_path) + sizeof (name.sun_family);
/* Send the datagram. */
nbytes = sendto (sock, MESSAGE, strlen (MESSAGE) + 1, 0,
(struct sockaddr *) & name, size);
if (nbytes < 0)
{
perror ("sendto (client)");
exit (EXIT_FAILURE);
}
/* Wait for a reply. */
nbytes = recvfrom (sock, message, MAXMSG, 0, NULL, 0);
if (nbytes < 0)
{
perror ("recfrom (client)");
exit (EXIT_FAILURE);
}
/* Print a diagnostic message. */
fprintf (stderr, "Client: got message: %s\n", message);
/* Clean up. */
remove (CLIENT);
close (sock);
}
Keep in mind that datagram socket communications are unreliable. In
this example, the client program waits indefinitely if the message
never reaches the server or if the server's response never comes
back. It's up to the user running the program to kill it and restart
it, if desired. A more automatic solution could be to use
select (see section Waiting for Input or Output) to establish a timeout period
for the reply, and in case of timeout either resend the message or
shut down the socket and exit.
inetd DaemonWe've explained above how to write a server program that does its own listening. Such a server must already be running in order for anyone to connect to it.
Another way to provide service for an Internet port is to let the daemon
program inetd do the listening. inetd is a program that
runs all the time and waits (using select) for messages on a
specified set of ports. When it receives a message, it accepts the
connection (if the socket style calls for connections) and then forks a
child process to run the corresponding server program. You specify the
ports and their programs in the file `/etc/inetd.conf'.
inetd Servers
Writing a server program to be run by inetd is very simple. Each time
someone requests a connection to the appropriate port, a new server
process starts. The connection already exists at this time; the
socket is available as the standard input descriptor and as the
standard output descriptor (descriptors 0 and 1) in the server
process. So the server program can begin reading and writing data
right away. Often the program needs only the ordinary I/O facilities;
in fact, a general-purpose filter program that knows nothing about
sockets can work as a byte stream server run by inetd.
You can also use inetd for servers that use connectionless
communication styles. For these servers, inetd does not try to accept
a connection, since no connection is possible. It just starts the
server program, which can read the incoming datagram packet from
descriptor 0. The server program can handle one request and then
exit, or you can choose to write it to keep reading more requests
until no more arrive, and then exit. You must specify which of these
two techniques the server uses, when you configure inetd.
inetd
The file `/etc/inetd.conf' tells inetd which ports to listen to
and what server programs to run for them. Normally each entry in the
file is one line, but you can split it onto multiple lines provided
all but the first line of the entry start with whitespace. Lines that
start with `#' are comments.
Here are two standard entries in `/etc/inetd.conf':
ftp stream tcp nowait root /libexec/ftpd ftpd talk dgram udp wait root /libexec/talkd talkd
An entry has this format:
service style protocol wait username program arguments
The service field says which service this program provides. It
should be the name of a service defined in `/etc/services'.
inetd uses service to decide which port to listen on for
this entry.
The fields style and protocol specify the communication style and the protocol to use for the listening socket. The style should be the name of a communication style, converted to lower case and with `SOCK_' deleted--for example, `stream' or `dgram'. protocol should be one of the protocols listed in `/etc/protocols'. The typical protocol names are `tcp' for byte stream connections and `udp' for unreliable datagrams.
The wait field should be either `wait' or `nowait'.
Use `wait' if style is a connectionless style and the
server, once started, handles multiple requests, as many as come in.
Use `nowait' if inetd should start a new process for each message
or request that comes in. If style uses connections, then
wait must be `nowait'.
user is the user name that the server should run as. inetd runs
as root, so it can set the user ID of its children arbitrarily. It's
best to avoid using `root' for user if you can; but some
servers, such as Telnet and FTP, read a username and password
themselves. These servers need to be root initially so they can log
in as commanded by the data coming over the network.
program together with arguments specifies the command to run to start the server. program should be an absolute file name specifying the executable file to run. arguments consists of any number of whitespace-separated words, which become the command-line arguments of program. The first word in arguments is argument zero, which should by convention be the program name itself (sans directories).
If you edit `/etc/inetd.conf', you can tell inetd to reread the
file and obey its new contents by sending the inetd process the
SIGHUP signal. You'll have to use ps to determine the
process ID of the inetd process, as it is not fixed.
This section describes how to read or set various options that modify the behavior of sockets and their underlying communications protocols.
When you are manipulating a socket option, you must specify which level the option pertains to. This describes whether the option applies to the socket interface, or to a lower-level communications protocol interface.
Here are the functions for examining and modifying socket options. They are declared in `sys/socket.h'.
getsockopt function gets information about the value of
option optname at level level for socket socket.
The option value is stored in a buffer that optval points to.
Before the call, you should supply in *optlen-ptr the
size of this buffer; on return, it contains the number of bytes of
information actually stored in the buffer.
Most options interpret the optval buffer as a single int
value.
The actual return value of getsockopt is 0 on success
and -1 on failure. The following errno error conditions
are defined:
EBADF
ENOTSOCK
ENOPROTOOPT
The return value and error codes for setsockopt are the same as
for getsockopt.
getsockopt or
setsockopt to manipulate the socket-level options described in
this section.
Here is a table of socket-level option names; all are defined in the header file `sys/socket.h'.
SO_DEBUG
int; a nonzero value means
"yes".
SO_REUSEADDR
bind (see section Setting the Address of a Socket)
should permit reuse of local addresses for this socket. If you enable
this option, you can actually have two sockets with the same Internet
port number; but the system won't allow you to use the two
identically-named sockets in a way that would confuse the Internet. The
reason for this option is that some higher-level Internet protocols,
including FTP, require you to keep reusing the same socket number.
The value has type int; a nonzero value means "yes".
SO_KEEPALIVE
int; a nonzero value means
"yes".
SO_DONTROUTE
int; a nonzero
value means "yes".
SO_LINGER
struct linger.
int l_onoff
close
blocks until the data is transmitted or the timeout period has expired.
int l_linger
SO_BROADCAST
int; a nonzero value means "yes".
SO_OOBINLINE
read or recv without specifying the MSG_OOB
flag. See section Out-of-Band Data. The value has type int; a
nonzero value means "yes".
SO_SNDBUF
size_t, which is the size in bytes.
SO_RCVBUF
size_t, which is the size in bytes.
SO_STYLE
SO_TYPE
getsockopt only. It is used to
get the socket's communication style. SO_TYPE is the
historical name, and SO_STYLE is the preferred name in GNU.
The value has type int and its value designates a communication
style; see section Communication Styles.
SO_ERROR
getsockopt only. It is used to reset
the error status of the socket. The value is an int, which represents
the previous error status.
Many systems come with a database that records a list of networks known
to the system developer. This is usually kept either in the file
`/etc/networks' or in an equivalent from a name server. This data
base is useful for routing programs such as route, but it is not
useful for programs that simply communicate over the network. We
provide functions to access this data base, which are declared in
`netdb.h'.
char *n_name
char **n_aliases
int n_addrtype
AF_INET for Internet networks.
unsigned long int n_net
Use the getnetbyname or getnetbyaddr functions to search
the networks database for information about a specific network. The
information is returned in a statically-allocated structure; you must
copy the information if you need to save it.
getnetbyname function returns information about the network
named name. It returns a null pointer if there is no such
network.
getnetbyaddr function returns information about the network
of type type with number net. You should specify a value of
AF_INET for the type argument for Internet networks.
getnetbyaddr returns a null pointer if there is no such
network.
You can also scan the networks database using setnetent,
getnetent, and endnetent. Be careful in using these
functions, because they are not reentrant.
If the stayopen argument is nonzero, this sets a flag so that
subsequent calls to getnetbyname or getnetbyaddr will
not close the database (as they usually would). This makes for more
efficiency if you call those functions several times, by avoiding
reopening the database for each call.
This chapter describes functions that are specific to terminal devices. You can use these functions to do things like turn off input echoing; set serial line characteristics such as line speed and flow control; and change which characters are used for end-of-file, command-line editing, sending signals, and similar control functions.
Most of the functions in this chapter operate on file descriptors. See section Low-Level Input/Output, for more information about what a file descriptor is and how to open a file descriptor for a terminal device.
The functions described in this chapter only work on files that
correspond to terminal devices. You can find out whether a file
descriptor is associated with a terminal by using the isatty
function.
Prototypes for both isatty and ttyname are declared in
the header file `unistd.h'.
1 if filedes is a file descriptor
associated with an open terminal device, and 0 otherwise.
If a file descriptor is associated with a terminal, you can get its
associated file name using the ttyname function. See also the
ctermid function, described in section Identifying the Controlling Terminal.
ttyname function returns a pointer to a
statically-allocated, null-terminated string containing the file name of
the terminal file. The value is a null pointer if the file descriptor
isn't associated with a terminal, or the file name cannot be determined.
Many of the remaining functions in this section refer to the input and output queues of a terminal device. These queues implement a form of buffering within the kernel independent of the buffering implemented by I/O streams (see section Input/Output on Streams).
The terminal input queue is also sometimes referred to as its typeahead buffer. It holds the characters that have been received from the terminal but not yet read by any process.
The size of the terminal's input queue is described by the
MAX_INPUT and _POSIX_MAX_INPUT parameters; see section Limits on File System Capacity. You are guaranteed a queue size of at least
MAX_INPUT, but the queue might be larger, and might even
dynamically change size. If input flow control is enabled by setting
the IXOFF input mode bit (see section Input Modes), the terminal
driver transmits STOP and START characters to the terminal when
necessary to prevent the queue from overflowing. Otherwise, input may
be lost if it comes in too fast from the terminal. In canonical mode,
all input stays in the queue until a newline character is received, so
the terminal input queue can fill up when you type a very long line.
See section Two Styles of Input: Canonical or Not.
The terminal output queue is like the input queue, but for output;
it contains characters that have been written by processes, but not yet
transmitted to the terminal. If output flow control is enabled by
setting the IXON input mode bit (see section Input Modes), the
terminal driver obeys STOP and STOP characters sent by the terminal to
stop and restart transmission of output.
Clearing the terminal input queue means discarding any characters that have been received but not yet read. Similarly, clearing the terminal output queue means discarding any characters that have been written but not yet transmitted.
POSIX systems support two basic modes of input: canonical and noncanonical.
In canonical input processing mode, terminal input is processed in
lines terminated by newline ('\n'), EOF, or EOL characters. No
input can be read until an entire line has been typed by the user, and
the read function (see section Input and Output Primitives) returns at most a
single line of input, no matter how many bytes are requested.
In canonical input mode, the operating system provides input editing facilities: some characters are interpreted specially to perform editing operations within the current line of text, such as ERASE and KILL. See section Characters for Input Editing.
The constants _POSIX_MAX_CANON and MAX_CANON parameterize
the maximum number of bytes which may appear in a single line of
canonical input. See section Limits on File System Capacity. You are guaranteed a maximum
line length of at least MAX_CANON bytes, but the maximum might be
larger, and might even dynamically change size.
In noncanonical input processing mode, characters are not grouped into lines, and ERASE and KILL processing is not performed. The granularity with which bytes are read in noncanonical input mode is controlled by the MIN and TIME settings. See section Noncanonical Input.
Most programs use canonical input mode, because this gives the user a way to edit input line by line. The usual reason to use noncanonical mode is when the program accepts single-character commands or provides its own editing facilities.
The choice of canonical or noncanonical input is controlled by the
ICANON flag in the c_lflag member of struct termios.
See section Local Modes.
This section describes the various terminal attributes that control how input and output are done. The functions, data structures, and symbolic constants are all declared in the header file `termios.h'.
The entire collection of attributes of a terminal is stored in a
structure of type struct termios. This structure is used
with the functions tcgetattr and tcsetattr to read
and set the attributes.
tcflag_t c_iflag
tcflag_t c_oflag
tcflag_t c_cflag
tcflag_t c_lflag
cc_t c_cc[NCCS]
The struct termios structure also contains members which
encode input and output transmission speeds, but the representation is
not specified. See section Line Speed, for how to examine and store the
speed values.
The following sections describe the details of the members of the
struct termios structure.
c_cc
array.
If successful, tcgetattr returns 0. A return value of -1
indicates an error. The following errno error conditions are
defined for this function:
EBADF
ENOTTY
The when argument specifies how to deal with input and output already queued. It can be one of the following values:
TCSANOW
TCSADRAIN
TCSAFLUSH
TCSADRAIN, but also discards any queued input.
TCSASOFT
TCSASOFT is exactly the same as setting the CIGNORE
bit in the c_cflag member of the structure termios-p points
to. See section Control Modes, for a description of CIGNORE.
If this function is called from a background process on its controlling
terminal, normally all processes in the process group are sent a
SIGTTOU signal, in the same way as if the process were trying to
write to the terminal. The exception is if the calling process itself
is ignoring or blocking SIGTTOU signals, in which case the
operation is performed and no signal is sent. See section Job Control.
If successful, tcsetattr returns 0. A return value of
-1 indicates an error. The following errno error
conditions are defined for this function:
EBADF
ENOTTY
EINVAL
when argument is not valid, or there is
something wrong with the data in the termios-p argument.
Although tcgetattr and tcsetattr specify the terminal
device with a file descriptor, the attributes are those of the terminal
device itself and not of the file descriptor. This means that the
effects of changing terminal attributes are persistent; if another
process opens the terminal file later on, it will see the changed
attributes even though it doesn't have anything to do with the open file
descriptor you originally specified in changing the attributes.
Similarly, if a single process has multiple or duplicated file descriptors for the same terminal device, changing the terminal attributes affects input and output to all of these file descriptors. This means, for example, that you can't open one file descriptor or stream to read from a terminal in the normal line-buffered, echoed mode; and simultaneously have another file descriptor for the same terminal that you use to read from it in single-character, non-echoed mode. Instead, you have to explicitly switch the terminal back and forth between the two modes.
When you set terminal modes, you should call tcgetattr first to
get the current modes of the particular terminal device, modify only
those modes that you are really interested in, and store the result with
tcsetattr.
It's a bad idea to simply initialize a struct termios structure
to a chosen set of attributes and pass it directly to tcsetattr.
Your program may be run years from now, on systems that support members
not documented in this manual. The way to avoid setting these members
to unreasonable values is to avoid changing them.
What's more, different terminal devices may require different mode settings in order to function properly. So you should avoid blindly copying attributes from one terminal device to another.
When a member contains a collection of independent flags, as the
c_iflag, c_oflag and c_cflag members do, even
setting the entire member is a bad idea, because particular operating
systems have their own flags. Instead, you should start with the
current value of the member and alter only the flags whose values matter
in your program, leaving any other flags unchanged.
Here is an example of how to set one flag (ISTRIP) in the
struct termios structure while properly preserving all the other
data in the structure:
int
set_istrip (int desc, int value)
{
struct termios settings;
int result;
result = tcgetattr (desc, &settings);
if (result < 0)
{
perror ("error in tcgetattr");
return 0;
}
settings.c_iflag &= ~ISTRIP;
if (value)
settings.c_iflag |= ISTRIP;
result = tcsetattr (desc, TCSANOW, &settings);
if (result < 0)
{
perror ("error in tcgetattr");
return;
}
return 1;
}
This section describes the terminal attribute flags that control fairly low-level aspects of input processing: handling of parity errors, break signals, flow control, and RET and LFD characters.
All of these flags are bits in the c_iflag member of the
struct termios structure. The member is an integer, and you
change flags using the operators &, | and ^. Don't
try to specify the entire value for c_iflag---instead, change
only specific flags and leave the rest untouched (see section Setting Terminal Modes Properly).
Parity checking on input processing is independent of whether parity
detection and generation on the underlying terminal hardware is enabled;
see section Control Modes. For example, you could clear the INPCK
input mode flag and set the PARENB control mode flag to ignore
parity errors on input, but still generate parity on output.
If this bit is set, what happens when a parity error is detected depends
on whether the IGNPAR or PARMRK bits are set. If neither
of these bits are set, a byte with a parity error is passed to the
application as a '\0' character.
INPCK is also set.
INPCK is set and IGNPAR is not set.
The way erroneous bytes are marked is with two preceding bytes,
377 and 0. Thus, the program actually reads three bytes
for one erroneous byte received from the terminal.
If a valid byte has the value 0377, and ISTRIP (see below)
is not set, the program might confuse it with the prefix that marks a
parity error. So a valid byte 0377 is passed to the program as
two bytes, 0377 0377, in this case.
A break condition is defined in the context of asynchronous serial data transmission as a series of zero-value bits longer than a single byte.
IGNBRK is not set, a break condition
clears the terminal input and output queues and raises a SIGINT
signal for the foreground process group associated with the terminal.
If neither BRKINT nor IGNBRK are set, a break condition is
passed to the application as a single '\0' character if
PARMRK is not set, or otherwise as a three-character sequence
'\377', '\0', '\0'.
'\r') are
discarded on input. Discarding carriage return may be useful on
terminals that send both carriage return and linefeed when you type the
RET key.
IGNCR is not set, carriage return characters
('\r') received as input are passed to the application as newline
characters ('\n').
'\n') received as input
are passed to the application as carriage return characters ('\r').
This is a BSD extension; it exists only on BSD systems and the GNU system.
007) to the terminal to ring the bell.
This is a BSD extension.
This section describes the terminal flags and fields that control how
output characters are translated and padded for display. All of these
are contained in the c_oflag member of the struct termios
structure.
The c_oflag member itself is an integer, and you change the flags
and fields using the operators &, |, and ^. Don't
try to specify the entire value for c_oflag---instead, change
only specific flags and leave the rest untouched (see section Setting Terminal Modes Properly).
'\n') onto
carriage return and linefeed pairs.
If this bit isn't set, the characters are transmitted as-is.
The following three bits are BSD features, and they exist only BSD
systems and the GNU system. They are effective only if OPOST is
set.
004) on
output. These characters cause many dial-up terminals to disconnect.
This section describes the terminal flags and fields that control
parameters usually associated with asynchronous serial data
transmission. These flags may not make sense for other kinds of
terminal ports (such as a network connection pseudo-terminal). All of
these are contained in the c_cflag member of the struct
termios structure.
The c_cflag member itself is an integer, and you change the flags
and fields using the operators &, |, and ^. Don't
try to specify the entire value for c_cflag---instead, change
only specific flags and leave the rest untouched (see section Setting Terminal Modes Properly).
On many systems if this bit is not set and you call open without
the O_NONBLOCK flag set, open blocks until a modem
connection is established.
If this bit is not set and a modem disconnect is detected, a
SIGHUP signal is sent to the controlling process group for the
terminal (if it has one). Normally, this causes the process to exit;
see section Signal Handling. Reading from the terminal after a disconnect
causes an end-of-file condition, and writing causes an EIO error
to be returned. The terminal device must be closed and reopened to
clear the condition.
If this bit is not set, no parity bit is added to output characters, and input characters are not checked for correct parity.
PARENB is set. If PARODD is set,
odd parity is used, otherwise even parity is used.
The control mode flags also includes a field for the number of bits per
character. You can use the CSIZE macro as a mask to extract the
value, like this: settings.c_cflag & CSIZE.
The following four bits are BSD extensions; this exist only on BSD systems and the GNU system.
tcsetattr.
The c_cflag member and the line speed values returned by
cfgetispeed and cfgetospeed will be unaffected by the
call. CIGNORE is useful if you want to set all the software
modes in the other members, but leave the hardware details in
c_cflag unchanged. (This is how the TCSASOFT flag to
tcsettattr works.)
This bit is never set in the structure filled in by tcgetattr.
This section describes the flags for the c_lflag member of the
struct termios structure. These flags generally control
higher-level aspects of input processing than the input modes flags
described in section Input Modes, such as echoing, signals, and the choice
of canonical or noncanonical input.
The c_lflag member itself is an integer, and you change the flags
and fields using the operators &, |, and ^. Don't
try to specify the entire value for c_lflag---instead, change
only specific flags and leave the rest untouched (see section Setting Terminal Modes Properly).
This bit only controls the display behavior; the ICANON bit by
itself controls actual recognition of the ERASE character and erasure of
input, without which ECHOE is simply irrelevant.
ECHOE, enables display of the ERASE character in
a way that is geared to a hardcopy terminal. When you type the ERASE
character, a `\' character is printed followed by the first
character erased. Typing the ERASE character again just prints the next
character erased. Then, the next time you type a normal character, a
`/' character is printed before the character echoes.
This is a BSD extension, and exists only in BSD systems and the GNU system.
ECHOKE (below) is nicer to look at.
If this bit is not set, the KILL character echoes just as it would if it were not the KILL character. Then it is up to the user to remember that the KILL character has erased the preceding input; there is no indication of this on the screen.
This bit only controls the display behavior; the ICANON bit by
itself controls actual recognition of the KILL character and erasure of
input, without which ECHOK is simply irrelevant.
ECHOK. It enables special display of the
KILL character by erasing on the screen the entire line that has been
killed. This is a BSD extension, and exists only in BSD systems and the
GNU system.
ICANON bit is also set, then the
newline ('\n') character is echoed even if the ECHO bit
is not set.
ECHO bit is also set, echo control
characters with `^' followed by the corresponding text character.
Thus, control-A echoes as `^A'. This is usually the preferred mode
for interactive input, because echoing a control character back to the
terminal could have some undesired effect on the terminal.
This is a BSD extension, and exists only in BSD systems and the GNU system.
You should use caution when disabling recognition of these characters. Programs that cannot be interrupted interactively are very user-unfriendly. If you clear this bit, your program should provide some alternate interface that allows the user to interactively send the signals associated with these characters, or to escape from the program.
See section Characters that Cause Signals.
IEXTEN implementation-defined meaning,
so you cannot rely on this interpretation on all systems.
On BSD systems and the GNU system, it enables the LNEXT and DISCARD characters. See section Other Special Characters.
SIGTTOU signals are generated by background processes that
attempt to write to the terminal. See section Access to the Controlling Terminal.
The following bits are BSD extensions; they exist only in BSD systems and the GNU system.
If this bit is clear, then the beginning of a word is a nonwhitespace character following a whitespace character. If the bit is set, then the beginning of a word is an alphanumeric character or underscore following a character which is none of those.
See section Characters for Input Editing, for more information about the WERASE character.
The terminal line speed tells the computer how fast to read and write data on the terminal.
If the terminal is connected to a real serial line, the terminal speed you specify actually controls the line--if it doesn't match the terminal's own idea of the speed, communication does not work. Real serial ports accept only certain standard speeds. Also, particular hardware may not support even all the standard speeds. Specifying a speed of zero hangs up a dialup connection and turns off modem control signals.
If the terminal is not a real serial line (for example, if it is a network connection), then the line speed won't really affect data transmission speed, but some programs will use it to determine the amount of padding needed. It's best to specify a line speed value that matches the actual speed of the actual terminal, but you can safely experiment with different values to vary the amount of padding.
There are actually two line speeds for each terminal, one for input and one for output. You can set them independently, but most often terminals use the same speed for both directions.
The speed values are stored in the struct termios structure, but
don't try to access them in the struct termios structure
directly. Instead, you should use the following functions to read and
store them:
*termios-p.
*termios-p.
*termios-p as the output
speed. The normal return value is 0; a value of -1
indicates an error. If speed is not a speed, cfsetospeed
returns -1.
*termios-p as the input
speed. The normal return value is 0; a value of -1
indicates an error. If speed is not a speed, cfsetospeed
returns -1.
*termios-p as both the
input and output speeds. The normal return value is 0; a value
of -1 indicates an error. If speed is not a speed,
cfsetspeed returns -1. This function is an extension in
4.4 BSD.
speed_t type is an unsigned integer data type used to
represent line speeds.
The functions cfsetospeed and cfsetispeed report errors
only for speed values that the system simply cannot handle. If you
specify a speed value that is basically acceptable, then those functions
will succeed. But they do not check that a particular hardware device
can actually support the specified speeds--in fact, they don't know
which device you plan to set the speed for. If you use tcsetattr
to set the speed of a particular device to a value that it cannot
handle, tcsetattr returns -1.
Portability note: In the GNU library, the functions above
accept speeds measured in bits per second as input, and return speed
values measured in bits per second. Other libraries require speeds to
be indicated by special codes. For POSIX.1 portability, you must use
one of the following symbols to represent the speed; their precise
numeric values are system-dependent, but each name has a fixed meaning:
B110 stands for 110 bps, B300 for 300 bps, and so on.
There is no portable way to represent any speed but these, but these are
the only speeds that typical serial lines can support.
B0 B50 B75 B110 B134 B150 B200 B300 B600 B1200 B1800 B2400 B4800 B9600 B19200 B38400
BSD defines two additional speed symbols as aliases: EXTA is an
alias for B19200 and EXTB is an alias for B38400.
These aliases are obsolete.
In canonical input, the terminal driver recognizes a number of special
characters which perform various control functions. These include the
ERASE character (usually DEL) for editing input, and other editing
characters. The INTR character (normally C-c) for sending a
SIGINT signal, and other signal-raising characters, may be
available in either canonical or noncanonical input mode. All these
characters are described in this section.
The particular characters used are specified in the c_cc member
of the struct termios structure. This member is an array; each
element specifies the character for a particular role. Each element has
a symbolic constant that stands for the index of that element--for
example, INTR is the index of the element that specifies the INTR
character, so storing '=' in termios.c_cc[INTR]
specifies `=' as the INTR character.
On some systems, you can disable a particular special character function
by specifying the value _POSIX_VDISABLE for that role. This
value is unequal to any possible character code. See section Optional Features in File Support, for more information about how to tell whether the operating
system you are using supports _POSIX_VDISABLE.
These special characters are active only in canonical input mode. See section Two Styles of Input: Canonical or Not.
termios.c_cc[VEOF] holds the character
itself.
The EOF character is recognized only in canonical input mode. It acts
as a line terminator in the same way as a newline character, but if the
EOF character is typed at the beginning of a line it causes read
to return a byte count of zero, indicating end-of-file. The EOF
character itself is discarded.
Usually, the EOF character is C-d.
termios.c_cc[VEOL] holds the character
itself.
The EOL character is recognized only in canonical input mode. It acts as a line terminator, just like a newline character. The EOL character is not discarded; it is read as the last character in the input line.
You don't need to use the EOL character to make RET end a line. Just set the ICRNL flag. In fact, this is the default state of affairs.
termios.c_cc[VEOL2] holds the character
itself.
The EOL2 character works just like the EOL character (see above), but it can be a different character. Thus, you can specify two characters to terminate an input line, by setting EOL to one of them and EOL2 to the other.
The EOL2 character is a BSD extension; it exists only on BSD systems and the GNU system.
termios.c_cc[VERASE] holds the
character itself.
The ERASE character is recognized only in canonical input mode. When the user types the erase character, the previous character typed is discarded. (If the terminal generates multibyte character sequences, this may cause more than one byte of input to be discarded.) This cannot be used to erase past the beginning of the current line of text. The ERASE character itself is discarded.
Usually, the ERASE character is DEL.
termios.c_cc[VWERASE] holds the character
itself.
The WERASE character is recognized only in canonical mode. It erases an entire word of prior input, and any whitespace after it; whitespace characters before the word are not erased.
The definition of a "word" depends on the setting of the
ALTWERASE mode; see section Local Modes.
If the ALTWERASE mode is not set, a word is defined as a sequence
of any characters except space or tab.
If the ALTWERASE mode is set, a word is defined as a sequence of
characters containing only letters, numbers, and underscores, optionally
followed by one character that is not a letter, number, or underscore.
The WERASE character is usually C-w.
This is a BSD extension.
termios.c_cc[VKILL] holds the character
itself.
The KILL character is recognized only in canonical input mode. When the user types the kill character, the entire contents of the current line of input are discarded. The kill character itself is discarded too.
The KILL character is usually C-u.
termios.c_cc[VREPRINT] holds the character
itself.
The REPRINT character is recognized only in canonical mode. It reprints the current input line. If some asynchronous output has come while you are typing, this lets you see the line you are typing clearly again.
The REPRINT character is usually C-r.
This is a BSD extension.
These special characters may be active in either canonical or noncanonical
input mode, but only when the ISIG flag is set (see section Local Modes).
termios.c_cc[VINTR] holds the character
itself.
The INTR (interrupt) character raises a SIGINT signal for all
processes in the foreground job associated with the terminal. The INTR
character itself is then discarded. See section Signal Handling, for more
information about signals.
Typically, the INTR character is C-c.
termios.c_cc[VQUIT] holds the character
itself.
The QUIT character raises a SIGQUIT signal for all processes in
the foreground job associated with the terminal. The QUIT character
itself is then discarded. See section Signal Handling, for more information
about signals.
Typically, the QUIT character is C-\.
termios.c_cc[VSUSP] holds the character
itself.
The SUSP (suspend) character is recognized only if the implementation
supports job control (see section Job Control). It causes a SIGTSTP
signal to be sent to all processes in the foreground job associated with
the terminal. The SUSP character itself is then discarded.
See section Signal Handling, for more information about signals.
Typically, the SUSP character is C-z.
Few applications disable the normal interpretation of the SUSP
character. If your program does this, it should provide some other
mechanism for the user to stop the job. When the user invokes this
mechanism, the program should send a SIGTSTP signal to the
process group of the process, not just to the process itself.
See section Signaling Another Process.
termios.c_cc[VDSUSP] holds the character
itself.
The DSUSP (suspend) character is recognized only if the implementation
supports job control (see section Job Control). It sends a SIGTSTP
signal, like the SUSP character, but not right away--only when the
program tries to read it as input. Not all systems with job control
support DSUSP; only BSD-compatible systems (including the GNU system).
See section Signal Handling, for more information about signals.
Typically, the DSUSP character is C-y.
These special characters may be active in either canonical or noncanonical
input mode, but their use is controlled by the flags IXON and
IXOFF (see section Input Modes).
termios.c_cc[VSTART] holds the
character itself.
The START character is used to support the IXON and IXOFF
input modes. If IXON is set, receiving a START character resumes
suspended output; the START character itself is discarded. If
IXANY is set, receiving any character at all resumes suspended
output; the resuming character is not discarded unless it is the START
character. IXOFF is set, the system may also transmit START
characters to the terminal.
The usual value for the START character is C-q. You may not be able to change this value--the hardware may insist on using C-q regardless of what you specify.
termios.c_cc[VSTOP] holds the character
itself.
The STOP character is used to support the IXON and IXOFF
input modes. If IXON is set, receiving a STOP character causes
output to be suspended; the STOP character itself is discarded. If
IXOFF is set, the system may also transmit STOP characters to the
terminal, to prevent the input queue from overflowing.
The usual value for the STOP character is C-s. You may not be able to change this value--the hardware may insist on using C-s regardless of what you specify.
These special characters exist only in BSD systems and the GNU system.
termios.c_cc[VLNEXT] holds the character
itself.
The LNEXT character is recognized only when IEXTEN is set, but in
both canonical and noncanonical mode. It disables any special
significance of the next character the user types. Even if the
character would normally perform some editing function or generate a
signal, it is read as a plain character. This is the analogue of the
C-q command in Emacs. "LNEXT" stands for "literal next."
The LNEXT character is usually C-v.
termios.c_cc[VDISCARD] holds the character
itself.
The DISCARD character is recognized only when IEXTEN is set, but
in both canonical and noncanonical mode. Its effect is to toggle the
discard-output flag. When this flag is set, all program output is
discarded. Setting the flag also discards all output currently in the
output buffer. Typing any other character resets the flag.
termios.c_cc[VSTATUS] holds the character
itself.
The STATUS character's effect is to print out a status message about how the current process is running.
The STATUS character is recognized only in canonical mode, and only if
NOKERNINFO is not set.
In noncanonical input mode, the special editing characters such as ERASE and KILL are ignored. The system facilities for the user to edit input are disabled in noncanonical mode, so that all input characters (unless they are special for signal or flow-control purposes) are passed to the application program exactly as typed. It is up to the application program to give the user ways to edit the input, if appropriate.
Noncanonical mode offers special parameters called MIN and TIME for controlling whether and how long to wait for input to be available. You can even use them to avoid ever waiting--to return immediately with whatever input is available, or with no input.
The MIN and TIME are stored in elements of the c_cc array, which
is a member of the struct termios structure. Each element of
this array has a particular role, and each element has a symbolic
constant that stands for the index of that element. VMIN and
VMAX are the names for the indices in the array of the MIN and
TIME slots.
c_cc array. Thus,
termios.c_cc[VMIN] is the value itself.
The MIN slot is only meaningful in noncanonical input mode; it
specifies the minimum number of bytes that must be available in the
input queue in order for read to return.
c_cc array. Thus,
termios.c_cc[VTIME] is the value itself.
The TIME slot is only meaningful in noncanonical input mode; it specifies how long to wait for input before returning, in units of 0.1 seconds.
The MIN and TIME values interact to determine the criterion for when
read should return; their precise meanings depend on which of
them are nonzero. There are four possible cases:
read keeps waiting until either MIN bytes have arrived in all, or
TIME elapses with no further input.
read always blocks until the first character arrives, even if
TIME elapses first. read can return more than MIN characters if
more than MIN happen to be in the queue.
read always returns immediately with as many
characters as are available in the queue, up to the number requested.
If no input is immediately available, read returns a value of
zero.
read waits for time TIME for input to become
available; the availability of a single byte is enough to satisfy the
read request and cause read to return. When it returns, it
returns as many characters as are available, up to the number requested.
If no input is available before the timer expires, read returns a
value of zero.
read waits until at least MIN bytes are available
in the queue. At that time, read returns as many characters as
are available, up to the number requested. read can return more
than MIN characters if more than MIN happen to be in the queue.
What happens if MIN is 50 and you ask to read just 10 bytes?
Normally, read waits until there are 50 bytes in the buffer (or,
more generally, the wait condition described above is satisfied), and
then reads 10 of them, leaving the other 40 buffered in the operating
system for a subsequent call to read.
Portability note: On some systems, the MIN and TIME slots are actually the same as the EOF and EOL slots. This causes no serious problem because the MIN and TIME slots are used only in noncanonical input and the EOF and EOL slots are used only in canonical input, but it isn't very clean. The GNU library allocates separate slots for these uses.
*termios-p for
what has traditionally been called "raw mode" in BSD. This uses
noncanonical input, and turns off most processing to give an unmodified
channel to the terminal.
It does exactly this:
termios-p->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
|INLCR|IGNCR|ICRNL|IXON);
termios-p->c_oflag &= ~OPOST;
termios-p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
termios-p->c_cflag &= ~(CSIZE|PARENB);
termios-p->c_cflag |= CS8;
These functions perform miscellaneous control actions on terminal
devices. As regards terminal access, they are treated like doing
output: if any of these functions is used by a background process on its
controlling terminal, normally all processes in the process group are
sent a SIGTTOU signal. The exception is if the calling process
itself is ignoring or blocking SIGTTOU signals, in which case the
operation is performed and no signal is sent. See section Job Control.
This function does nothing if the terminal is not an asynchronous serial data port.
The return value is normally zero. In the event of an error, a value
of -1 is returned. The following errno error conditions
are defined for this function:
EBADF
ENOTTY
tcdrain function waits until all queued
output to the terminal filedes has been transmitted.
The return value is normally zero. In the event of an error, a value
of -1 is returned. The following errno error conditions
are defined for this function:
EBADF
ENOTTY
EINTR
tcflush function is used to clear the input and/or output
queues associated with the terminal file filedes. The queue
argument specifies which queue(s) to clear, and can be one of the
following values:
TCIFLUSH
TCOFLUSH
TCIOFLUSH
The return value is normally zero. In the event of an error, a value
of -1 is returned. The following errno error conditions
are defined for this function:
EBADF
ENOTTY
EINVAL
It is unfortunate that this function is named tcflush, because
the term "flush" is normally used for quite another operation--waiting
until all output is transmitted--and using it for discarding input or
output would be confusing. Unfortunately, the name tcflush comes
from POSIX and we cannot change it.
tcflow function is used to perform operations relating to
XON/XOFF flow control on the terminal file specified by filedes.
The action argument specifies what operation to perform, and can be one of the following values:
TCOOFF
TCOON
TCIOFF
TCION
For more information about the STOP and START characters, see section Special Characters.
The return value is normally zero. In the event of an error, a value
of -1 is returned. The following errno error conditions
are defined for this function:
EBADF
ENOTTY
EINVAL
Here is an example program that shows how you can set up a terminal device to read single characters in noncanonical input mode, without echo.
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <termios.h>
/* Use this variable to remember original terminal attributes. */
struct termios saved_attributes;
void
reset_input_mode (void)
{
tcsetattr (STDIN_FILENO, TCSANOW, &saved_attributes);
}
void
set_input_mode (void)
{
struct termios tattr;
char *name;
/* Make sure stdin is a terminal. */
if (!isatty (STDIN_FILENO))
{
fprintf (stderr, "Not a terminal.\n");
exit (EXIT_FAILURE);
}
/* Save the terminal attributes so we can restore them later. */
tcgetattr (STDIN_FILENO, &saved_attributes);
atexit (reset_input_mode);
/* Set the funny terminal modes. */
tcgetattr (STDIN_FILENO, &tattr);
tattr.c_lflag &= ~(ICANON|ECHO); /* Clear ICANON and ECHO. */
tattr.c_cc[VMIN] = 1;
tattr.c_cc[VTIME] = 0;
tcsetattr (STDIN_FILENO, TCSAFLUSH, &tattr);
}
int
main (void)
{
char c;
set_input_mode ();
while (1)
{
read (STDIN_FILENO, &c, 1);
if (c == '\004') /* C-d */
break;
else
putchar (c);
}
return EXIT_SUCCESS;
}
This program is careful to restore the original terminal modes before
exiting or terminating with a signal. It uses the atexit
function (see section Cleanups on Exit) to make sure this is done
by exit.
The shell is supposed to take care of resetting the terminal modes when a process is stopped or continued; see section Job Control. But some existing shells do not actually do this, so you may wish to establish handlers for job control signals that reset terminal modes. The above example does so.
This chapter contains information about functions for performing mathematical computations, such as trigonometric functions. Most of these functions have prototypes declared in the header file `math.h'.
All of the functions that operate on floating-point numbers accept
arguments and return results of type double. In the future,
there may be additional functions that operate on float and
long double values. For example, cosf and cosl
would be versions of the cos function that operate on
float and long double arguments, respectively. In the
meantime, you should avoid using these names yourself. See section Reserved Names.
Many of the functions listed in this chapter are defined mathematically
over a domain that is only a subset of real numbers. For example, the
acos function is defined over the domain between -1 and
1. If you pass an argument to one of these functions that is
outside the domain over which it is defined, the function sets
errno to EDOM to indicate a domain error. On
machines that support IEEE 754 floating point, functions reporting
error EDOM also return a NaN.
Some of these functions are defined mathematically to result in a complex value over parts of their domains. The most familiar example of this is taking the square root of a negative number. The functions in this chapter take only real arguments and return only real values; therefore, if the value ought to be nonreal, this is treated as a domain error.
A related problem is that the mathematical result of a function may not
be representable as a floating point number. If magnitude of the
correct result is too large to be represented, the function sets
errno to ERANGE to indicate a range error, and
returns a particular very large value (named by the macro
HUGE_VAL) or its negation (- HUGE_VAL).
If the magnitude of the result is too small, a value of zero is returned
instead. In this case, errno might or might not be
set to ERANGE.
The only completely reliable way to check for domain and range errors is
to set errno to 0 before you call the mathematical function
and test errno afterward. As a consequence of this use of
errno, use of the mathematical functions is not reentrant if you
check for errors.
None of the mathematical functions ever generates signals as a result of
domain or range errors. In particular, this means that you won't see
SIGFPE signals generated within these functions. (See section Signal Handling, for more information about signals.)
The value of this macro is used as the return value from various
mathematical double returning functions in overflow situations.
HUGE_VAL macro except that it is
used by functions returning float values.
This macro is a GNU extension.
HUGE_VAL macro except that it is
used by functions returning long double values. The value is
only different from HUGE_VAL if the architecture really supports
long double values.
This macro is a GNU extension.
For more information about floating-point representations and limits,
see section Floating Point Parameters. In particular, the macro
DBL_MAX might be more appropriate than HUGE_VAL for many
uses other than testing for an error in a mathematical function.
These are the familiar sin, cos, and tan functions.
The arguments to all of these functions are in units of radians; recall
that pi radians equals 180 degrees.
The math library doesn't define a symbolic constant for pi, but you can define your own if you need one:
#define PI 3.14159265358979323846264338327
You can also compute the value of pi with the expression acos
(-1.0).
-1 to 1.
-1 to 1.
The following errno error conditions are defined for this function:
ERANGE
tan sets errno to ERANGE and returns
either positive or negative HUGE_VAL.
These are the usual arc sine, arc cosine and arc tangent functions, which are the inverses of the sine, cosine and tangent functions, respectively.
-pi/2 and pi/2 (inclusive).
asin fails, and sets errno to EDOM, if x is
out of range. The arc sine function is defined mathematically only
over the domain -1 to 1.
0 and pi (inclusive).
acos fails, and sets errno to EDOM, if x is
out of range. The arc cosine function is defined mathematically only
over the domain -1 to 1.
-pi/2 and pi/2
(inclusive).
-pi to pi, inclusive.
If x and y are coordinates of a point in the plane,
atan2 returns the signed angle between the line from the origin
to that point and the x-axis. Thus, atan2 is useful for
converting Cartesian coordinates to polar coordinates. (To compute the
radial coordinate, use hypot; see section Exponentiation and Logarithms.)
The function atan2 sets errno to EDOM if both
x and y are zero; the return value is not defined in this
case.
exp function returns the value of e (the base of natural
logarithms) raised to power x.
The function fails, and sets errno to ERANGE, if the
magnitude of the result is too large to be representable.
exp (log
(x)) equals x, exactly in mathematics and approximately in
C.
The following errno error conditions are defined for this function:
EDOM
ERANGE
log function. In fact,
log10 (x) equals log (x) / log (10).
The following errno error conditions are defined for this function:
EDOM
ERANGE
The sqrt function fails, and sets errno to EDOM, if
x is negative. Mathematically, the square root would be a complex
number.
hypot function returns sqrt (x*x +
y*y). (This is the length of the hypotenuse of a right
triangle with sides of length x and y, or the distance
of the point (x, y) from the origin.) See also the function
cabs in section Absolute Value.
exp (x) - 1.
It is computed in a way that is accurate even if the value of x is
near zero--a case where exp (x) - 1 would be inaccurate due
to subtraction of two numbers that are nearly equal.
log (1 + x).
It is computed in a way that is accurate even if the value of x is
near zero.
The functions in this section are related to the exponential functions; see section Exponentiation and Logarithms.
sinh function returns the hyperbolic sine of x, defined
mathematically as exp (x) - exp (-x) / 2. The
function fails, and sets errno to ERANGE, if the value of
x is too large; that is, if overflow occurs.
cosh function returns the hyperbolic cosine of x,
defined mathematically as exp (x) + exp (-x) / 2.
The function fails, and sets errno to ERANGE, if the value
of x is too large; that is, if overflow occurs.
sinh (x) / cosh (x).
1, acosh returns HUGE_VAL.
1, atanh returns
HUGE_VAL.
This section describes the GNU facilities for generating a series of pseudo-random numbers. The numbers generated are not truly random; typically, they form a sequence that repeats periodically, with a period so large that you can ignore it for ordinary purposes. The random number generator works by remembering at all times a seed value which it uses to compute the next random number and also to compute a new seed.
Although the generated numbers look unpredictable within one run of a program, the sequence of numbers is exactly the same from one run to the next. This is because the initial seed is always the same. This is convenient when you are debugging a program, but it is unhelpful if you want the program to behave unpredictably. If you want truly random numbers, not just pseudo-random, specify a seed based on the current time.
You can get repeatable sequences of numbers on a particular machine type by specifying the same initial seed value for the random number generator. There is no standard meaning for a particular seed value; the same seed, used in different C libraries or on different CPU types, will give you different random numbers.
The GNU library supports the standard ISO C random number functions
plus another set derived from BSD. We recommend you use the standard
ones, rand and srand.
This section describes the random number functions that are part of the ISO C standard.
To use these facilities, you should include the header file `stdlib.h' in your program.
rand
function. In the GNU library, it is 037777777, which is the
largest signed integer representable in 32 bits. In other libraries, it
may be as low as 32767.
rand function returns the next pseudo-random number in the
series. The value is in the range from 0 to RAND_MAX.
rand before a seed has been
established with srand, it uses the value 1 as a default
seed.
To produce truly random numbers (not just pseudo-random), do srand
(time (0)).
This section describes a set of random number generation functions that are derived from BSD. There is no advantage to using these functions with the GNU C library; we support them for BSD compatibility only.
The prototypes for these functions are in `stdlib.h'.
0 to RAND_MAX.
srandom function sets the seed for the current random number
state based on the integer seed. If you supply a seed value
of 1, this will cause random to reproduce the default set
of random numbers.
To produce truly random numbers (not just pseudo-random), do
srandom (time (0)).
initstate function is used to initialize the random number
generator state. The argument state is an array of size
bytes, used to hold the state information. The size must be at least 8
bytes, and optimal sizes are 8, 16, 32, 64, 128, and 256. The bigger
the state array, the better.
The return value is the previous value of the state information array.
You can use this value later as an argument to setstate to
restore that state.
setstate function restores the random number state
information state. The argument must have been the result of
a previous call to initstate or setstate.
The return value is the previous value of the state information array.
You can use thise value later as an argument to setstate to
restore that state.
This chapter contains information about functions for doing basic arithmetic operations, such as splitting a float into its integer and fractional parts. These functions are declared in the header file `math.h'.
The IEEE floating point format used by most modern computers supports values that are "not a number". These values are called NaNs. "Not a number" values result from certain operations which have no meaningful numeric result, such as zero divided by zero or infinity divided by infinity.
One noteworthy property of NaNs is that they are not equal to
themselves. Thus, x == x can be 0 if the value of x is a
NaN. You can use this to test whether a value is a NaN or not: if it is
not equal to itself, then it is a NaN. But the recommended way to test
for a NaN is with the isnan function (see section Predicates on Floats).
Almost any arithmetic operation in which one argument is a NaN returns a NaN.
You can use `#ifdef NAN' to test whether the machine supports
NaNs. (Of course, you must arrange for GNU extensions to be visible,
such as by defining _GNU_SOURCE, and then you must include
`math.h'.)
This section describes some miscellaneous test functions on doubles.
Prototypes for these functions appear in `math.h'. These are BSD
functions, and thus are available if you define _BSD_SOURCE or
_GNU_SOURCE.
-1 if x represents negative infinity,
1 if x represents positive infinity, and 0 otherwise.
x !=
x to get the same result).
infnan to decide what to return on
occasion of an error. Its argument is an error code, EDOM or
ERANGE; infnan returns a suitable value to indicate this
with. -ERANGE is also acceptable as an argument, and corresponds
to -HUGE_VAL as a value.
In the BSD library, on certain machines, infnan raises a fatal
signal in all cases. The GNU library does not do likewise, because that
does not fit the ISO C specification.
Portability Note: The functions listed in this section are BSD extensions.
These functions are provided for obtaining the absolute value (or
magnitude) of a number. The absolute value of a real number
x is x is x is positive, -x if x is
negative. For a complex number z, whose real part is x and
whose imaginary part is y, the absolute value is sqrt
(x*x + y*y).
Prototypes for abs and labs are in `stdlib.h';
fabs and cabs are declared in `math.h'.
Most computers use a two's complement integer representation, in which
the absolute value of INT_MIN (the smallest possible int)
cannot be represented; thus, abs (INT_MIN) is not defined.
abs, except that both the argument and result
are of type long int rather than int.
cabs function returns the absolute value of the complex
number z, whose real part is z.real and whose
imaginary part is z.imag. (See also the function
hypot in section Exponentiation and Logarithms.) The value is:
sqrt (z.real*z.real + z.imag*z.imag)
The functions described in this section are primarily provided as a way to efficiently perform certain low-level manipulations on floating point numbers that are represented internally using a binary radix; see section Floating Point Representation Concepts. These functions are required to have equivalent behavior even if the representation does not use a radix of 2, but of course they are unlikely to be particularly efficient in those cases.
All these functions are declared in `math.h'.
frexp function is used to split the number value
into a normalized fraction and an exponent.
If the argument value is not zero, the return value is value
times a power of two, and is always in the range 1/2 (inclusive) to 1
(exclusive). The corresponding exponent is stored in
*exponent; the return value multiplied by 2 raised to this
exponent equals the original number value.
For example, frexp (12.8, &exponent) returns 0.8 and
stores 4 in exponent.
If value is zero, then the return value is zero and
zero is stored in *exponent.
frexp.)
For example, ldexp (0.8, 4) returns 12.8.
The following functions which come from BSD provide facilities
equivalent to those of ldexp and frexp:
scalb function is the BSD name for ldexp.
double. This is
the highest integer power of 2 contained in x. The sign of
x is ignored. For example, logb (3.5) is 1.0 and
logb (4.0) is 2.0.
When 2 raised to this power is divided into x, it gives a
quotient between 1 (inclusive) and 2 (exclusive).
If x is zero, the value is minus infinity (if the machine supports such a value), or else a very small number. If x is infinity, the value is infinity.
The value returned by logb is one less than the value that
frexp would store into *exponent.
copysign function returns a value whose absolute value is the
same as that of value, and whose sign matches that of sign.
This is a BSD function.
The functions listed here perform operations such as rounding, truncation, and remainder in division of floating point numbers. Some of these functions convert floating point numbers to integer values. They are all declared in `math.h'.
You can also convert floating-point numbers to integers simply by
casting them to int. This discards the fractional part,
effectively rounding towards zero. However, this only works if the
result can actually be represented as an int---for very large
numbers, this is impossible. The functions listed here return the
result as a double instead to get around this problem.
ceil function rounds x upwards to the nearest integer,
returning that value as a double. Thus, ceil (1.5)
is 2.0.
ceil function rounds x downwards to the nearest
integer, returning that value as a double. Thus, floor
(1.5) is 1.0 and floor (-1.5) is -2.0.
-1 and 1, exclusive). Their sum
equals value. Each of the parts has the same sign as value,
so the rounding of the integer part is towards zero.
modf stores the integer part in *integer-part, and
returns the fractional part. For example, modf (2.5, &intpart)
returns 0.5 and stores 2.0 into intpart.
numerator - n * denominator, where n
is the quotient of numerator divided by denominator, rounded
towards zero to an integer. Thus, fmod (6.5, 2.3) returns
1.9, which is 6.5 minus 4.6.
The result has the same sign as the numerator and has magnitude less than the magnitude of the denominator.
If denominator is zero, fmod fails and sets errno to
EDOM.
drem is like fmod except that it rounds the
internal quotient n to the nearest integer instead of towards zero
to an integer. For example, drem (6.5, 2.3) returns -0.4,
which is 6.5 minus 6.9.
The absolute value of the result is less than or equal to half the
absolute value of the denominator. The difference between
fmod (numerator, denominator) and drem
(numerator, denominator) is always either
denominator, minus denominator, or zero.
If denominator is zero, drem fails and sets errno to
EDOM.
This section describes functions for performing integer division. These
functions are redundant in the GNU C library, since in GNU C the `/'
operator always rounds towards zero. But in other C implementations,
`/' may round differently with negative arguments. div and
ldiv are useful because they specify how to round the quotient:
towards zero. The remainder has the same sign as the numerator.
These functions are specified to return a result r such that the value
r.quot*denominator + r.rem equals
numerator.
To use these facilities, you should include the header file `stdlib.h' in your program.
div
function. It has the following members:
int quot
int rem
div computes the quotient and remainder from
the division of numerator by denominator, returning the
result in a structure of type div_t.
If the result cannot be represented (as in a division by zero), the behavior is undefined.
Here is an example, albeit not a very useful one.
div_t result; result = div (20, -6);
Now result.quot is -3 and result.rem is 2.
ldiv
function. It has the following members:
long int quot
long int rem
(This is identical to div_t except that the components are of
type long int rather than int.)
ldiv function is similar to div, except that the
arguments are of type long int and the result is returned as a
structure of type ldiv.
This section describes functions for "reading" integer and
floating-point numbers from a string. It may be more convenient in some
cases to use sscanf or one of the related functions; see
section Formatted Input. But often you can make a program more robust by
finding the tokens in the string by hand, then converting the numbers
one by one.
These functions are declared in `stdlib.h'.
strtol ("string-to-long") function converts the initial
part of string to a signed integer, which is returned as a value
of type long int.
This function attempts to decompose string as follows:
isspace function
(see section Classification of Characters). These are discarded.
2 and 35.
If base is 16, the digits may optionally be preceded by
`0x' or `0X'. If base has no legal value the value returned
is 0l and the global variable errno is set to EINVAL.
strtol stores a pointer to this tail in
*tailptr.
If the string is empty, contains only whitespace, or does not contain an
initial substring that has the expected syntax for an integer in the
specified base, no conversion is performed. In this case,
strtol returns a value of zero and the value stored in
*tailptr is the value of string.
In a locale other than the standard "C" locale, this function
may recognize additional implementation-dependent syntax.
If the string has valid syntax for an integer but the value is not
representable because of overflow, strtol returns either
LONG_MAX or LONG_MIN (see section Range of an Integer Type), as
appropriate for the sign of the value. It also sets errno
to ERANGE to indicate there was overflow.
Because the value 0l is a correct result for strtol the
user who is interested in handling errors should set the global variable
errno to 0 before calling this function, so that the program
can later test whether an error occurred.
There is an example at the end of this section.
strtoul ("string-to-unsigned-long") function is like
strtol except it deals with unsigned numbers, and returns its
value with type unsigned long int. No `+' or `-' sign
may appear before the number, but the syntax is otherwise the same as
described above for strtol. The value returned in case of
overflow is ULONG_MAX (see section Range of an Integer Type).
Like strtol this function sets errno and returns the value
0ul in case the value for base is not in the legal range.
For strtoul this can happen in another situation. In case the
number to be converted is negative strtoul also sets errno
to EINVAL and returns 0ul.
strtoq ("string-to-quad-word") function is like
strtol except that is deals with extra long numbers and it
returns its value with type long long int.
If the string has valid syntax for an integer but the value is not
representable because of overflow, strtoq returns either
LONG_LONG_MAX or LONG_LONG_MIN (see section Range of an Integer Type), as
appropriate for the sign of the value. It also sets errno to
ERANGE to indicate there was overflow.
strtoll is only an commonly used other name for the strtoq
function. Everything said for strtoq applies to strtoll
as well.
strtouq ("string-to-unsigned-quad-word") function is like
strtoul except that is deals with extra long numbers and it
returns its value with type unsigned long long int. The value
returned in case of overflow is ULONG_LONG_MAX (see section Range of an Integer Type).
strtoull is only an commonly used other name for the strtouq
function. Everything said for strtouq applies to strtoull
as well.
strtol function with a base
argument of 10, except that it need not detect overflow errors.
The atol function is provided mostly for compatibility with
existing code; using strtol is more robust.
atol, except that it returns an int
value rather than long int. The atoi function is also
considered obsolete; use strtol instead.
The POSIX locales contain some information about how to format numbers (see section Generic Numeric Formatting Parameters). This mainly deals with representing numbers for better readability for humans. The functions present so far in this section cannot handle numbers in this form.
If this functionality is needed in a program one can use the functions
from the scanf family which know about the flag `'' for
parsing numeric input (see section Numeric Input Conversions). Sometimes it
is more desirable to have finer control.
In these situation one could use the function
__strtoXXX_internal. XXX here stands for any of the
above forms. All numeric conversion functions (including the functions
to process floating-point numbers) have such a counterpart. The
difference to the normal form is the extra argument at the end of the
parameter list. If this value has an non-zero value the handling of
number grouping is enabled. The advantage of using these functions is
that the tailptr parameters allow to determine which part of the
input is processed. The scanf functions don't provide this
information. The drawback of using these functions is that they are not
portable. They only exist in the GNU C library.
Here is a function which parses a string as a sequence of integers and returns the sum of them:
int
sum_ints_from_string (char *string)
{
int sum = 0;
while (1) {
char *tail;
int next;
/* Skip whitespace by hand, to detect the end. */
while (isspace (*string)) string++;
if (*string == 0)
break;
/* There is more nonwhitespace, */
/* so it ought to be another number. */
errno = 0;
/* Parse it. */
next = strtol (string, &tail, 0);
/* Add it in, if not overflow. */
if (errno)
printf ("Overflow\n");
else
sum += next;
/* Advance past it. */
string = tail;
}
return sum;
}
These functions are declared in `stdlib.h'.
strtod ("string-to-double") function converts the initial
part of string to a floating-point number, which is returned as a
value of type double.
This function attempts to decompose string as follows:
isspace function
(see section Classification of Characters). These are discarded.
*tailptr.
If the string is empty, contains only whitespace, or does not contain an
initial substring that has the expected syntax for a floating-point
number, no conversion is performed. In this case, strtod returns
a value of zero and the value returned in *tailptr is the
value of string.
In a locale other than the standard "C" or "POSIX" locales,
this function may recognize additional locale-dependent syntax.
If the string has valid syntax for a floating-point number but the value
is not representable because of overflow, strtod returns either
positive or negative HUGE_VAL (see section Mathematics), depending on
the sign of the value. Similarly, if the value is not representable
because of underflow, strtod returns zero. It also sets errno
to ERANGE if there was overflow or underflow.
Since the value zero which is returned in the error case is also a valid
result the user should set the global variable errno to zero
before calling this function. So one can test for failures after the
call since all failures set errno to a non-zero value.
strtod function but it returns a
float value instead of a double value. If the precision
of a float value is sufficient this function should be used since
it is much faster than strtod on some architectures. The reasons
are obvious: IEEE 754 defines float to have a mantissa of 23
bits while double has 53 bits and every additional bit of
precision can require additional computation.
If the string has valid syntax for a floating-point number but the value
is not representable because of overflow, strtof returns either
positive or negative HUGE_VALf (see section Mathematics), depending on
the sign of the value.
This function is a GNU extension.
strtod function but it returns a
long double value instead of a double value. It should be
used when high precision is needed. On systems which define a long
double type (i.e., on which it is not the same as double)
running this function might take significantly more time since more bits
of precision are required.
If the string has valid syntax for a floating-point number but the value
is not representable because of overflow, strtold returns either
positive or negative HUGE_VALl (see section Mathematics), depending on
the sign of the value.
This function is a GNU extension.
As for the integer parsing functions there are additional functions which will handle numbers represented using the grouping scheme of the current locale (see section Parsing of Integers).
strtod function, except that it
need not detect overflow and underflow errors. The atof function
is provided mostly for compatibility with existing code; using
strtod is more robust.
This chapter describes functions for searching and sorting arrays of arbitrary objects. You pass the appropriate comparison function to be applied as an argument, along with the size of the objects in the array and the total number of elements.
In order to use the sorted array library functions, you have to describe how to compare the elements of the array.
To do this, you supply a comparison function to compare two elements of
the array. The library will call this function, passing as arguments
pointers to two array elements to be compared. Your comparison function
should return a value the way strcmp (see section String/Array Comparison) does: negative if the first argument is "less" than the
second, zero if they are "equal", and positive if the first argument
is "greater".
Here is an example of a comparison function which works with an array of
numbers of type double:
int
compare_doubles (const double *a, const double *b)
{
return (int) (*a - *b);
}
The header file `stdlib.h' defines a name for the data type of comparison functions. This type is a GNU extension.
int comparison_fn_t (const void *, const void *);
To search a sorted array for an element matching the key, use the
bsearch function. The prototype for this function is in
the header file `stdlib.h'.
bsearch function searches the sorted array array for an object
that is equivalent to key. The array contains count elements,
each of which is of size size bytes.
The compare function is used to perform the comparison. This function is called with two pointer arguments and should return an integer less than, equal to, or greater than zero corresponding to whether its first argument is considered less than, equal to, or greater than its second argument. The elements of the array must already be sorted in ascending order according to this comparison function.
The return value is a pointer to the matching array element, or a null pointer if no match is found. If the array contains more than one element that matches, the one that is returned is unspecified.
This function derives its name from the fact that it is implemented using the binary search algorithm.
To sort an array using an arbitrary comparison function, use the
qsort function. The prototype for this function is in
`stdlib.h'.
The compare function is used to perform the comparison on the array elements. This function is called with two pointer arguments and should return an integer less than, equal to, or greater than zero corresponding to whether its first argument is considered less than, equal to, or greater than its second argument.
Warning: If two objects compare as equal, their order after sorting is unpredictable. That is to say, the sorting is not stable. This can make a difference when the comparison considers only part of the elements. Two elements with the same sort key may differ in other respects.
If you want the effect of a stable sort, you can get this result by writing the comparison function so that, lacking other reason distinguish between two elements, it compares them by their addresses. Note that doing this may make the sorting algorithm less efficient, so do it only if necessary.
Here is a simple example of sorting an array of doubles in numerical order, using the comparison function defined above (see section Defining the Comparison Function):
{
double *array;
int size;
...
qsort (array, size, sizeof (double), compare_doubles);
}
The qsort function derives its name from the fact that it was
originally implemented using the "quick sort" algorithm.
Here is an example showing the use of qsort and bsearch
with an array of structures. The objects in the array are sorted
by comparing their name fields with the strcmp function.
Then, we can look up individual objects based on their names.
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/* Define an array of critters to sort. */
struct critter
{
const char *name;
const char *species;
};
struct critter muppets[] =
{
{"Kermit", "frog"},
{"Piggy", "pig"},
{"Gonzo", "whatever"},
{"Fozzie", "bear"},
{"Sam", "eagle"},
{"Robin", "frog"},
{"Animal", "animal"},
{"Camilla", "chicken"},
{"Sweetums", "monster"},
{"Dr. Strangepork", "pig"},
{"Link Hogthrob", "pig"},
{"Zoot", "human"},
{"Dr. Bunsen Honeydew", "human"},
{"Beaker", "human"},
{"Swedish Chef", "human"}
};
int count = sizeof (muppets) / sizeof (struct critter);
/* This is the comparison function used for sorting and searching. */
int
critter_cmp (const struct critter *c1, const struct critter *c2)
{
return strcmp (c1->name, c2->name);
}
/* Print information about a critter. */
void
print_critter (const struct critter *c)
{
printf ("%s, the %s\n", c->name, c->species);
}
/* Do the lookup into the sorted array. */
void
find_critter (const char *name)
{
struct critter target, *result;
target.name = name;
result = bsearch (&target, muppets, count, sizeof (struct critter),
critter_cmp);
if (result)
print_critter (result);
else
printf ("Couldn't find %s.\n", name);
}
/* Main program. */
int
main (void)
{
int i;
for (i = 0; i < count; i++)
print_critter (&muppets[i]);
printf ("\n");
qsort (muppets, count, sizeof (struct critter), critter_cmp);
for (i = 0; i < count; i++)
print_critter (&muppets[i]);
printf ("\n");
find_critter ("Kermit");
find_critter ("Gonzo");
find_critter ("Janice");
return 0;
}
The output from this program looks like:
Kermit, the frog Piggy, the pig Gonzo, the whatever Fozzie, the bear Sam, the eagle Robin, the frog Animal, the animal Camilla, the chicken Sweetums, the monster Dr. Strangepork, the pig Link Hogthrob, the pig Zoot, the human Dr. Bunsen Honeydew, the human Beaker, the human Swedish Chef, the human Animal, the animal Beaker, the human Camilla, the chicken Dr. Bunsen Honeydew, the human Dr. Strangepork, the pig Fozzie, the bear Gonzo, the whatever Kermit, the frog Link Hogthrob, the pig Piggy, the pig Robin, the frog Sam, the eagle Swedish Chef, the human Sweetums, the monster Zoot, the human Kermit, the frog Gonzo, the whatever Couldn't find Janice.
The GNU C Library provides pattern matching facilities for two kinds of patterns: regular expressions and file-name wildcards. The library also provides a facility for expanding variable and command references and parsing text into words in the way the shell does.
This section describes how to match a wildcard pattern against a particular string. The result is a yes or no answer: does the string fit the pattern or not. The symbols described here are all declared in `fnmatch.h'.
0 if they do match; otherwise, it
returns the nonzero value FNM_NOMATCH. The arguments
pattern and string are both strings.
The argument flags is a combination of flag bits that alter the details of matching. See below for a list of the defined flags.
In the GNU C Library, fnmatch cannot experience an "error"---it
always returns an answer for whether the match succeeds. However, other
implementations of fnmatch might sometimes report "errors".
They would do so by returning nonzero values that are not equal to
FNM_NOMATCH.
These are the available flags for the flags argument:
FNM_FILE_NAME
FNM_PATHNAME
FNM_FILE_NAME; it comes from POSIX.2. We
don't recommend this name because we don't use the term "pathname" for
file names.
FNM_PERIOD
FNM_PERIOD and FNM_FILE_NAME, then the
special treatment applies to `.' following `/' as well as to
`.' at the beginning of string. (The shell uses the
FNM_PERIOD and FNM_FILE_NAME flags together for matching
file names.)
FNM_NOESCAPE
FNM_NOESCAPE, then `\' is an ordinary character.
FNM_LEADING_DIR
FNM_CASEFOLD
The archetypal use of wildcards is for matching against the files in a directory, and making a list of all the matches. This is called globbing.
You could do this using fnmatch, by reading the directory entries
one by one and testing each one with fnmatch. But that would be
slow (and complex, since you would have to handle subdirectories by
hand).
The library provides a function glob to make this particular use
of wildcards convenient. glob and the other symbols in this
section are declared in `glob.h'.
glob
The result of globbing is a vector of file names (strings). To return
this vector, glob uses a special data type, glob_t, which
is a structure. You pass glob the address of the structure, and
it fills in the structure's fields to tell you about the results.
gl_pathc
gl_pathv
char **.
gl_offs
gl_pathv field. Unlike the other fields, this
is always an input to glob, rather than an output from it.
If you use a nonzero offset, then that many elements at the beginning of
the vector are left empty. (The glob function fills them with
null pointers.)
The gl_offs field is meaningful only if you use the
GLOB_DOOFFS flag. Otherwise, the offset is always zero
regardless of what is in this field, and the first real element comes at
the beginning of the vector.
glob does globbing using the pattern pattern
in the current directory. It puts the result in a newly allocated
vector, and stores the size and address of this vector into
*vector-ptr. The argument flags is a combination of
bit flags; see section Flags for Globbing, for details of the flags.
The result of globbing is a sequence of file names. The function
glob allocates a string for each resulting word, then
allocates a vector of type char ** to store the addresses of
these strings. The last element of the vector is a null pointer.
This vector is called the word vector.
To return this vector, glob stores both its address and its
length (number of elements, not counting the terminating null pointer)
into *vector-ptr.
Normally, glob sorts the file names alphabetically before
returning them. You can turn this off with the flag GLOB_NOSORT
if you want to get the information as fast as possible. Usually it's
a good idea to let glob sort them--if you process the files in
alphabetical order, the users will have a feel for the rate of progress
that your application is making.
If glob succeeds, it returns 0. Otherwise, it returns one
of these error codes:
GLOB_ABORTED
GLOB_ERR or your specified errfunc returned a nonzero
value.
See below
for an explanation of the GLOB_ERR flag and errfunc.
GLOB_NOMATCH
GLOB_NOCHECK flag, then you never get this error code, because
that flag tells glob to pretend that the pattern matched
at least one file.
GLOB_NOSPACE
In the event of an error, glob stores information in
*vector-ptr about all the matches it has found so far.
This section describes the flags that you can specify in the
flags argument to glob. Choose the flags you want,
and combine them with the C bitwise OR operator |.
GLOB_APPEND
glob. This way you can effectively expand
several words as if they were concatenated with spaces between them.
In order for appending to work, you must not modify the contents of the
word vector structure between calls to glob. And, if you set
GLOB_DOOFFS in the first call to glob, you must also
set it when you append to the results.
Note that the pointer stored in gl_pathv may no longer be valid
after you call glob the second time, because glob might
have relocated the vector. So always fetch gl_pathv from the
glob_t structure after each glob call; never save
the pointer across calls.
GLOB_DOOFFS
gl_offs field says how many slots to leave.
The blank slots contain null pointers.
GLOB_ERR
glob tries its best to keep
on going despite any errors, reading whatever directories it can.
You can exercise even more control than this by specifying an
error-handler function errfunc when you call glob. If
errfunc is not a null pointer, then glob doesn't give up
right away when it can't read a directory; instead, it calls
errfunc with two arguments, like this:
(*errfunc) (filename, error-code)The argument filename is the name of the directory that
glob couldn't open or couldn't read, and error-code is the
errno value that was reported to glob.
If the error handler function returns nonzero, then glob gives up
right away. Otherwise, it continues.
GLOB_MARK
GLOB_NOCHECK
glob returns that there were no
matches.)
GLOB_NOSORT
GLOB_NOESCAPE
GLOB_NOESCAPE, then `\' is an ordinary character.
glob does its work by calling the function fnmatch
repeatedly. It handles the flag GLOB_NOESCAPE by turning on the
FNM_NOESCAPE flag in calls to fnmatch.
The GNU C library supports two interfaces for matching regular expressions. One is the standard POSIX.2 interface, and the other is what the GNU system has had for many years.
Both interfaces are declared in the header file `regex.h'.
If you define _POSIX_C_SOURCE, then only the POSIX.2
functions, structures, and constants are declared.
Before you can actually match a regular expression, you must compile it. This is not true compilation--it produces a special data structure, not machine instructions. But it is like ordinary compilation in that its purpose is to enable you to "execute" the pattern fast. (See section Matching a Compiled POSIX Regular Expression, for how to use the compiled regular expression for matching.)
There is a special data type for compiled regular expressions:
re_nsub
There are several other fields, but we don't describe them here, because only the functions in the library should use them.
After you create a regex_t object, you can compile a regular
expression into it by calling regcomp.
regcomp "compiles" a regular expression into a
data structure that you can use with regexec to match against a
string. The compiled regular expression format is designed for
efficient matching. regcomp stores it into *compiled.
It's up to you to allocate an object of type regex_t and pass its
address to regcomp.
The argument cflags lets you specify various options that control the syntax and semantics of regular expressions. See section Flags for POSIX Regular Expressions.
If you use the flag REG_NOSUB, then regcomp omits from
the compiled regular expression the information necessary to record
how subexpressions actually match. In this case, you might as well
pass 0 for the matchptr and nmatch arguments when
you call regexec.
If you don't use REG_NOSUB, then the compiled regular expression
does have the capacity to record how subexpressions match. Also,
regcomp tells you how many subexpressions pattern has, by
storing the number in compiled->re_nsub. You can use that
value to decide how long an array to allocate to hold information about
subexpression matches.
regcomp returns 0 if it succeeds in compiling the regular
expression; otherwise, it returns a nonzero error code (see the table
below). You can use regerror to produce an error message string
describing the reason for a nonzero value; see section POSIX Regexp Matching Cleanup.
Here are the possible nonzero values that regcomp can return:
REG_BADBR
REG_BADPAT
REG_BADRPT
REG_ECOLLATE
REG_ECTYPE
REG_EESCAPE
REG_ESUBREG
REG_EBRACK
REG_EPAREN
REG_EBRACE
REG_ERANGE
REG_ESPACE
regcomp ran out of memory.
These are the bit flags that you can use in the cflags operand when
compiling a regular expression with regcomp.
REG_EXTENDED
REG_ICASE
REG_NOSUB
REG_NEWLINE
Once you have compiled a regular expression, as described in section POSIX Regular Expression Compilation, you can match it against strings using
regexec. A match anywhere inside the string counts as success,
unless the regular expression contains anchor characters (`^' or
`$').
*compiled against string.
regexec returns 0 if the regular expression matches;
otherwise, it returns a nonzero value. See the table below for
what nonzero values mean. You can use regerror to produce an
error message string describing the reason for a nonzero value;
see section POSIX Regexp Matching Cleanup.
The argument eflags is a word of bit flags that enable various options.
If you want to get information about what part of string actually
matched the regular expression or its subexpressions, use the arguments
matchptr and nmatch. Otherwise, pass 0 for
nmatch, and NULL for matchptr. See section Match Results with Subexpressions.
You must match the regular expression with the same set of current locales that were in effect when you compiled the regular expression.
The function regexec accepts the following flags in the
eflags argument:
REG_NOTBOL
REG_NOTEOL
Here are the possible nonzero values that regexec can return:
REG_NOMATCH
REG_ESPACE
regexec ran out of memory.
When regexec matches parenthetical subexpressions of
pattern, it records which parts of string they match. It
returns that information by storing the offsets into an array whose
elements are structures of type regmatch_t. The first element of
the array (index 0) records the part of the string that matched
the entire regular expression. Each other element of the array records
the beginning and end of the part that matched a single parenthetical
subexpression.
regexec. It contains two structure fields, as follows:
rm_so
rm_eo
regoff_t is an alias for another signed integer type.
The fields of regmatch_t have type regoff_t.
The regmatch_t elements correspond to subexpressions
positionally; the first element (index 1) records where the first
subexpression matched, the second element records the second
subexpression, and so on. The order of the subexpressions is the order
in which they begin.
When you call regexec, you specify how long the matchptr
array is, with the nmatch argument. This tells regexec how
many elements to store. If the actual regular expression has more than
nmatch subexpressions, then you won't get offset information about
the rest of them. But this doesn't alter whether the pattern matches a
particular string or not.
If you don't want regexec to return any information about where
the subexpressions matched, you can either supply 0 for
nmatch, or use the flag REG_NOSUB when you compile the
pattern with regcomp.
Sometimes a subexpression matches a substring of no characters. This
happens when `f\(o*\)' matches the string `fum'. (It really
matches just the `f'.) In this case, both of the offsets identify
the point in the string where the null substring was found. In this
example, the offsets are both 1.
Sometimes the entire regular expression can match without using some of
its subexpressions at all--for example, when `ba\(na\)*' matches the
string `ba', the parenthetical subexpression is not used. When
this happens, regexec stores -1 in both fields of the
element for that subexpression.
Sometimes matching the entire regular expression can match a particular
subexpression more than once--for example, when `ba\(na\)*'
matches the string `bananana', the parenthetical subexpression
matches three times. When this happens, regexec usually stores
the offsets of the last part of the string that matched the
subexpression. In the case of `bananana', these offsets are
6 and 8.
But the last match is not always the one that is chosen. It's more
accurate to say that the last opportunity to match is the one
that takes precedence. What this means is that when one subexpression
appears within another, then the results reported for the inner
subexpression reflect whatever happened on the last match of the outer
subexpression. For an example, consider `\(ba\(na\)*s \)*' matching
the string `bananas bas '. The last time the inner expression
actually matches is near the end of the first word. But it is
considered again in the second word, and fails to match there.
regexec reports nonuse of the "na" subexpression.
Another place where this rule applies is when the regular expression
`\(ba\(na\)*s \|nefer\(ti\)* \)*' matches `bananas nefertiti'.
The "na" subexpression does match in the first word, but it doesn't
match in the second word because the other alternative is used there.
Once again, the second repetition of the outer subexpression overrides
the first, and within that second repetition, the "na" subexpression
is not used. So regexec reports nonuse of the "na"
subexpression.
When you are finished using a compiled regular expression, you can
free the storage it uses by calling regfree.
regfree frees all the storage that *compiled
points to. This includes various internal fields of the regex_t
structure that aren't documented in this manual.
regfree does not free the object *compiled itself.
You should always free the space in a regex_t structure with
regfree before using the structure to compile another regular
expression.
When regcomp or regexec reports an error, you can use
the function regerror to turn it into an error message string.
regcomp or
regexec was working with when it got the error. Alternatively,
you can supply NULL for compiled; you will still get a
meaningful error message, but it might not be as detailed.
If the error message can't fit in length bytes (including a
terminating null character), then regerror truncates it.
The string that regerror stores is always null-terminated
even if it has been truncated.
The return value of regerror is the minimum length needed to
store the entire error message. If this is less than length, then
the error message was not truncated, and you can use it. Otherwise, you
should call regerror again with a larger buffer.
Here is a function which uses regerror, but always dynamically
allocates a buffer for the error message:
char *get_regerror (int errcode, regex_t *compiled)
{
size_t length = regerror (errcode, compiled, NULL, 0);
char *buffer = xmalloc (length);
(void) regerror (errcode, compiled, buffer, length);
return buffer;
}
Word expansion means the process of splitting a string into words and substituting for variables, commands, and wildcards just as the shell does.
For example, when you write `ls -l foo.c', this string is split into three separate words---`ls', `-l' and `foo.c'. This is the most basic function of word expansion.
When you write `ls *.c', this can become many words, because the word `*.c' can be replaced with any number of file names. This is called wildcard expansion, and it is also a part of word expansion.
When you use `echo $PATH' to print your path, you are taking advantage of variable substitution, which is also part of word expansion.
Ordinary programs can perform word expansion just like the shell by
calling the library function wordexp.
When word expansion is applied to a sequence of words, it performs the following transformations in the order shown here:
For the details of these transformations, and how to write the constructs that use them, see The BASH Manual (to appear).
wordexpAll the functions, constants and data types for word expansion are declared in the header file `wordexp.h'.
Word expansion produces a vector of words (strings). To return this
vector, wordexp uses a special data type, wordexp_t, which
is a structure. You pass wordexp the address of the structure,
and it fills in the structure's fields to tell you about the results.
we_wordc
we_wordv
char **.
we_offs
we_wordv field. Unlike the other fields, this
is always an input to wordexp, rather than an output from it.
If you use a nonzero offset, then that many elements at the beginning of
the vector are left empty. (The wordexp function fills them with
null pointers.)
The we_offs field is meaningful only if you use the
WRDE_DOOFFS flag. Otherwise, the offset is always zero
regardless of what is in this field, and the first real element comes at
the beginning of the vector.
*word-vector-ptr. The argument flags is a
combination of bit flags; see section Flags for Word Expansion, for details of
the flags.
You shouldn't use any of the characters `|&;<>' in the string
words unless they are quoted; likewise for newline. If you use
these characters unquoted, you will get the WRDE_BADCHAR error
code. Don't use parentheses or braces unless they are quoted or part of
a word expansion construct. If you use quotation characters `'"`',
they should come in pairs that balance.
The results of word expansion are a sequence of words. The function
wordexp allocates a string for each resulting word, then
allocates a vector of type char ** to store the addresses of
these strings. The last element of the vector is a null pointer.
This vector is called the word vector.
To return this vector, wordexp stores both its address and its
length (number of elements, not counting the terminating null pointer)
into *word-vector-ptr.
If wordexp succeeds, it returns 0. Otherwise, it returns one
of these error codes:
WRDE_BADCHAR
WRDE_BADVAL
WRDE_UNDEF to forbid such references.
WRDE_CMDSUB
WRDE_NOCMD to forbid command substitution.
WRDE_NOSPACE
wordexp can store part of the results--as much as it could
allocate room for.
WRDE_SYNTAX
*word-vector-ptr points to. This does not free the
structure *word-vector-ptr itself--only the other
data it points to.
This section describes the flags that you can specify in the
flags argument to wordexp. Choose the flags you want,
and combine them with the C operator |.
WRDE_APPEND
wordexp. This way you can effectively expand
several words as if they were concatenated with spaces between them.
In order for appending to work, you must not modify the contents of the
word vector structure between calls to wordexp. And, if you set
WRDE_DOOFFS in the first call to wordexp, you must also
set it when you append to the results.
WRDE_DOOFFS
we_offs field says how many slots to leave.
The blank slots contain null pointers.
WRDE_NOCMD
WRDE_REUSE
wordexp.
Instead of allocating a new vector of words, this call to wordexp
will use the vector that already exists (making it larger if necessary).
Note that the vector may move, so it is not safe to save an old pointer
and use it again after calling wordexp. You must fetch
we_pathv anew after each call.
WRDE_SHOWERR
wordexp gives these
commands a standard error stream that discards all output.
WRDE_UNDEF
wordexp Example
Here is an example of using wordexp to expand several strings
and use the results to run a shell command. It also shows the use of
WRDE_APPEND to concatenate the expansions and of wordfree
to free the space allocated by wordexp.
int
expand_and_execute (const char *program, const char *options)
{
wordexp_t result;
pid_t pid
int status, i;
/* Expand the string for the program to run. */
switch (wordexp (program, &result, 0))
{
case 0: /* Successful. */
break;
case WRDE_NOSPACE:
/* If the error was WRDE_NOSPACE,
then perhaps part of the result was allocated. */
wordfree (&result);
default: /* Some other error. */
return -1;
}
/* Expand the strings specified for the arguments. */
for (i = 0; args[i]; i++)
{
if (wordexp (options, &result, WRDE_APPEND))
{
wordfree (&result);
return -1;
}
}
pid = fork ();
if (pid == 0)
{
/* This is the child process. Execute the command. */
execv (result.we_wordv[0], result.we_wordv);
exit (EXIT_FAILURE);
}
else if (pid < 0)
/* The fork failed. Report failure. */
status = -1;
else
/* This is the parent process. Wait for the child to complete. */
if (waitpid (pid, &status, 0) != pid)
status = -1;
wordfree (&result);
return status;
}
In practice, since wordexp is executed by running a subshell, it
would be faster to do this by concatenating the strings with spaces
between them and running that as a shell command using `sh -c'.
This chapter describes functions for manipulating dates and times, including functions for determining what the current time is and conversion between different time representations.
The time functions fall into three main categories:
If you're trying to optimize your program or measure its efficiency, it's
very useful to be able to know how much processor time or CPU
time it has used at any given point. Processor time is different from
actual wall clock time because it doesn't include any time spent waiting
for I/O or when some other process is running. Processor time is
represented by the data type clock_t, and is given as a number of
clock ticks relative to an arbitrary base time marking the beginning
of a single program invocation.
To get the elapsed CPU time used by a process, you can use the
clock function. This facility is declared in the header file
`time.h'.
In typical usage, you call the clock function at the beginning and
end of the interval you want to time, subtract the values, and then divide
by CLOCKS_PER_SEC (the number of clock ticks per second), like this:
#include <time.h> clock_t start, end; double elapsed; start = clock(); ... /* Do the work. */ end = clock(); elapsed = ((double) (end - start)) / CLOCKS_PER_SEC;
Different computers and operating systems vary wildly in how they keep track of processor time. It's common for the internal processor clock to have a resolution somewhere between hundredths and millionths of a second.
In the GNU system, clock_t is equivalent to long int and
CLOCKS_PER_SEC is an integer value. But in other systems, both
clock_t and the type of the macro CLOCKS_PER_SEC can be
either integer or floating-point types. Casting processor time values
to double, as in the example above, makes sure that operations
such as arithmetic and printing work properly and consistently no matter
what the underlying representation is.
clock function.
CLOCKS_PER_SEC.
clock function.
Values of type clock_t are in units of clock ticks.
clock returns the
value (clock_t)(-1).
The times function returns more detailed information about
elapsed processor time in a struct tms object. You should
include the header file `sys/times.h' to use this facility.
tms structure is used to return information about process
times. It contains at least the following members:
clock_t tms_utime
clock_t tms_stime
clock_t tms_cutime
tms_utime values and the tms_cutime
values of all terminated child processes of the calling process, whose
status has been reported to the parent process by wait or
waitpid; see section Process Completion. In other words, it
represents the total CPU time used in executing the instructions of all
the terminated child processes of the calling process, excluding child
processes which have not yet been reported by wait or
waitpid.
clock_t tms_cstime
tms_cutime, but represents the total CPU time
used by the system on behalf of all the terminated child processes of the
calling process.
All of the times are given in clock ticks. These are absolute values; in a newly created process, they are all zero. See section Creating a Process.
times function stores the processor time information for
the calling process in buffer.
The return value is the same as the value of clock(): the elapsed
real time relative to an arbitrary base. The base is a constant within a
particular process, and typically represents the time since system
start-up. A value of (clock_t)(-1) is returned to indicate failure.
Portability Note: The clock function described in
section Basic CPU Time Inquiry, is specified by the ISO C standard. The
times function is a feature of POSIX.1. In the GNU system, the
value returned by the clock function is equivalent to the sum of
the tms_utime and tms_stime fields returned by
times.
This section describes facilities for keeping track of dates and times according to the Gregorian calendar.
There are three representations for date and time information:
time_t data type) is a compact
representation, typically giving the number of seconds elapsed since
some implementation-specific base time.
struct
timeval data type) that includes fractions of a second. Use this time
representation instead of ordinary calendar time when you need greater
precision.
struct
tm data type) represents the date and time as a set of components
specifying the year, month, and so on, for a specific time zone.
This time representation is usually used in conjunction with formatting
date and time values.
This section describes the time_t data type for representing
calendar time, and the functions which operate on calendar time objects.
These facilities are declared in the header file `time.h'.
TZ to certain values (see section Specifying the Time Zone with TZ).
In the GNU C library, time_t is equivalent to long int.
In other systems, time_t might be either an integer or
floating-point type.
difftime function returns the number of seconds elapsed
between time time1 and time time0, as a value of type
double. The difference ignores leap seconds unless leap
second support is enabled.
In the GNU system, you can simply subtract time_t values. But on
other systems, the time_t data type might use some other encoding
where subtraction doesn't work directly.
time function returns the current time as a value of type
time_t. If the argument result is not a null pointer, the
time value is also stored in *result. If the calendar
time is not available, the value (time_t)(-1) is returned.
The time_t data type used to represent calendar times has a
resolution of only one second. Some applications need more precision.
So, the GNU C library also contains functions which are capable of representing calendar times to a higher resolution than one second. The functions and the associated data types described in this section are declared in `sys/time.h'.
struct timeval structure represents a calendar time. It
has the following members:
long int tv_sec
time_t value.
long int tv_usec
tv_sec member is the number of seconds in the interval, and
tv_usec is the number of additional microseconds.
struct timezone structure is used to hold minimal information
about the local time zone. It has the following members:
int tz_minuteswest
int tz_dsttime
The struct timezone type is obsolete and should never be used.
Instead, use the facilities described in section Functions and Variables for Time Zones.
It is often necessary to subtract two values of type struct
timeval. Here is the best way to do this. It works even on some
peculiar operating systems where the tv_sec member has an
unsigned type.
/* Subtract the `struct timeval' values X and Y,
storing the result in RESULT.
Return 1 if the difference is negative, otherwise 0. */
int
timeval_subtract (result, x, y)
struct timeval *result, *x, *y;
{
/* Perform the carry for the later subtraction by updating y. */
if (x->tv_usec < y->tv_usec) {
int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
y->tv_usec -= 1000000 * nsec;
y->tv_sec += nsec;
}
if (x->tv_usec - y->tv_usec > 1000000) {
int nsec = (y->tv_usec - x->tv_usec) / 1000000;
y->tv_usec += 1000000 * nsec;
y->tv_sec -= nsec;
}
/* Compute the time remaining to wait.
tv_usec is certainly positive. */
result->tv_sec = x->tv_sec - y->tv_sec;
result->tv_usec = x->tv_usec - y->tv_usec;
/* Return 1 if result is negative. */
return x->tv_sec < y->tv_sec;
}
gettimeofday function returns the current date and time in the
struct timeval structure indicated by tp. Information about the
time zone is returned in the structure pointed at tzp. If the tzp
argument is a null pointer, time zone information is ignored.
The return value is 0 on success and -1 on failure. The
following errno error condition is defined for this function:
ENOSYS
struct timezone to represent time zone
information; that is an obsolete feature of 4.3 BSD.
Instead, use the facilities described in section Functions and Variables for Time Zones.
settimeofday function sets the current date and time
according to the arguments. As for gettimeofday, time zone
information is ignored if tzp is a null pointer.
You must be a privileged user in order to use settimeofday.
The return value is 0 on success and -1 on failure. The
following errno error conditions are defined for this function:
EPERM
ENOSYS
The delta argument specifies a relative adjustment to be made to the current time. If negative, the system clock is slowed down for a while until it has lost this much time. If positive, the system clock is speeded up for a while.
If the olddelta argument is not a null pointer, the adjtime
function returns information about any previous time adjustment that
has not yet completed.
This function is typically used to synchronize the clocks of computers
in a local network. You must be a privileged user to use it.
The return value is 0 on success and -1 on failure. The
following errno error condition is defined for this function:
EPERM
Portability Note: The gettimeofday, settimeofday,
and adjtime functions are derived from BSD.
Calendar time is represented as a number of seconds. This is convenient for calculation, but has no resemblance to the way people normally represent dates and times. By contrast, broken-down time is a binary representation separated into year, month, day, and so on. Broken down time values are not useful for calculations, but they are useful for printing human readable time.
A broken-down time value is always relative to a choice of local time zone, and it also indicates which time zone was used.
The symbols in this section are declared in the header file `time.h'.
int tm_sec
0 through 59. (The actual upper limit is 60, to allow
for leap seconds if leap second support is available.)
int tm_min
0 through
59.
int tm_hour
0 through
23.
int tm_mday
1 through 31.
int tm_mon
0 through
11.
int tm_year
1900.
int tm_wday
0 through
6.
int tm_yday
0 through
365.
int tm_isdst
long int tm_gmtoff
-5*60*60.
The tm_gmtoff field is derived from BSD and is a GNU library
extension; it is not visible in a strict ISO C environment.
const char *tm_zone
tm_gmtoff, this field is a BSD and
GNU extension, and is not visible in a strict ISO C environment.
localtime function converts the calendar time pointed to by
time to broken-down time representation, expressed relative to the
user's specified time zone.
The return value is a pointer to a static broken-down time structure, which
might be overwritten by subsequent calls to ctime, gmtime,
or localtime. (But no other library function overwrites the contents
of this object.)
Calling localtime has one other effect: it sets the variable
tzname with information about the current time zone. See section Functions and Variables for Time Zones.
localtime, except that the broken-down
time is expressed as Coordinated Universal Time (UTC)---that is, as
Greenwich Mean Time (GMT)---rather than relative to the local time zone.
Recall that calendar times are always expressed in coordinated universal time.
mktime function is used to convert a broken-down time structure
to a calendar time representation. It also "normalizes" the contents of
the broken-down time structure, by filling in the day of week and day of
year based on the other date and time components.
The mktime function ignores the specified contents of the
tm_wday and tm_yday members of the broken-down time
structure. It uses the values of the other components to compute the
calendar time; it's permissible for these components to have
unnormalized values outside of their normal ranges. The last thing that
mktime does is adjust the components of the brokentime
structure (including the tm_wday and tm_yday).
If the specified broken-down time cannot be represented as a calendar time,
mktime returns a value of (time_t)(-1) and does not modify
the contents of brokentime.
Calling mktime also sets the variable tzname with
information about the current time zone. See section Functions and Variables for Time Zones.
The functions described in this section format time values as strings. These functions are declared in the header file `time.h'.
asctime function converts the broken-down time value that
brokentime points to into a string in a standard format:
"Tue May 21 13:46:22 1991\n"
The abbreviations for the days of week are: `Sun', `Mon', `Tue', `Wed', `Thu', `Fri', and `Sat'.
The abbreviations for the months are: `Jan', `Feb', `Mar', `Apr', `May', `Jun', `Jul', `Aug', `Sep', `Oct', `Nov', and `Dec'.
The return value points to a statically allocated string, which might be
overwritten by subsequent calls to asctime or ctime.
(But no other library function overwrites the contents of this
string.)
ctime function is similar to asctime, except that the
time value is specified as a time_t calendar time value rather
than in broken-down local time format. It is equivalent to
asctime (localtime (time))
ctime sets the variable tzname, because localtime
does so. See section Functions and Variables for Time Zones.
sprintf function (see section Formatted Input), but the conversion specifications that can appear in the format
template template are specialized for printing components of the date
and time brokentime according to the locale currently specified for
time conversion (see section Locales and Internationalization).
Ordinary characters appearing in the template are copied to the output string s; this can include multibyte character sequences. Conversion specifiers are introduced by a `%' character, followed by an optional flag which can be one of the following. These flags, which are GNU extensions, affect only the output of numbers:
_
-
0
^
The default action is to pad the number with zeros to keep it a constant width. Numbers that do not have a range indicated below are never padded, since there is no natural width for them.
Following the flag an optional specification of the width is possible. This is specified in decimal notation. If the natural size of the output is of the field has less than the specified number of characters, the result is written right adjusted and space padded to the given size.
An optional modifier can follow the optional flag and width specification. The modifiers, which are POSIX.2 extensions, are:
E
%c, %C, %x, %X,
%y and %Y format specifiers. In a Japanese locale, for
example, %Ex might yield a date format based on the Japanese
Emperors' reigns.
O
If the format supports the modifier but no alternate representation is available, it is ignored.
The conversion specifier ends with a format specifier taken from the following list. The whole `%' sequence is replaced in the output string as follows:
%a
%A
%b
%B
%c
%C
%d
01 through 31).
%D
%m/%d/%y.
This format is a POSIX.2 extension.
%e
%d, but padded with blank (range
1 through 31).
This format is a POSIX.2 extension.
%g
00 through 99). This has the same format and value
as %y, except that if the ISO week number (see %V) belongs
to the previous or next year, that year is used instead.
This format is a GNU extension.
%G
%Y, except that if the ISO week number (see
%V) belongs to the previous or next year, that year is used
instead.
This format is a GNU extension.
%h
%b.
This format is a POSIX.2 extension.
%H
00 through
23).
%I
01 through
12).
%j
001 through 366).
%k
%H, but
padded with blank (range 0 through 23).
This format is a GNU extension.
%l
%I, but
padded with blank (range 1 through 12).
This format is a GNU extension.
%m
01 through 12).
%M
00 through 59).
%n
%p
%P
%r
%R
%H:%M.
This format is a GNU extension.
%s
%S
00 through 60).
%t
%T
%H:%M:%S.
This format is a POSIX.2 extension.
%u
1 through
7), Monday being 1.
This format is a POSIX.2 extension.
%U
00
through 53), starting with the first Sunday as the first day of
the first week. Days preceding the first Sunday in the year are
considered to be in week 00.
%V
01
through 53). ISO weeks start with Monday and end with Sunday.
Week 01 of a year is the first week which has the majority of its
days in that year; this is equivalent to the week containing the year's
first Thursday, and it is also equivalent to the week containing January
4. Week 01 of a year can contain days from the previous year.
The week before week 01 of a year is the last week (52 or
53) of the previous year even if it contains days from the new
year.
This format is a POSIX.2 extension.
%w
0 through
6), Sunday being 0.
%W
00
through 53), starting with the first Monday as the first day of
the first week. All days preceding the first Monday in the year are
considered to be in week 00.
%x
%X
%y
00 through
99). This is equivalent to the year modulo 100.
%Y
1 are numbered 0, -1, and so on.
%z
-0600 or +0100), or nothing if no time zone is
determinable.
This format is a GNU extension.
%Z
%%
The size parameter can be used to specify the maximum number of
characters to be stored in the array s, including the terminating
null character. If the formatted time requires more than size
characters, the excess characters are discarded. The return value from
strftime is the number of characters placed in the array s,
not including the terminating null character. If the value equals
size, it means that the array s was too small; you should
repeat the call, providing a bigger array.
If s is a null pointer, strftime does not actually write
anything, but instead returns the number of characters it would have written.
According to POSIX.1 every call to strftime implies a call to
tzset. So the contents of the environment variable TZ
is examined before any output is produced.
For an example of strftime, see section Time Functions Example.
TZ
In POSIX systems, a user can specify the time zone by means of the
TZ environment variable. For information about how to set
environment variables, see section Environment Variables. The functions
for accessing the time zone are declared in `time.h'.
You should not normally need to set TZ. If the system is
configured properly, the default time zone will be correct. You might
set TZ if you are using a computer over the network from a
different time zone, and would like times reported to you in the time zone
that local for you, rather than what is local for the computer.
In POSIX.1 systems the value of the TZ variable can be of one of
three formats. With the GNU C library, the most common format is the
last one, which can specify a selection from a large database of time
zone information for many regions of the world. The first two formats
are used to describe the time zone information directly, which is both
more cumbersome and less precise. But the POSIX.1 standard only
specifies the details of the first two formats, so it is good to be
familiar with them in case you come across a POSIX.1 system that doesn't
support a time zone information database.
The first format is used when there is no Daylight Saving Time (or summer time) in the local time zone:
std offset
The std string specifies the name of the time zone. It must be three or more characters long and must not contain a leading colon or embedded digits, commas, or plus or minus signs. There is no space character separating the time zone name from the offset, so these restrictions are necessary to parse the specification correctly.
The offset specifies the time value one must add to the local time
to get a Coordinated Universal Time value. It has syntax like
[+|-]hh[:mm[:ss]]. This
is positive if the local time zone is west of the Prime Meridian and
negative if it is east. The hour must be between 0 and
23, and the minute and seconds between 0 and 59.
For example, here is how we would specify Eastern Standard Time, but without any daylight saving time alternative:
EST+5
The second format is used when there is Daylight Saving Time:
std offset dst [offset],start[/time],end[/time]
The initial std and offset specify the standard time zone, as described above. The dst string and offset specify the name and offset for the corresponding daylight saving time time zone; if the offset is omitted, it defaults to one hour ahead of standard time.
The remainder of the specification describes when daylight saving time is in effect. The start field is when daylight saving time goes into effect and the end field is when the change is made back to standard time. The following formats are recognized for these fields:
Jn
1 and 365.
February 29 is never counted, even in leap years.
n
0 and 365.
February 29 is counted in leap years.
Mm.w.d
0 (Sunday) and 6. The week
w must be between 1 and 5; week 1 is the
first week in which day d occurs, and week 5 specifies the
last d day in the month. The month m should be
between 1 and 12.
The time fields specify when, in the local time currently in
effect, the change to the other time occurs. If omitted, the default is
02:00:00.
For example, here is how one would specify the Eastern time zone in the United States, including the appropriate daylight saving time and its dates of applicability. The normal offset from UTC is 5 hours; since this is west of the prime meridian, the sign is positive. Summer time begins on the first Sunday in April at 2:00am, and ends on the last Sunday in October at 2:00am.
EST+5EDT,M4.1.0/2,M10.5.0/2
The schedule of daylight saving time in any particular jurisdiction has changed over the years. To be strictly correct, the conversion of dates and times in the past should be based on the schedule that was in effect then. However, this format has no facilities to let you specify how the schedule has changed from year to year. The most you can do is specify one particular schedule--usually the present day schedule--and this is used to convert any date, no matter when. For precise time zone specifications, it is best to use the time zone information database (see below).
The third format looks like this:
:characters
Each operating system interprets this format differently; in the GNU C library, characters is the name of a file which describes the time zone.
If the TZ environment variable does not have a value, the
operation chooses a time zone by default. In the GNU C library, the
default time zone is like the specification `TZ=:/etc/localtime'
(or `TZ=:/usr/local/etc/localtime', depending on how GNU C library
was configured; see section How to Install the GNU C Library). Other C libraries use their own
rule for choosing the default time zone, so there is little we can say
about them.
If characters begins with a slash, it is an absolute file name; otherwise the library looks for the file `/share/lib/zoneinfo/characters'. The `zoneinfo' directory contains data files describing local time zones in many different parts of the world. The names represent major cities, with subdirectories for geographical areas; for example, `America/New_York', `Europe/London', `Asia/Hong_Kong'. These data files are installed by the system administrator, who also sets `/etc/localtime' to point to the data file for the local time zone. The GNU C library comes with a large database of time zone information for most regions of the world, which is maintained by a community of volunteers and put in the public domain.
tzname contains two strings, which are the standard
names of the pair of time zones (standard and daylight
saving) that the user has selected. tzname[0] is the name of
the standard time zone (for example, "EST"), and tzname[1]
is the name for the time zone when daylight saving time is in use (for
example, "EDT"). These correspond to the std and dst
strings (respectively) from the TZ environment variable. If
daylight saving time is never used, tzname[1] is the empty string.
The tzname array is initialized from the TZ environment
variable whenever tzset, ctime, strftime,
mktime, or localtime is called. If multiple abbreviations
have been used (e.g. "EWT" and "EDT" for U.S. Eastern War
Time and Eastern Daylight Time), the array contains the most recent
abbreviation.
The tzname array is required for POSIX.1 compatibility, but in
GNU programs it is better to use the tm_zone member of the
broken-down time structure, since tm_zone reports the correct
abbreviation even when it is not the latest one.
tzset function initializes the tzname variable from
the value of the TZ environment variable. It is not usually
necessary for your program to call this function, because it is called
automatically when you use the other time conversion functions that
depend on the time zone.
The following variables are defined for compatibility with System V
Unix. Like tzname, these variables are set by calling
tzset or the other time conversion functions.
5*60*60. Unlike the tm_gmtoff member
of the broken-down time structure, this value is not adjusted for
daylight saving, and its sign is reversed. In GNU programs it is better
to use tm_gmtoff, since it contains the correct offset even when
it is not the latest one.
Here is an example program showing the use of some of the local time and calendar time functions.
#include <time.h>
#include <stdio.h>
#define SIZE 256
int
main (void)
{
char buffer[SIZE];
time_t curtime;
struct tm *loctime;
/* Get the current time. */
curtime = time (NULL);
/* Convert it to local time representation. */
loctime = localtime (&curtime);
/* Print out the date and time in the standard format. */
fputs (asctime (loctime), stdout);
/* Print it out in a nice format. */
strftime (buffer, SIZE, "Today is %A, %B %d.\n", loctime);
fputs (buffer, stdout);
strftime (buffer, SIZE, "The time is %I:%M %p.\n", loctime);
fputs (buffer, stdout);
return 0;
}
It produces output like this:
Wed Jul 31 13:02:36 1991 Today is Wednesday, July 31. The time is 01:02 PM.
The alarm and setitimer functions provide a mechanism for a
process to interrupt itself at some future time. They do this by setting a
timer; when the timer expires, the process receives a signal.
Each process has three independent interval timers available:
SIGALRM signal to the process when it expires.
SIGVTALRM signal to the process when it expires.
SIGPROF signal to the process when it expires.
This timer is useful for profiling in interpreters. The interval timer
mechanism does not have the fine granularity necessary for profiling
native code.
You can only have one timer of each kind set at any given time. If you set a timer that has not yet expired, that timer is simply reset to the new value.
You should establish a handler for the appropriate alarm signal using
signal or sigaction before issuing a call to setitimer
or alarm. Otherwise, an unusual chain of events could cause the
timer to expire before your program establishes the handler, and in that
case it would be terminated, since that is the default action for the alarm
signals. See section Signal Handling.
The setitimer function is the primary means for setting an alarm.
This facility is declared in the header file `sys/time.h'. The
alarm function, declared in `unistd.h', provides a somewhat
simpler interface for setting the real-time timer.
struct timeval it_interval
struct timeval it_value
The struct timeval data type is described in section High-Resolution Calendar.
setitimer function sets the timer specified by which
according to new. The which argument can have a value of
ITIMER_REAL, ITIMER_VIRTUAL, or ITIMER_PROF.
If old is not a null pointer, setitimer returns information
about any previous unexpired timer of the same kind in the structure it
points to.
The return value is 0 on success and -1 on failure. The
following errno error conditions are defined for this function:
EINVAL
getitimer function stores information about the timer specified
by which in the structure pointed at by old.
The return value and error conditions are the same as for setitimer.
ITIMER_REAL
setitimer and getitimer functions to specify the real-time
timer.
ITIMER_VIRTUAL
setitimer and getitimer functions to specify the virtual
timer.
ITIMER_PROF
setitimer and getitimer functions to specify the profiling
timer.
alarm function sets the real-time timer to expire in
seconds seconds. If you want to cancel any existing alarm, you
can do this by calling alarm with a seconds argument of
zero.
The return value indicates how many seconds remain before the previous
alarm would have been sent. If there is no previous alarm, alarm
returns zero.
The alarm function could be defined in terms of setitimer
like this:
unsigned int
alarm (unsigned int seconds)
{
struct itimerval old, new;
new.it_interval.tv_usec = 0;
new.it_interval.tv_sec = 0;
new.it_value.tv_usec = 0;
new.it_value.tv_sec = (long int) seconds;
if (setitimer (ITIMER_REAL, &new, &old) < 0)
return 0;
else
return old.it_value.tv_sec;
}
There is an example showing the use of the alarm function in
section Signal Handlers that Return.
If you simply want your process to wait for a given number of seconds,
you should use the sleep function. See section Sleeping.
You shouldn't count on the signal arriving precisely when the timer expires. In a multiprocessing environment there is typically some amount of delay involved.
Portability Note: The setitimer and getitimer
functions are derived from BSD Unix, while the alarm function is
specified by the POSIX.1 standard. setitimer is more powerful than
alarm, but alarm is more widely used.
The function sleep gives a simple way to make the program wait
for short periods of time. If your program doesn't use signals (except
to terminate), then you can expect sleep to wait reliably for
the specified amount of time. Otherwise, sleep can return sooner
if a signal arrives; if you want to wait for a given period regardless
of signals, use select (see section Waiting for Input or Output) and don't
specify any descriptors to wait for.
sleep function waits for seconds or until a signal
is delivered, whichever happens first.
If sleep function returns because the requested time has
elapsed, it returns a value of zero. If it returns because of delivery
of a signal, its return value is the remaining time in the sleep period.
The sleep function is declared in `unistd.h'.
Resist the temptation to implement a sleep for a fixed amount of time by
using the return value of sleep, when nonzero, to call
sleep again. This will work with a certain amount of accuracy as
long as signals arrive infrequently. But each signal can cause the
eventual wakeup time to be off by an additional second or so. Suppose a
few signals happen to arrive in rapid succession by bad luck--there is
no limit on how much this could shorten or lengthen the wait.
Instead, compute the time at which the program should stop waiting, and
keep trying to wait until that time. This won't be off by more than a
second. With just a little more work, you can use select and
make the waiting period quite accurate. (Of course, heavy system load
can cause unavoidable additional delays--unless the machine is
dedicated to one application, there is no way you can avoid this.)
On some systems, sleep can do strange things if your program uses
SIGALRM explicitly. Even if SIGALRM signals are being
ignored or blocked when sleep is called, sleep might
return prematurely on delivery of a SIGALRM signal. If you have
established a handler for SIGALRM signals and a SIGALRM
signal is delivered while the process is sleeping, the action taken
might be just to cause sleep to return instead of invoking your
handler. And, if sleep is interrupted by delivery of a signal
whose handler requests an alarm or alters the handling of SIGALRM,
this handler and sleep will interfere.
On the GNU system, it is safe to use sleep and SIGALRM in
the same program, because sleep does not work by means of
SIGALRM.
The function getrusage and the data type struct rusage
are used for examining the usage figures of a process. They are declared
in `sys/resource.h'.
*rusage.
In most systems, processes has only two valid values:
RUSAGE_SELF
RUSAGE_CHILDREN
In the GNU system, you can also inquire about a particular child process by specifying its process ID.
The return value of getrusage is zero for success, and -1
for failure.
EINVAL
One way of getting usage figures for a particular child process is with
the function wait4, which returns totals for a child when it
terminates. See section BSD Process Wait Functions.
struct timeval ru_utime
struct timeval ru_stime
long int ru_maxrss
long int ru_ixrss
long int ru_idrss
long int ru_isrss
long int ru_minflt
long int ru_majflt
long int ru_nswap
long int ru_inblock
long int ru_oublock
long int ru_msgsnd
long ru_msgrcv
long int ru_nsignals
long int ru_nvcsw
long int ru_nivcsw
An additional historical function for examining usage figures,
vtimes, is supported but not documented here. It is declared in
`sys/vtimes.h'.
You can specify limits for the resource usage of a process. When the process tries to exceed a limit, it may get a signal, or the system call by which it tried to do so may fail, depending on the limit. Each process initially inherits its limit values from its parent, but it can subsequently change them.
The symbols in this section are defined in `sys/resource.h'.
*rlp.
The return value is 0 on success and -1 on failure. The
only possible errno error condition is EFAULT.
*rlp.
The return value is 0 on success and -1 on failure. The
following errno error condition is possible:
EPERM
getrlimit to receive limit values,
and with setrlimit to specify limit values. It has two fields:
rlim_cur
rlim_max
In getrlimit, the structure is an output; it receives the current
values. In setrlimit, it specifies the new values.
Here is a list of resources that you can specify a limit for. Those that are sizes are measured in bytes.
RLIMIT_CPU
SIGXCPU. The value is
measured in seconds. See section Operation Error Signals.
RLIMIT_FSIZE
SIGXFSZ. See section Operation Error Signals.
RLIMIT_DATA
RLIMIT_STACK
SIGSEGV signal.
See section Program Error Signals.
RLIMIT_CORE
RLIMIT_RSS
RLIMIT_MEMLOCK
RLIMIT_NPROC
fork will fail
with EAGAIN. See section Creating a Process.
RLIMIT_NOFILE
RLIMIT_OFILE
EMFILE.
See section Error Codes. Not all systems support this limit; GNU does, and
4.4 BSD does.
RLIM_NLIMITS
RLIM_NLIMITS.
setrlimit.
Two historical functions for setting resource limits, ulimit and
vlimit, are not documented here. The latter is declared in
`sys/vlimit.h' and comes from BSD.
When several processes try to run, their respective priorities determine what share of the CPU each process gets. This section describes how you can read and set the priority of a process. All these functions and macros are declared in `sys/resource.h'.
The range of valid priority values depends on the operating system, but
typically it runs from -20 to 20. A lower priority value
means the process runs more often. These constants describe the range of
priority values:
PRIO_MIN
PRIO_MAX
The return value is the priority value on success, and -1 on
failure. The following errno error condition are possible for
this function:
ESRCH
EINVAL
When the return value is -1, it could indicate failure, or it
could be the priority value. The only way to make certain is to set
errno = 0 before calling getpriority, then use errno
!= 0 afterward as the criterion for failure.
The return value is 0 on success and -1 on failure. The
following errno error condition are defined for this function:
ESRCH
EINVAL
EPERM
EACCES
The arguments class and id together specify a set of processes you are interested in. These are the possible values for class:
PRIO_PROCESS
PRIO_PGRP
PRIO_USER
If the argument id is 0, it stands for the current process, current process group, or the current user, according to class.
setpriority.
Here is an equivalent definition for nice:
int
nice (int increment)
{
int old = getpriority (PRIO_PROCESS, 0);
return setpriority (PRIO_PROCESS, 0, old + increment);
}
A number of languages use character sets that are larger than the range
of values of type char. Japanese and Chinese are probably the
most familiar examples.
The GNU C library includes support for two mechanisms for dealing with extended character sets: multibyte characters and wide characters. This chapter describes how to use these mechanisms, and the functions for converting between them.
The behavior of the functions in this chapter is affected by the current
locale for character classification--the LC_CTYPE category; see
section Categories of Activities that Locales Affect. This choice of locale selects which multibyte
code is used, and also controls the meanings and characteristics of wide
character codes.
You can represent extended characters in either of two ways:
char objects. Their advantage is that many
programs and operating systems can handle occasional multibyte
characters scattered among ordinary ASCII characters, without any
change.
wchar_t,
has a range large enough to hold extended character codes as well as
old-fashioned ASCII codes.
An advantage of wide characters is that each character is a single data
object, just like ordinary ASCII characters. There are a few
disadvantages:
Typically, you use the multibyte character representation as part of the
external program interface, such as reading or writing text to files.
However, it's usually easier to perform internal manipulations on
strings containing extended characters on arrays of wchar_t
objects, since the uniform representation makes most editing operations
easier. If you do use multibyte characters for files and wide
characters for internal operations, you need to convert between them
when you read and write data.
If your system supports extended characters, then it supports them both as multibyte characters and as wide characters. The library includes functions you can use to convert between the two representations. These functions are described in this chapter.
A computer system can support more than one multibyte character code, and more than one wide character code. The user controls the choice of codes through the current locale for character classification (see section Locales and Internationalization). Each locale specifies a particular multibyte character code and a particular wide character code. The choice of locale influences the behavior of the conversion functions in the library.
Some locales support neither wide characters nor nontrivial multibyte characters. In these locales, the library conversion functions still work, even though what they do is basically trivial.
If you select a new locale for character classification, the internal shift state maintained by these functions can become confused, so it's not a good idea to change the locale while you are in the middle of processing a string.
In the ordinary ASCII code, a sequence of characters is a sequence of bytes, and each character is one byte. This is very simple, but allows for only 256 distinct characters.
In a multibyte character code, a sequence of characters is a sequence of bytes, but each character may occupy one or more consecutive bytes of the sequence.
There are many different ways of designing a multibyte character code; different systems use different codes. To specify a particular code means designating the basic byte sequences--those which represent a single character--and what characters they stand for. A code that a computer can actually use must have a finite number of these basic sequences, and typically none of them is more than a few characters long.
These sequences need not all have the same length. In fact, many of
them are just one byte long. Because the basic ASCII characters in the
range from 0 to 0177 are so important, they stand for
themselves in all multibyte character codes. That is to say, a byte
whose value is 0 through 0177 is always a character in
itself. The characters which are more than one byte must always start
with a byte in the range from 0200 through 0377.
The byte value 0 can be used to terminate a string, just as it is
often used in a string of ASCII characters.
Specifying the basic byte sequences that represent single characters
automatically gives meanings to many longer byte sequences, as more than
one character. For example, if the two byte sequence 0205 049
stands for the Greek letter alpha, then 0205 049 065 must stand
for an alpha followed by an `A' (ASCII code 065), and 0205 049
0205 049 must stand for two alphas in a row.
If any byte sequence can have more than one meaning as a sequence of characters, then the multibyte code is ambiguous--and no good. The codes that systems actually use are all unambiguous.
In most codes, there are certain sequences of bytes that have no meaning as a character or characters. These are called invalid.
The simplest possible multibyte code is a trivial one:
The basic sequences consist of single bytes.
This particular code is equivalent to not using multibyte characters at all. It has no invalid sequences. But it can handle only 256 different characters.
Here is another possible code which can handle 9376 different characters:
The basic sequences consist of
- single bytes with values in the range
0through0237.- two-byte sequences, in which both of the bytes have values in the range from
0240through0377.
This code or a similar one is used on some systems to represent Japanese
characters. The invalid sequences are those which consist of an odd
number of consecutive bytes in the range from 0240 through
0377.
Here is another multibyte code which can handle more distinct extended characters--in fact, almost thirty million:
The basic sequences consist of
- single bytes with values in the range
0through0177.- sequences of up to four bytes in which the first byte is in the range from
0200through0237, and the remaining bytes are in the range from0240through0377.
In this code, any sequence that starts with a byte in the range
from 0240 through 0377 is invalid.
And here is another variant which has the advantage that removing the last byte or bytes from a valid character can never produce another valid character. (This property is convenient when you want to search strings for particular characters.)
The basic sequences consist of
- single bytes with values in the range
0through0177.- two-byte sequences in which the first byte is in the range from
0200through0207, and the second byte is in the range from0240through0377.- three-byte sequences in which the first byte is in the range from
0210through0217, and the other bytes are in the range from0240through0377.- four-byte sequences in which the first byte is in the range from
0220through0227, and the other bytes are in the range from0240through0377.
The list of invalid sequences for this code is long and not worth
stating in full; examples of invalid sequences include 0240 and
0220 0300 065.
The number of possible multibyte codes is astronomical. But a given computer system will support at most a few different codes. (One of these codes may allow for thousands of different characters.) Another computer system may support a completely different code. The library facilities described in this chapter are helpful because they package up the knowledge of the details of a particular computer system's multibyte code, so your programs need not know them.
You can use special standard macros to find out the maximum possible
number of bytes in a character in the currently selected multibyte
code with MB_CUR_MAX, and the maximum for any multibyte
code supported on your computer with MB_LEN_MAX.
MB_LEN_MAX.
Normally, each basic sequence in a particular character code stands for one character, the same character regardless of context. Some multibyte character codes have a concept of shift state; certain codes, called shift sequences, change to a different shift state, and the meaning of some or all basic sequences varies according to the current shift state. In fact, the set of basic sequences might even be different depending on the current shift state. See section Multibyte Codes Using Shift Sequences, for more information on handling this sort of code.
What happens if you try to pass a string containing multibyte characters to a function that doesn't know about them? Normally, such a function treats a string as a sequence of bytes, and interprets certain byte values specially; all other byte values are "ordinary". As long as a multibyte character doesn't contain any of the special byte values, the function should pass it through as if it were several ordinary characters.
For example, let's figure out what happens if you use multibyte
characters in a file name. The functions such as open and
unlink that operate on file names treat the name as a sequence of
byte values, with `/' as the only special value. Any other byte
values are copied, or compared, in sequence, and all byte values are
treated alike. Thus, you may think of the file name as a sequence of
bytes or as a string containing multibyte characters; the same behavior
makes sense equally either way, provided no multibyte character contains
a `/'.
Wide characters are much simpler than multibyte characters. They
are simply characters with more than eight bits, so that they have room
for more than 256 distinct codes. The wide character data type,
wchar_t, has a range large enough to hold extended character
codes as well as old-fashioned ASCII codes.
An advantage of wide characters is that each character is a single data object, just like ordinary ASCII characters. Wide characters also have some disadvantages:
Wide character values 0 through 0177 are always identical
in meaning to the ASCII character codes. The wide character value zero
is often used to terminate a string of wide characters, just as a single
byte with value zero often terminates a string of ordinary characters.
If your system supports extended characters, then each extended character has both a wide character code and a corresponding multibyte basic sequence.
In this chapter, the term code is used to refer to a single
extended character object to emphasize the distinction from the
char data type.
The mbstowcs function converts a string of multibyte characters
to a wide character array. The wcstombs function does the
reverse. These functions are declared in the header file
`stdlib.h'.
In most programs, these functions are the only ones you need for conversion between wide strings and multibyte character strings. But they have limitations. If your data is not null-terminated or is not all in core at once, you probably need to use the low-level conversion functions to convert one character at a time. See section Conversion of Extended Characters One by One.
mbstowcs ("multibyte string to wide character string")
function converts the null-terminated string of multibyte characters
string to an array of wide character codes, storing not more than
size wide characters into the array beginning at wstring.
The terminating null character counts towards the size, so if size
is less than the actual number of wide characters resulting from
string, no terminating null character is stored.
The conversion of characters from string begins in the initial shift state.
If an invalid multibyte character sequence is found, this function
returns a value of -1. Otherwise, it returns the number of wide
characters stored in the array wstring. This number does not
include the terminating null character, which is present if the number
is less than size.
Here is an example showing how to convert a string of multibyte characters, allocating enough space for the result.
wchar_t *
mbstowcs_alloc (const char *string)
{
size_t size = strlen (string) + 1;
wchar_t *buf = xmalloc (size * sizeof (wchar_t));
size = mbstowcs (buf, string, size);
if (size == (size_t) -1)
return NULL;
buf = xrealloc (buf, (size + 1) * sizeof (wchar_t));
return buf;
}
wcstombs ("wide character string to multibyte string")
function converts the null-terminated wide character array wstring
into a string containing multibyte characters, storing not more than
size bytes starting at string, followed by a terminating
null character if there is room. The conversion of characters begins in
the initial shift state.
The terminating null character counts towards the size, so if size is less than or equal to the number of bytes needed in wstring, no terminating null character is stored.
If a code that does not correspond to a valid multibyte character is
found, this function returns a value of -1. Otherwise, the
return value is the number of bytes stored in the array string.
This number does not include the terminating null character, which is
present if the number is less than size.
This section describes how to scan a string containing multibyte
characters, one character at a time. The difficulty in doing this
is to know how many bytes each character contains. Your program
can use mblen to find this out.
mblen function with a non-null string argument returns
the number of bytes that make up the multibyte character beginning at
string, never examining more than size bytes. (The idea is
to supply for size the number of bytes of data you have in hand.)
The return value of mblen distinguishes three possibilities: the
first size bytes at string start with valid multibyte
character, they start with an invalid byte sequence or just part of a
character, or string points to an empty string (a null character).
For a valid multibyte character, mblen returns the number of
bytes in that character (always at least 1, and never more than
size). For an invalid byte sequence, mblen returns
-1. For an empty string, it returns 0.
If the multibyte character code uses shift characters, then mblen
maintains and updates a shift state as it scans. If you call
mblen with a null pointer for string, that initializes the
shift state to its standard initial value. It also returns nonzero if
the multibyte character code in use actually has a shift state.
See section Multibyte Codes Using Shift Sequences.
You can convert multibyte characters one at a time to wide characters
with the mbtowc function. The wctomb function does the
reverse. These functions are declared in `stdlib.h'.
mbtowc ("multibyte to wide character") function when called
with non-null string converts the first multibyte character
beginning at string to its corresponding wide character code. It
stores the result in *result.
mbtowc never examines more than size bytes. (The idea is
to supply for size the number of bytes of data you have in hand.)
mbtowc with non-null string distinguishes three
possibilities: the first size bytes at string start with
valid multibyte character, they start with an invalid byte sequence or
just part of a character, or string points to an empty string (a
null character).
For a valid multibyte character, mbtowc converts it to a wide
character and stores that in *result, and returns the
number of bytes in that character (always at least 1, and never
more than size).
For an invalid byte sequence, mbtowc returns -1. For an
empty string, it returns 0, also storing 0 in
*result.
If the multibyte character code uses shift characters, then
mbtowc maintains and updates a shift state as it scans. If you
call mbtowc with a null pointer for string, that
initializes the shift state to its standard initial value. It also
returns nonzero if the multibyte character code in use actually has a
shift state. See section Multibyte Codes Using Shift Sequences.
wctomb ("wide character to multibyte") function converts
the wide character code wchar to its corresponding multibyte
character sequence, and stores the result in bytes starting at
string. At most MB_CUR_MAX characters are stored.
wctomb with non-null string distinguishes three
possibilities for wchar: a valid wide character code (one that can
be translated to a multibyte character), an invalid code, and 0.
Given a valid code, wctomb converts it to a multibyte character,
storing the bytes starting at string. Then it returns the number
of bytes in that character (always at least 1, and never more
than MB_CUR_MAX).
If wchar is an invalid wide character code, wctomb returns
-1. If wchar is 0, it returns 0, also
storing 0 in *string.
If the multibyte character code uses shift characters, then
wctomb maintains and updates a shift state as it scans. If you
call wctomb with a null pointer for string, that
initializes the shift state to its standard initial value. It also
returns nonzero if the multibyte character code in use actually has a
shift state. See section Multibyte Codes Using Shift Sequences.
Calling this function with a wchar argument of zero when
string is not null has the side-effect of reinitializing the
stored shift state as well as storing the multibyte character
0 and returning 0.
Here is an example that reads multibyte character text from descriptor
input and writes the corresponding wide characters to descriptor
output. We need to convert characters one by one for this
example because mbstowcs is unable to continue past a null
character, and cannot cope with an apparently invalid partial character
by reading more input.
int
file_mbstowcs (int input, int output)
{
char buffer[BUFSIZ + MB_LEN_MAX];
int filled = 0;
int eof = 0;
while (!eof)
{
int nread;
int nwrite;
char *inp = buffer;
wchar_t outbuf[BUFSIZ];
wchar_t *outp = outbuf;
/* Fill up the buffer from the input file. */
nread = read (input, buffer + filled, BUFSIZ);
if (nread < 0)
{
perror ("read");
return 0;
}
/* If we reach end of file, make a note to read no more. */
if (nread == 0)
eof = 1;
/* filled is now the number of bytes in buffer. */
filled += nread;
/* Convert those bytes to wide characters--as many as we can. */
while (1)
{
int thislen = mbtowc (outp, inp, filled);
/* Stop converting at invalid character;
this can mean we have read just the first part
of a valid character. */
if (thislen == -1)
break;
/* Treat null character like any other,
but also reset shift state. */
if (thislen == 0) {
thislen = 1;
mbtowc (NULL, NULL, 0);
}
/* Advance past this character. */
inp += thislen;
filled -= thislen;
outp++;
}
/* Write the wide characters we just made. */
nwrite = write (output, outbuf,
(outp - outbuf) * sizeof (wchar_t));
if (nwrite < 0)
{
perror ("write");
return 0;
}
/* See if we have a real invalid character. */
if ((eof && filled > 0) || filled >= MB_CUR_MAX)
{
error ("invalid multibyte character");
return 0;
}
/* If any characters must be carried forward,
put them at the beginning of buffer. */
if (filled > 0)
memcpy (inp, buffer, filled);
}
}
return 1;
}
In some multibyte character codes, the meaning of any particular byte sequence is not fixed; it depends on what other sequences have come earlier in the same string. Typically there are just a few sequences that can change the meaning of other sequences; these few are called shift sequences and we say that they set the shift state for other sequences that follow.
To illustrate shift state and shift sequences, suppose we decide that
the sequence 0200 (just one byte) enters Japanese mode, in which
pairs of bytes in the range from 0240 to 0377 are single
characters, while 0201 enters Latin-1 mode, in which single bytes
in the range from 0240 to 0377 are characters, and
interpreted according to the ISO Latin-1 character set. This is a
multibyte code which has two alternative shift states ("Japanese mode"
and "Latin-1 mode"), and two shift sequences that specify particular
shift states.
When the multibyte character code in use has shift states, then
mblen, mbtowc and wctomb must maintain and update
the current shift state as they scan the string. To make this work
properly, you must follow these rules:
mblen (NULL,
0). This initializes the shift state to its standard initial value.
Here is an example of using mblen following these rules:
void
scan_string (char *s)
{
int length = strlen (s);
/* Initialize shift state. */
mblen (NULL, 0);
while (1)
{
int thischar = mblen (s, length);
/* Deal with end of string and invalid characters. */
if (thischar == 0)
break;
if (thischar == -1)
{
error ("invalid multibyte character");
break;
}
/* Advance past this character. */
s += thischar;
length -= thischar;
}
}
The functions mblen, mbtowc and wctomb are not
reentrant when using a multibyte code that uses a shift state. However,
no other library functions call these functions, so you don't have to
worry that the shift state will be changed mysteriously.
Different countries and cultures have varying conventions for how to communicate. These conventions range from very simple ones, such as the format for representing dates and times, to very complex ones, such as the language spoken.
Internationalization of software means programming it to be able to adapt to the user's favorite conventions. In ISO C, internationalization works by means of locales. Each locale specifies a collection of conventions, one convention for each purpose. The user chooses a set of conventions by specifying a locale (via environment variables).
All programs inherit the chosen locale as part of their environment. Provided the programs are written to obey the choice of locale, they will follow the conventions preferred by the user.
Each locale specifies conventions for several purposes, including the following:
Some aspects of adapting to the specified locale are handled
automatically by the library subroutines. For example, all your program
needs to do in order to use the collating sequence of the chosen locale
is to use strcoll or strxfrm to compare strings.
Other aspects of locales are beyond the comprehension of the library. For example, the library can't automatically translate your program's output messages into other languages. The only way you can support output in the user's favorite language is to program this more or less by hand. (Eventually, we hope to provide facilities to make this easier.)
This chapter discusses the mechanism by which you can modify the current locale. The effects of the current locale on specific library functions are discussed in more detail in the descriptions of those functions.
The simplest way for the user to choose a locale is to set the
environment variable LANG. This specifies a single locale to use
for all purposes. For example, a user could specify a hypothetical
locale named `espana-castellano' to use the standard conventions of
most of Spain.
The set of locales supported depends on the operating system you are using, and so do their names. We can't make any promises about what locales will exist, except for one standard locale called `C' or `POSIX'.
A user also has the option of specifying different locales for different purposes--in effect, choosing a mixture of multiple locales.
For example, the user might specify the locale `espana-castellano' for most purposes, but specify the locale `usa-english' for currency formatting. This might make sense if the user is a Spanish-speaking American, working in Spanish, but representing monetary amounts in US dollars.
Note that both locales `espana-castellano' and `usa-english', like all locales, would include conventions for all of the purposes to which locales apply. However, the user can choose to use each locale for a particular subset of those purposes.
The purposes that locales serve are grouped into categories, so
that a user or a program can choose the locale for each category
independently. Here is a table of categories; each name is both an
environment variable that a user can set, and a macro name that you can
use as an argument to setlocale.
LC_COLLATE
strcoll
and strxfrm); see section Collation Functions.
LC_CTYPE
LC_MONETARY
LC_NUMERIC
LC_TIME
LC_MESSAGES
LC_ALL
setlocale to set a single locale for all purposes.
LANG
A C program inherits its locale environment variables when it starts up.
This happens automatically. However, these variables do not
automatically control the locale used by the library functions, because
ISO C says that all programs start by default in the standard `C'
locale. To use the locales specified by the environment, you must call
setlocale. Call it as follows:
setlocale (LC_ALL, "");
to select a locale based on the appropriate environment variables.
You can also use setlocale to specify a particular locale, for
general use or for a specific category.
The symbols in this section are defined in the header file `locale.h'.
setlocale sets the current locale for
category category to locale.
If category is LC_ALL, this specifies the locale for all
purposes. The other possible values of category specify an
individual purpose (see section Categories of Activities that Locales Affect).
You can also use this function to find out the current locale by passing
a null pointer as the locale argument. In this case,
setlocale returns a string that is the name of the locale
currently selected for category category.
The string returned by setlocale can be overwritten by subsequent
calls, so you should make a copy of the string (see section Copying and Concatenation) if you want to save it past any further calls to
setlocale. (The standard library is guaranteed never to call
setlocale itself.)
You should not modify the string returned by setlocale.
It might be the same string that was passed as an argument in a
previous call to setlocale.
When you read the current locale for category LC_ALL, the value
encodes the entire combination of selected locales for all categories.
In this case, the value is not just a single locale name. In fact, we
don't make any promises about what it looks like. But if you specify
the same "locale name" with LC_ALL in a subsequent call to
setlocale, it restores the same combination of locale selections.
When the locale argument is not a null pointer, the string returned
by setlocale reflects the newly modified locale.
If you specify an empty string for locale, this means to read the appropriate environment variable and use its value to select the locale for category.
If you specify an invalid locale name, setlocale returns a null
pointer and leaves the current locale unchanged.
Here is an example showing how you might use setlocale to
temporarily switch to a new locale.
#include <stddef.h>
#include <locale.h>
#include <stdlib.h>
#include <string.h>
void
with_other_locale (char *new_locale,
void (*subroutine) (int),
int argument)
{
char *old_locale, *saved_locale;
/* Get the name of the current locale. */
old_locale = setlocale (LC_ALL, NULL);
/* Copy the name so it won't be clobbered by setlocale. */
saved_locale = strdup (old_locale);
if (old_locale == NULL)
fatal ("Out of memory");
/* Now change the locale and do some stuff with it. */
setlocale (LC_ALL, new_locale);
(*subroutine) (argument);
/* Restore the original locale. */
setlocale (LC_ALL, saved_locale);
free (saved_locale);
}
Portability Note: Some ISO C systems may define additional locale categories. For portability, assume that any symbol beginning with `LC_' might be defined in `locale.h'.
The only locale names you can count on finding on all operating systems are these three standard ones:
"C"
"POSIX"
""
Defining and installing named locales is normally a responsibility of the system administrator at your site (or the person who installed the GNU C library). Some systems may allow users to create locales, but we don't discuss that here.
If your program needs to use something other than the `C' locale, it will be more portable if you use whatever locale the user specifies with the environment, rather than trying to specify some non-standard locale explicitly by name. Remember, different machines might have different sets of locales installed.
When you want to format a number or a currency amount using the
conventions of the current locale, you can use the function
localeconv to get the data on how to do it. The function
localeconv is declared in the header file `locale.h'.
localeconv function returns a pointer to a structure whose
components contain information about how numeric and monetary values
should be formatted in the current locale.
You shouldn't modify the structure or its contents. The structure might
be overwritten by subsequent calls to localeconv, or by calls to
setlocale, but no other function in the library overwrites this
value.
localeconv.
If a member of the structure struct lconv has type char,
and the value is CHAR_MAX, it means that the current locale has
no value for that parameter.
These are the standard members of struct lconv; there may be
others.
char *decimal_point
char *mon_decimal_point
decimal_point is ".", and the value of
mon_decimal_point is "".
char *thousands_sep
char *mon_thousands_sep
"" (the empty string).
char *grouping
char *mon_grouping
grouping applies to non-monetary quantities
and mon_grouping applies to monetary quantities. Use either
thousands_sep or mon_thousands_sep to separate the digit
groups.
Each string is made up of decimal numbers separated by semicolons.
Successive numbers (from left to right) give the sizes of successive
groups (from right to left, starting at the decimal point). The last
number in the string is used over and over for all the remaining groups.
If the last integer is -1, it means that there is no more
grouping--or, put another way, any remaining digits form one large
group without separators.
For example, if grouping is "4;3;2", the correct grouping
for the number 123456787654321 is `12', `34',
`56', `78', `765', `4321'. This uses a group of 4
digits at the end, preceded by a group of 3 digits, preceded by groups
of 2 digits (as many as needed). With a separator of `,', the
number would be printed as `12,34,56,78,765,4321'.
A value of "3" indicates repeated groups of three digits, as
normally used in the U.S.
In the standard `C' locale, both grouping and
mon_grouping have a value of "". This value specifies no
grouping at all.
char int_frac_digits
char frac_digits
CHAR_MAX, meaning "unspecified". The ISO standard doesn't say
what to do when you find this the value; we recommend printing no
fractional digits. (This locale also specifies the empty string for
mon_decimal_point, so printing any fractional digits would be
confusing!)
These members of the struct lconv structure specify how to print
the symbol to identify a monetary value--the international analog of
`$' for US dollars.
Each country has two standard currency symbols. The local currency symbol is used commonly within the country, while the international currency symbol is used internationally to refer to that country's currency when it is necessary to indicate the country unambiguously.
For example, many countries use the dollar as their monetary unit, and when dealing with international currencies it's important to specify that one is dealing with (say) Canadian dollars instead of U.S. dollars or Australian dollars. But when the context is known to be Canada, there is no need to make this explicit--dollar amounts are implicitly assumed to be in Canadian dollars.
char *currency_symbol
""
(the empty string), meaning "unspecified". The ISO standard doesn't
say what to do when you find this value; we recommend you simply print
the empty string as you would print any other string found in the
appropriate member.
char *int_curr_symbol
int_curr_symbol should normally consist of a
three-letter abbreviation determined by the international standard
ISO 4217 Codes for the Representation of Currency and Funds,
followed by a one-character separator (often a space).
In the standard `C' locale, this member has a value of ""
(the empty string), meaning "unspecified". We recommend you simply
print the empty string as you would print any other string found in the
appropriate member.
char p_cs_precedes
char n_cs_precedes
1 if the currency_symbol string should
precede the value of a monetary amount, or 0 if the string should
follow the value. The p_cs_precedes member applies to positive
amounts (or zero), and the n_cs_precedes member applies to
negative amounts.
In the standard `C' locale, both of these members have a value of
CHAR_MAX, meaning "unspecified". The ISO standard doesn't say
what to do when you find this value, but we recommend printing the
currency symbol before the amount. That's right for most countries.
In other words, treat all nonzero values alike in these members.
The POSIX standard says that these two members apply to the
int_curr_symbol as well as the currency_symbol. The ISO
C standard seems to imply that they should apply only to the
currency_symbol---so the int_curr_symbol should always
precede the amount.
We can only guess which of these (if either) matches the usual
conventions for printing international currency symbols. Our guess is
that they should always precede the amount. If we find out a reliable
answer, we will put it here.
char p_sep_by_space
char n_sep_by_space
1 if a space should appear between the
currency_symbol string and the amount, or 0 if no space
should appear. The p_sep_by_space member applies to positive
amounts (or zero), and the n_sep_by_space member applies to
negative amounts.
In the standard `C' locale, both of these members have a value of
CHAR_MAX, meaning "unspecified". The ISO standard doesn't say
what you should do when you find this value; we suggest you treat it as
one (print a space). In other words, treat all nonzero values alike in
these members.
These members apply only to currency_symbol. When you use
int_curr_symbol, you never print an additional space, because
int_curr_symbol itself contains the appropriate separator.
The POSIX standard says that these two members apply to the
int_curr_symbol as well as the currency_symbol. But an
example in the ISO C standard clearly implies that they should apply
only to the currency_symbol---that the int_curr_symbol
contains any appropriate separator, so you should never print an
additional space.
Based on what we know now, we recommend you ignore these members when
printing international currency symbols, and print no extra space.
These members of the struct lconv structure specify how to print
the sign (if any) in a monetary value.
char *positive_sign
char *negative_sign
"" (the empty string), meaning "unspecified".
The ISO standard doesn't say what to do when you find this value; we
recommend printing positive_sign as you find it, even if it is
empty. For a negative value, print negative_sign as you find it
unless both it and positive_sign are empty, in which case print
`-' instead. (Failing to indicate the sign at all seems rather
unreasonable.)
char p_sign_posn
char n_sign_posn
positive_sign or negative_sign.) The possible values are
as follows:
0
1
2
3
4
CHAR_MAX
CHAR_MAX. We recommend you print the sign after the currency
symbol.
It is not clear whether you should let these members apply to the international currency format or not. POSIX says you should, but intuition plus the examples in the ISO C standard suggest you should not. We hope that someone who knows well the conventions for formatting monetary quantities will tell us what we should recommend.
Sometimes when your program detects an unusual situation inside a deeply
nested set of function calls, you would like to be able to immediately
return to an outer level of control. This section describes how you can
do such non-local exits using the setjmp and longjmp
functions.
As an example of a situation where a non-local exit can be useful, suppose you have an interactive program that has a "main loop" that prompts for and executes commands. Suppose the "read" command reads input from a file, doing some lexical analysis and parsing of the input while processing it. If a low-level input error is detected, it would be useful to be able to return immediately to the "main loop" instead of having to make each of the lexical analysis, parsing, and processing phases all have to explicitly deal with error situations initially detected by nested calls.
(On the other hand, if each of these phases has to do a substantial amount of cleanup when it exits--such as closing files, deallocating buffers or other data structures, and the like--then it can be more appropriate to do a normal return and have each phase do its own cleanup, because a non-local exit would bypass the intervening phases and their associated cleanup code entirely. Alternatively, you could use a non-local exit but do the cleanup explicitly either before or after returning to the "main loop".)
In some ways, a non-local exit is similar to using the `return' statement to return from a function. But while `return' abandons only a single function call, transferring control back to the point at which it was called, a non-local exit can potentially abandon many levels of nested function calls.
You identify return points for non-local exits calling the function
setjmp. This function saves information about the execution
environment in which the call to setjmp appears in an object of
type jmp_buf. Execution of the program continues normally after
the call to setjmp, but if a exit is later made to this return
point by calling longjmp with the corresponding jmp_buf
object, control is transferred back to the point where setjmp was
called. The return value from setjmp is used to distinguish
between an ordinary return and a return made by a call to
longjmp, so calls to setjmp usually appear in an `if'
statement.
Here is how the example program described above might be set up:
#include <setjmp.h>
#include <stdlib.h>
#include <stdio.h>
jmp_buf main_loop;
void
abort_to_main_loop (int status)
{
longjmp (main_loop, status);
}
int
main (void)
{
while (1)
if (setjmp (main_loop))
puts ("Back at main loop....");
else
do_command ();
}
void
do_command (void)
{
char buffer[128];
if (fgets (buffer, 128, stdin) == NULL)
abort_to_main_loop (-1);
else
exit (EXIT_SUCCESS);
}
The function abort_to_main_loop causes an immediate transfer of
control back to the main loop of the program, no matter where it is
called from.
The flow of control inside the main function may appear a little
mysterious at first, but it is actually a common idiom with
setjmp. A normal call to setjmp returns zero, so the
"else" clause of the conditional is executed. If
abort_to_main_loop is called somewhere within the execution of
do_command, then it actually appears as if the same call
to setjmp in main were returning a second time with a value
of -1.
So, the general pattern for using setjmp looks something like:
if (setjmp (buffer)) /* Code to clean up after premature return. */ ... else /* Code to be executed normally after setting up the return point. */ ...
Here are the details on the functions and data structures used for performing non-local exits. These facilities are declared in `setjmp.h'.
jmp_buf hold the state information to
be restored by a non-local exit. The contents of a jmp_buf
identify a specific place to return to.
setjmp stores information about the
execution state of the program in state and returns zero. If
longjmp is later used to perform a non-local exit to this
state, setjmp returns a nonzero value.
setjmp that
established that return point. Returning from setjmp by means of
longjmp returns the value argument that was passed to
longjmp, rather than 0. (But if value is given as
0, setjmp returns 1).
There are a lot of obscure but important restrictions on the use of
setjmp and longjmp. Most of these restrictions are
present because non-local exits require a fair amount of magic on the
part of the C compiler and can interact with other parts of the language
in strange ways.
The setjmp function is actually a macro without an actual
function definition, so you shouldn't try to `#undef' it or take
its address. In addition, calls to setjmp are safe in only the
following contexts:
Return points are valid only during the dynamic extent of the function
that called setjmp to establish them. If you longjmp to
a return point that was established in a function that has already
returned, unpredictable and disastrous things are likely to happen.
You should use a nonzero value argument to longjmp. While
longjmp refuses to pass back a zero argument as the return value
from setjmp, this is intended as a safety net against accidental
misuse and is not really good programming style.
When you perform a non-local exit, accessible objects generally retain
whatever values they had at the time longjmp was called. The
exception is that the values of automatic variables local to the
function containing the setjmp call that have been changed since
the call to setjmp are indeterminate, unless you have declared
them volatile.
In BSD Unix systems, setjmp and longjmp also save and
restore the set of blocked signals; see section Blocking Signals. However,
the POSIX.1 standard requires setjmp and longjmp not to
change the set of blocked signals, and provides an additional pair of
functions (sigsetjmp and sigsetjmp) to get the BSD
behavior.
The behavior of setjmp and longjmp in the GNU library is
controlled by feature test macros; see section Feature Test Macros. The
default in the GNU system is the POSIX.1 behavior rather than the BSD
behavior.
The facilities in this section are declared in the header file `setjmp.h'.
jmp_buf, except that it can also store state
information about the set of blocked signals.
setjmp. If savesigs is nonzero, the set
of blocked signals is saved in state and will be restored if a
siglongjmp is later performed with this state.
longjmp except for the type of its state
argument. If the sigsetjmp call that set this state used a
nonzero savesigs flag, siglongjmp also restores the set of
blocked signals.
A signal is a software interrupt delivered to a process. The operating system uses signals to report exceptional situations to an executing program. Some signals report errors such as references to invalid memory addresses; others report asynchronous events, such as disconnection of a phone line.
The GNU C library defines a variety of signal types, each for a particular kind of event. Some kinds of events make it inadvisable or impossible for the program to proceed as usual, and the corresponding signals normally abort the program. Other kinds of signals that report harmless events are ignored by default.
If you anticipate an event that causes signals, you can define a handler function and tell the operating system to run it when that particular type of signal arrives.
Finally, one process can send a signal to another process; this allows a parent process to abort a child, or two related processes to communicate and synchronize.
This section explains basic concepts of how signals are generated, what happens after a signal is delivered, and how programs can handle signals.
A signal reports the occurrence of an exceptional event. These are some of the events that can cause (or generate, or raise) a signal:
kill or raise by the same process.
kill from another process. Signals are a limited but
useful form of interprocess communication.
Each of these kinds of events (excepting explicit calls to kill
and raise) generates its own particular kind of signal. The
various kinds of signals are listed and described in detail in
section Standard Signals.
In general, the events that generate signals fall into three major categories: errors, external events, and explicit requests.
An error means that a program has done something invalid and cannot
continue execution. But not all kinds of errors generate signals--in
fact, most do not. For example, opening a nonexistent file is an error,
but it does not raise a signal; instead, open returns -1.
In general, errors that are necessarily associated with certain library
functions are reported by returning a value that indicates an error.
The errors which raise signals are those which can happen anywhere in
the program, not just in library calls. These include division by zero
and invalid memory addresses.
An external event generally has to do with I/O or other processes. These include the arrival of input, the expiration of a timer, and the termination of a child process.
An explicit request means the use of a library function such as
kill whose purpose is specifically to generate a signal.
Signals may be generated synchronously or asynchronously. A synchronous signal pertains to a specific action in the program, and is delivered (unless blocked) during that action. Most errors generate signals synchronously, and so do explicit requests by a process to generate a signal for that same process. On some machines, certain kinds of hardware errors (usually floating-point exceptions) are not reported completely synchronously, but may arrive a few instructions later.
Asynchronous signals are generated by events outside the control of the process that receives them. These signals arrive at unpredictable times during execution. External events generate signals asynchronously, and so do explicit requests that apply to some other process.
A given type of signal is either typically synchronous or typically asynchronous. For example, signals for errors are typically synchronous because errors generate signals synchronously. But any type of signal can be generated synchronously or asynchronously with an explicit request.
When a signal is generated, it becomes pending. Normally it remains pending for just a short period of time and then is delivered to the process that was signaled. However, if that kind of signal is currently blocked, it may remain pending indefinitely--until signals of that kind are unblocked. Once unblocked, it will be delivered immediately. See section Blocking Signals.
When the signal is delivered, whether right away or after a long delay,
the specified action for that signal is taken. For certain
signals, such as SIGKILL and SIGSTOP, the action is fixed,
but for most signals, the program has a choice: ignore the signal,
specify a handler function, or accept the default action for
that kind of signal. The program specifies its choice using functions
such as signal or sigaction (see section Specifying Signal Actions). We
sometimes say that a handler catches the signal. While the
handler is running, that particular signal is normally blocked.
If the specified action for a kind of signal is to ignore it, then any such signal which is generated is discarded immediately. This happens even if the signal is also blocked at the time. A signal discarded in this way will never be delivered, not even if the program subsequently specifies a different action for that kind of signal and then unblocks it.
If a signal arrives which the program has neither handled nor ignored, its default action takes place. Each kind of signal has its own default action, documented below (see section Standard Signals). For most kinds of signals, the default action is to terminate the process. For certain kinds of signals that represent "harmless" events, the default action is to do nothing.
When a signal terminates a process, its parent process can determine the
cause of termination by examining the termination status code reported
by the wait or waitpid functions. (This is discussed in
more detail in section Process Completion.) The information it can get
includes the fact that termination was due to a signal, and the kind of
signal involved. If a program you run from a shell is terminated by a
signal, the shell typically prints some kind of error message.
The signals that normally represent program errors have a special property: when one of these signals terminates the process, it also writes a core dump file which records the state of the process at the time of termination. You can examine the core dump with a debugger to investigate what caused the error.
If you raise a "program error" signal by explicit request, and this terminates the process, it makes a core dump file just as if the signal had been due directly to an error.
This section lists the names for various standard kinds of signals and describes what kind of event they mean. Each signal name is a macro which stands for a positive integer--the signal number for that kind of signal. Your programs should never make assumptions about the numeric code for a particular kind of signal, but rather refer to them always by the names defined here. This is because the number for a given kind of signal can vary from system to system, but the meanings of the names are standardized and fairly uniform.
The signal names are defined in the header file `signal.h'.
NSIG is also one greater than the largest defined signal number.
The following signals are generated when a serious program error is detected by the operating system or the computer itself. In general, all of these signals are indications that your program is seriously broken in some way, and there's usually no way to continue the computation which encountered the error.
Some programs handle program error signals in order to tidy up before terminating; for example, programs that turn off echoing of terminal input should handle program error signals in order to turn echoing back on. The handler should end by specifying the default action for the signal that happened and then reraising it; this will cause the program to terminate with that signal, as if it had not had a handler. (See section Handlers That Terminate the Process.)
Termination is the sensible ultimate outcome from a program error in
most programs. However, programming systems such as Lisp that can load
compiled user programs might need to keep executing even if a user
program incurs an error. These programs have handlers which use
longjmp to return control to the command level.
The default action for all of these signals is to cause the process to
terminate. If you block or ignore these signals or establish handlers
for them that return normally, your program will probably break horribly
when such signals happen, unless they are generated by raise or
kill instead of a real error.
When one of these program error signals terminates a process, it also
writes a core dump file which records the state of the process at
the time of termination. The core dump file is named `core' and is
written in whichever directory is current in the process at the time.
(On the GNU system, you can specify the file name for core dumps with
the environment variable COREFILE.) The purpose of core dump
files is so that you can examine them with a debugger to investigate
what caused the error.
SIGFPE signal reports a fatal arithmetic error. Although the
name is derived from "floating-point exception", this signal actually
covers all arithmetic errors, including division by zero and overflow.
If a program stores integer data in a location which is then used in a
floating-point operation, this often causes an "invalid operation"
exception, because the processor cannot recognize the data as a
floating-point number.
Actual floating-point exceptions are a complicated subject because there
are many types of exceptions with subtly different meanings, and the
SIGFPE signal doesn't distinguish between them. The IEEE
Standard for Binary Floating-Point Arithmetic (ANSI/IEEE Std 754-1985
and ANSI/IEEE Std 854-1987)
defines various floating-point exceptions and requires conforming
computer systems to report their occurrences. However, this standard
does not specify how the exceptions are reported, or what kinds of
handling and control the operating system can offer to the programmer.
BSD systems provide the SIGFPE handler with an extra argument
that distinguishes various causes of the exception. In order to access
this argument, you must define the handler to accept two arguments,
which means you must cast it to a one-argument function type in order to
establish the handler. The GNU library does provide this extra
argument, but the value is meaningful only on operating systems that
provide the information (BSD systems and GNU systems).
FPE_INTOVF_TRAP
FPE_INTDIV_TRAP
FPE_SUBRNG_TRAP
FPE_FLTOVF_TRAP
FPE_FLTDIV_TRAP
FPE_FLTUND_TRAP
FPE_DECOVF_TRAP
SIGILL typically indicates that the executable file is corrupted,
or that you are trying to execute data. Some common ways of getting
into the latter situation are by passing an invalid object where a
pointer to a function was expected, or by writing past the end of an
automatic array (or similar problems with pointers to automatic
variables) and corrupting other data on the stack such as the return
address of a stack frame.
SIGILL can also be generated when the stack overflows, or when
the system has trouble running the handler for a signal.
Common ways of getting a SIGSEGV condition include dereferencing
a null or uninitialized pointer, or when you use a pointer to step
through an array, but fail to check for the end of the array. It varies
among systems whether dereferencing a null pointer generates
SIGSEGV or SIGBUS.
SIGSEGV, this signal is typically the result of dereferencing an
uninitialized pointer. The difference between the two is that
SIGSEGV indicates an invalid access to valid memory, while
SIGBUS indicates an access to an invalid address. In particular,
SIGBUS signals often result from dereferencing a misaligned
pointer, such as referring to a four-word integer at an address not
divisible by four. (Each kind of computer has its own requirements for
address alignment.)
The name of this signal is an abbreviation for "bus error".
abort. See section Aborting a Program.
SIGABRT.
SIGTRAP if it is somehow executing bad
instructions.
These signals are all used to tell a process to terminate, in one way or another. They have different names because they're used for slightly different purposes, and programs might want to handle them differently.
The reason for handling these signals is usually so your program can tidy up as appropriate before actually terminating. For example, you might want to save state information, delete temporary files, or restore the previous terminal modes. Such a handler should end by specifying the default action for the signal that happened and then reraising it; this will cause the program to terminate with that signal, as if it had not had a handler. (See section Handlers That Terminate the Process.)
The (obvious) default action for all of these signals is to cause the process to terminate.
SIGTERM signal is a generic signal used to cause program
termination. Unlike SIGKILL, this signal can be blocked,
handled, and ignored. It is the normal way to politely ask a program to
terminate.
SIGINT ("program interrupt") signal is sent when the user
types the INTR character (normally C-c). See section Special Characters, for information about terminal driver support for
C-c.
SIGQUIT signal is similar to SIGINT, except that it's
controlled by a different key--the QUIT character, usually
C-\---and produces a core dump when it terminates the process,
just like a program error signal. You can think of this as a
program error condition "detected" by the user.
See section Program Error Signals, for information about core dumps. See section Special Characters, for information about terminal driver support.
Certain kinds of cleanups are best omitted in handling SIGQUIT.
For example, if the program creates temporary files, it should handle
the other termination requests by deleting the temporary files. But it
is better for SIGQUIT not to delete them, so that the user can
examine them in conjunction with the core dump.
SIGKILL signal is used to cause immediate program termination.
It cannot be handled or ignored, and is therefore always fatal. It is
also not possible to block this signal.
This signal is usually generated only by explicit request. Since it
cannot be handled, you should generate it only as a last resort, after
first trying a less drastic method such as C-c or SIGTERM.
If a process does not respond to any other termination signals, sending
it a SIGKILL signal will almost always cause it to go away.
In fact, if SIGKILL fails to terminate a process, that by itself
constitutes an operating system bug which you should report.
The system will generate SIGKILL for a process itself under some
unusual conditions where the program cannot possible continue to run
(even to run a signal handler).
SIGHUP ("hang-up") signal is used to report that the user's
terminal is disconnected, perhaps because a network or telephone
connection was broken. For more information about this, see section Control Modes.
This signal is also used to report the termination of the controlling process on a terminal to jobs associated with that session; this termination effectively disconnects all processes in the session from the controlling terminal. For more information, see section Termination Internals.
These signals are used to indicate the expiration of timers. See section Setting an Alarm, for information about functions that cause these signals to be sent.
The default behavior for these signals is to cause program termination. This default is rarely useful, but no other default would be useful; most of the ways of using these signals would require handler functions in any case.
alarm function, for example.
The signals listed in this section are used in conjunction with
asynchronous I/O facilities. You have to take explicit action by
calling fcntl to enable a particular file descriptor to generate
these signals (see section Interrupt-Driven Input). The default action for these
signals is to ignore them.
On most operating systems, terminals and sockets are the only kinds of
files that can generate SIGIO; other kinds, including ordinary
files, never generate SIGIO even if you ask them to.
In the GNU system SIGIO will always be generated properly
if you successfully set asynchronous mode with fcntl.
SIGIO.
It is defined only for compatibility.
These signals are used to support job control. If your system doesn't support job control, then these macros are defined but the signals themselves can't be raised or handled.
You should generally leave these signals alone unless you really understand how job control works. See section Job Control.
The default action for this signal is to ignore it. If you establish a
handler for this signal while there are child processes that have
terminated but not reported their status via wait or
waitpid (see section Process Completion), whether your new handler
applies to those processes or not depends on the particular operating
system.
SIGCHLD.
SIGCONT signal to a process to make it continue.
This signal is special--it always makes the process continue if it is
stopped, before the signal is delivered. The default behavior is to do
nothing else. You cannot block this signal. You can set a handler, but
SIGCONT always makes the process continue regardless.
Most programs have no reason to handle SIGCONT; they simply
resume execution without realizing they were ever stopped. You can use
a handler for SIGCONT to make a program do something special when
it is stopped and continued--for example, to rep