Copyright © 2008 Linux Foundation
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1; with no Invariant Sections, with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License".
Portions of the text may be copyrighted by the following parties:
The Regents of the University of California
Free Software Foundation
Ian F. Darwin
Paul Vixie
BSDI (now Wind River)
Andrew G Morgan
Jean-loup Gailly and Mark Adler
Massachusetts Institute of Technology
Apple Inc.
Easy Software Products
artofcode LLC
Till Kamppeter
Manfred Wassman
Python Software Foundation
These excerpts are being used in accordance with their respective licenses.
Linux is the registered trademark of Linus Torvalds in the U.S. and other countries.
UNIX is a registered trademark of The Open Group.
LSB is a trademark of the Linux Foundation in the United States and other countries.
AMD is a trademark of Advanced Micro Devices, Inc.
Intel and Itanium are registered trademarks and Intel386 is a trademark of Intel Corporation.
PowerPC is a registered trademark and PowerPC Architecture is a trademark of the IBM Corporation.
S/390 is a registered trademark of the IBM Corporation.
OpenGL is a registered trademark of Silicon Graphics, Inc.
This is version 4.0 of the Linux Standard Base Core Specification. This specification is part of a family of specifications under the general title "Linux Standard Base". Developers of applications or implementations interested in using the LSB trademark should see the Linux Foundation Certification Policy for details.
The LSB defines a binary interface for application programs that are compiled and packaged for LSB-conforming implementations on many different hardware architectures. Since a binary specification shall include information specific to the computer processor architecture for which it is intended, it is not possible for a single document to specify the interface for all possible LSB-conforming implementations. Therefore, the LSB is a family of specifications, rather than a single one.
This document should be used in conjunction with the documents it references. This document enumerates the system components it includes, but descriptions of those components may be included entirely or partly in this document, partly in other documents, or entirely in other reference documents. For example, the section that describes system service routines includes a list of the system routines supported in this interface, formal declarations of the data structures they use that are visible to applications, and a pointer to the underlying referenced specification for information about the syntax and semantics of each call. Only those routines not described in standards referenced by this document, or extensions to those standards, are described in the detail. Information referenced in this way is as much a part of this document as is the information explicitly included here.
The specification carries a version number of either the form x.y or x.y.z. This version number carries the following meaning:
The first number (x) is the major version number. All versions with the same major version number should share binary compatibility. Any addition or deletion of a new library results in a new version number. Interfaces marked as deprecated may be removed from the specification at a major version change.
The second number (y) is the minor version number. Individual interfaces may be added if all certified implementations already had that (previously undocumented) interface. Interfaces may be marked as deprecated at a minor version change. Other minor changes may be permitted at the discretion of the LSB workgroup.
The third number (z), if present, is the editorial level. Only editorial changes should be included in such versions.
Since this specification is a descriptive Application Binary Interface, and not a source level API specification, it is not possible to make a guarantee of 100% backward compatibility between major releases. However, it is the intent that those parts of the binary interface that are visible in the source level API will remain backward compatible from version to version, except where a feature marked as "Deprecated" in one release may be removed from a future release.
Implementors are strongly encouraged to make use of symbol versioning to permit simultaneous support of applications conforming to different releases of this specification.
The Linux Standard Base (LSB) defines a system interface for compiled applications and a minimal environment for support of installation scripts. Its purpose is to enable a uniform industry standard environment for high-volume applications conforming to the LSB.
These specifications are composed of two basic parts: A common specification ("LSB-generic" or "generic LSB"), ISO/IEC 23360 Part 1, describing those parts of the interface that remain constant across all implementations of the LSB, and an architecture-specific part ("LSB-arch" or "archLSB") describing the parts of the interface that vary by processor architecture. Together, the LSB-generic and the relevant architecture-specific part of ISO/IEC 23360 for a single hardware architecture provide a complete interface specification for compiled application programs on systems that share a common hardware architecture.
ISO/IEC 23360 Part 1, the LSB-generic document, should be used in conjunction with an architecture-specific part. Whenever a section of the LSB-generic specification is supplemented by architecture-specific information, the LSB-generic document includes a reference to the architecture part. Architecture-specific parts of ISO/IEC 23360 may also contain additional information that is not referenced in the LSB-generic document.
The LSB contains both a set of Application Program Interfaces (APIs) and Application Binary Interfaces (ABIs). APIs may appear in the source code of portable applications, while the compiled binary of that application may use the larger set of ABIs. A conforming implementation provides all of the ABIs listed here. The compilation system may replace (e.g. by macro definition) certain APIs with calls to one or more of the underlying binary interfaces, and may insert calls to binary interfaces as needed.
The LSB is primarily a binary interface definition. Not all of the source level APIs available to applications may be contained in this specification.
This is the Core module of the Linux Standard Base (LSB), ISO/IEC 23360 Part 1. This module provides the fundamental system interfaces, libraries, and runtime environment upon which all conforming applications and libraries depend.
Interfaces described in this part of ISO/IEC 23360 are mandatory except where explicitly listed otherwise. Core interfaces may be supplemented by other modules; all modules are built upon the core.
The following referenced documents are indispensable for the application of this document. For dated references, only the edition cited applies. For undated references, the latest edition of the referenced document (including any amendments) applies.
Note: Where copies of a document are available on the World Wide Web, a Uniform Resource Locator (URL) is given for informative purposes only. This may point to a more recent copy of the referenced specification, or may be out of date. Reference copies of specifications at the revision level indicated may be found at the Linux Foundation's Reference Specifications site.
Table 2-1. Normative References
| Name | Title | URL |
|---|---|---|
| Filesystem Hierarchy Standard | Filesystem Hierarchy Standard (FHS) 2.3 | http://www.pathname.com/fhs/ |
| ISO C (1999) | ISO/IEC 9899: 1999, Programming Languages --C | |
| ISO POSIX (2003) | ISO/IEC 9945-1:2003 Information technology -- Portable Operating System Interface (POSIX) -- Part 1: Base Definitions ISO/IEC 9945-2:2003 Information technology -- Portable Operating System Interface (POSIX) -- Part 2: System Interfaces ISO/IEC 9945-3:2003 Information technology -- Portable Operating System Interface (POSIX) -- Part 3: Shell and Utilities ISO/IEC 9945-4:2003 Information technology -- Portable Operating System Interface (POSIX) -- Part 4: Rationale Including Technical Cor. 1: 2004 | http://www.unix.org/version3/ |
| Itanium™ C++ ABI | Itanium™ C++ ABI (Revision 1.83) | http://refspecs.linux-foundation.org/cxxabi-1.83.html |
| Large File Support | Large File Support | http://www.UNIX-systems.org/version2/whatsnew/lfs20mar.html |
| POSIX 1003.1 2008 | Portable Operating System Interface (POSIX®) 2008 Edition / The Open Group Technical Standard Base Specifications, Issue 7 | http://www.unix.org/version4/ |
| SUSv2 | CAE Specification, January 1997, System Interfaces and Headers (XSH),Issue 5 (ISBN: 1-85912-181-0, C606) | http://www.opengroup.org/publications/catalog/un.htm |
| SVID Issue 3 | American Telephone and Telegraph Company, System V Interface Definition, Issue 3; Morristown, NJ, UNIX Press, 1989. (ISBN 0201566524) | |
| SVID Issue 4 | System V Interface Definition, Fourth Edition | |
| System V ABI | System V Application Binary Interface, Edition 4.1 | http://www.caldera.com/developers/devspecs/gabi41.pdf |
| System V ABI Update | System V Application Binary Interface - DRAFT - 17 December 2003 | http://www.caldera.com/developers/gabi/2003-12-17/contents.html |
| X/Open Curses | CAE Specification, May 1996, X/Open Curses, Issue 4, Version 2 (ISBN: 1-85912-171-3, C610), plus Corrigendum U018 | http://www.opengroup.org/publications/catalog/un.htm |
In addition, the specifications listed below provide essential background information to implementors of this specification. These references are included for information only.
Table 2-2. Other References
| Name | Title | URL |
|---|---|---|
| Cairo API Reference | Cairo Vector Graphics API Specification for 1.0.2 | http://cairographics.org/manual-1.0.2 |
| DWARF Debugging Information Format, Revision 2.0.0 | DWARF Debugging Information Format, Revision 2.0.0 (July 27, 1993) | http://refspecs.linux-foundation.org/dwarf/dwarf-2.0.0.pdf |
| DWARF Debugging Information Format, Revision 3.0.0 (Draft) | DWARF Debugging Information Format, Revision 3.0.0 (Draft) | http://refspecs.linux-foundation.org/dwarf |
| IEC 60559/IEEE 754 Floating Point | IEC 60559:1989 Binary floating-point arithmetic for microprocessor systems | http://www.ieee.org/ |
| ISO/IEC TR14652 | ISO/IEC Technical Report 14652:2002 Specification method for cultural conventions | |
| ITU-T V.42 | International Telecommunication Union Recommendation V.42 (2002): Error-correcting procedures for DCEs using asynchronous-to-synchronous conversionITUV | http://www.itu.int/rec/recommendation.asp?type=folders&lang=e&parent=T-REC-V.42 |
| Li18nux Globalization Specification | LI18NUX 2000 Globalization Specification, Version 1.0 with Amendment 4 | http://www.openi18n.org/docs/html/LI18NUX-2000-amd4.htm |
| Linux Allocated Device Registry | LINUX ALLOCATED DEVICES | http://www.lanana.org/docs/device-list/devices.txt |
| PAM | Open Software Foundation, Request For Comments: 86.0 , October 1995, V. Samar & R.Schemers (SunSoft) | http://www.opengroup.org/tech/rfc/mirror-rfc/rfc86.0.txt |
| RFC 1321: The MD5 Message-Digest Algorithm | IETF RFC 1321: The MD5 Message-Digest Algorithm | http://www.ietf.org/rfc/rfc1321.txt |
| RFC 1831/1832 RPC & XDR | IETF RFC 1831 & 1832 | http://www.ietf.org/ |
| RFC 1833: Binding Protocols for ONC RPC Version 2 | IETF RFC 1833: Binding Protocols for ONC RPC Version 2 | http://www.ietf.org/rfc/rfc1833.txt |
| RFC 1950: ZLIB Compressed Data Format Specication | IETF RFC 1950: ZLIB Compressed Data Format Specification | http://www.ietf.org/rfc/rfc1950.txt |
| RFC 1951: DEFLATE Compressed Data Format Specification | IETF RFC 1951: DEFLATE Compressed Data Format Specification version 1.3 | http://www.ietf.org/rfc/rfc1951.txt |
| RFC 1952: GZIP File Format Specification | IETF RFC 1952: GZIP file format specification version 4.3 | http://www.ietf.org/rfc/rfc1952.txt |
| RFC 2440: OpenPGP Message Format | IETF RFC 2440: OpenPGP Message Format | http://www.ietf.org/rfc/rfc2440.txt |
| RFC 2821:Simple Mail Transfer Protocol | IETF RFC 2821: Simple Mail Transfer Protocol | http://www.ietf.org/rfc/rfc2821.txt |
| RFC 2822:Internet Message Format | IETF RFC 2822: Internet Message Format | http://www.ietf.org/rfc/rfc2822.txt |
| RFC 791:Internet Protocol | IETF RFC 791: Internet Protocol Specification | http://www.ietf.org/rfc/rfc791.txt |
| RPM Package Format | RPM Package Format V3.0 | http://www.rpm.org/max-rpm/s1-rpm-file-format-rpm-file-format.html |
| SUSv2 Commands and Utilities | The Single UNIX Specification(SUS) Version 2, Commands and Utilities (XCU), Issue 5 (ISBN: 1-85912-191-8, C604) | http://www.opengroup.org/publications/catalog/un.htm |
| zlib Manual | zlib 1.2 Manual | http://www.gzip.org/zlib/ |
The libraries listed in Table 3-1 shall be available on a Linux Standard Base system, with the specified runtime names. The libraries listed in Table 3-2 are architecture specific, but shall be available on all LSB conforming systems. This list may be supplemented or amended by the relevant architecture specific part of ISO/IEC 23360.
Table 3-1. Standard Library Names
| Library | Runtime Name |
|---|---|
| libdl | libdl.so.2 |
| libcrypt | libcrypt.so.1 |
| libz | libz.so.1 |
| libncurses | libncurses.so.5 |
| libutil | libutil.so.1 |
| libpthread | libpthread.so.0 |
| librt | librt.so.1 |
| libpam | libpam.so.0 |
| libgcc_s | libgcc_s.so.1 |
Table 3-2. Standard Library Names defined in the Architecture Specific Parts of ISO/IEC 23360
| Library | Runtime Name |
|---|---|
| libm | See archLSB |
| libc | See archLSB |
| proginterp | See archLSB |
These libraries will be in an implementation-defined directory which the dynamic linker shall search by default.
A conforming implementation is necessarily architecture specific, and must provide the interfaces specified by both the generic LSB Core specification (ISO/IEC 23360 Part 1) and the relevant architecture specific part of ISO/IEC 23360.
Rationale: An implementation must provide at least the interfaces specified in these specifications. It may also provide additional interfaces.
A conforming implementation shall satisfy the following requirements:
A processor architecture represents a family of related processors which may not have identical feature sets. The architecture specific parts of ISO/IEC 23360 that supplement this specification for a given target processor architecture describe a minimum acceptable processor. The implementation shall provide all features of this processor, whether in hardware or through emulation transparent to the application.
The implementation shall be capable of executing compiled applications having the format and using the system interfaces described in this document.
The implementation shall provide libraries containing the interfaces specified by this document, and shall provide a dynamic linking mechanism that allows these interfaces to be attached to applications at runtime. All the interfaces shall behave as specified in this document.
The map of virtual memory provided by the implementation shall conform to the requirements of this document.
The implementation's low-level behavior with respect to function call linkage, system traps, signals, and other such activities shall conform to the formats described in this document.
The implementation shall provide all of the mandatory interfaces in their entirety.
The implementation may provide one or more of the optional interfaces. Each optional interface that is provided shall be provided in its entirety. The product documentation shall state which optional interfaces are provided.
The implementation shall provide all files and utilities specified as part of this document in the format defined here and in other referenced documents. All commands and utilities shall behave as required by this document. The implementation shall also provide all mandatory components of an application's runtime environment that are included or referenced in this document.
The implementation, when provided with standard data formats and values at a named interface, shall provide the behavior defined for those values and data formats at that interface. However, a conforming implementation may consist of components which are separately packaged and/or sold. For example, a vendor of a conforming implementation might sell the hardware, operating system, and windowing system as separately packaged items.
The implementation may provide additional interfaces with different names. It may also provide additional behavior corresponding to data values outside the standard ranges, for standard named interfaces.
A conforming application is necessarily architecture specific, and must conform to both the generic LSB Core specification (ISO/IEC 23360 Part 1)and the relevant architecture specific part of ISO/IEC 23360.
A conforming application shall satisfy the following requirements:
Its executable files shall be either shell scripts or object files in the format defined for the Object File Format system interface.
Its object files shall participate in dynamic linking as defined in the Program Loading and Linking System interface.
It shall employ only the instructions, traps, and other low-level facilities defined in the Low-Level System interface as being for use by applications.
If it requires any optional interface defined in this document in order to be installed or to execute successfully, the requirement for that optional interface shall be stated in the application's documentation.
It shall not use any interface or data format that is not required to be provided by a conforming implementation, unless:
If such an interface or data format is supplied by another application through direct invocation of that application during execution, that application shall be in turn an LSB conforming application.
The use of that interface or data format, as well as its source, shall be identified in the documentation of the application.
It shall not use any values for a named interface that are reserved for vendor extensions.
For the purposes of this document, the following definitions, as specified in the ISO/IEC Directives, Part 2, 2001, 4th Edition, apply:
For the purposes of this document, the following terms apply:
The architectural part of the LSB Specification which describes the specific parts of the interface that are platform specific. The archLSB is complementary to the gLSB.
The total set of interfaces that are available to be used in the compiled binary code of a conforming application.
The common part of the LSB Specification that describes those parts of the interface that remain constant across all hardware implementations of the LSB.
Describes a value or behavior that is not defined by this document but is selected by an implementor. The value or behavior may vary among implementations that conform to this document. An application should not rely on the existence of the value or behavior. An application that relies on such a value or behavior cannot be assured to be portable across conforming implementations. The implementor shall document such a value or behavior so that it can be used correctly by an application.
A file that is read by an interpreter (e.g., awk). The first line of the shell script includes a reference to its interpreter binary.
The set of interfaces that are available to be used in the source code of a conforming application.
Describes the nature of a value or behavior not defined by this document which results from use of an invalid program construct or invalid data input. The value or behavior may vary among implementations that conform to this document. An application should not rely on the existence or validity of the value or behavior. An application that relies on any particular value or behavior cannot be assured to be portable across conforming implementations.
Describes the nature of a value or behavior not specified by this document which results from use of a valid program construct or valid data input. The value or behavior may vary among implementations that conform to this document. An application should not rely on the existence or validity of the value or behavior. An application that relies on any particular value or behavior cannot be assured to be portable across conforming implementations.
Other terms and definitions used in this document shall have the same meaning as defined in Chapter 3 of the Base Definitions volume of ISO POSIX (2003).
Throughout this document, the following typographic conventions are used:
| function() | the name of a function | |
| command | the name of a command or utility | |
CONSTANT | a constant value | |
| parameter | a parameter | |
variable | a variable |
Throughout this specification, several tables of interfaces are presented. Each entry in these tables has the following format:
| name | the name of the interface | |
| (symver) | An optional symbol version identifier, if required. | |
| [refno] | A reference number indexing the table of referenced specifications that follows this table. |
For example,
refers to the interface named forkpty() with symbol versionGLIBC_2.0 that is defined in the
SUSv3 reference.
Note: For symbols with versions which differ between architectures, the symbol versions are defined in the architecture specific parts of ISO/IEC 23360 only.
This specification includes many interfaces described in ISO POSIX (2003). Unless otherwise specified, such interfaces should behave exactly as described in that specification. Any conflict between the requirements described here and the ISO POSIX (2003) standard is unintentional, except as explicitly noted otherwise.
Note: In addition to the differences noted inline in this specification, PDTR 24715 has extracted the differences between this specification and ISO POSIX (2003) into a single place. It is the long term plan of the Linux Foundation to converge the LSB Core Specification with ISO/IEC 9945 POSIX.
The LSB Specification Authority is responsible for deciding the meaning of conformance to normative referenced standards in the LSB context. Problem Reports regarding underlying or referenced standards in any other context will be referred to the relevant maintenance body for that standard.
The LSB is the base for several other specification projects under the umbrella of the Linux Foundation (LF). This specification is the foundation, and other specifications build on the interfaces defined here. However, beyond those specifications listed as Normative References, this specification has no dependencies on other LF projects.
Executable and Linking Format (ELF) defines the object format for compiled applications. This specification supplements the information found in System V ABI Update and is intended to document additions made since the publication of that document.
LSB-conforming applications shall assume that stack, heap and other allocated memory regions will be non-executable. The application must take steps to make them executable if needed.
LSB-conforming applications shall use the data representation as defined in the Arcitecture specific ELF documents.
In addition to the fundamental types specified in the relevant architecture specific part of ISO/IEC 23360, a 1 byte data type is defined here.
LSB-conforming implementations shall support the object file Executable and Linking Format (ELF), which is defined by the following documents:
this specification
the relevant architecture specific part of ISO/IEC 23360
As described in System V ABI, an ELF object file contains a number of sections.
The section header table is an array of
Elf32_Shdr or
Elf64_Shdr structures as
described in System V ABI. The
sh_type member shall be either a value from
Table 11-1, drawn from the System V
ABI, or one of the additional values specified in Table 11-2.
A section header's sh_type member specifies the sections's semantics.
The following section types are defined in the System V ABI and the System V ABI Update.
Table 11-1. ELF Section Types
Various sections hold program and control information. Sections in the lists below are used by the system and have the indicated types and attributes.
The following sections are defined in the System V ABI and the System V ABI Update.
Table 11-3. ELF Special Sections
| Name | Type | Attributes |
|---|---|---|
| .bss | SHT_NOBITS | SHF_ALLOC+SHF_WRITE |
| .comment | SHT_PROGBITS | 0 |
| .data | SHT_PROGBITS | SHF_ALLOC+SHF_WRITE |
| .data1 | SHT_PROGBITS | SHF_ALLOC+SHF_WRITE |
| .debug | SHT_PROGBITS | 0 |
| .dynamic | SHT_DYNAMIC | SHF_ALLOC+SHF_WRITE |
| .dynstr | SHT_STRTAB | SHF_ALLOC |
| .dynsym | SHT_DYNSYM | SHF_ALLOC |
| .fini | SHT_PROGBITS | SHF_ALLOC+SHF_EXECINSTR |
| .fini_array | SHT_FINI_ARRAY | SHF_ALLOC+SHF_WRITE |
| .hash | SHT_HASH | SHF_ALLOC |
| .init | SHT_PROGBITS | SHF_ALLOC+SHF_EXECINSTR |
| .init_array | SHT_INIT_ARRAY | SHF_ALLOC+SHF_WRITE |
| .interp | SHT_PROGBITS | SHF_ALLOC |
| .line | SHT_PROGBITS | 0 |
| .note | SHT_NOTE | 0 |
| .preinit_array | SHT_PREINIT_ARRAY | SHF_ALLOC+SHF_WRITE |
| .rodata | SHT_PROGBITS | SHF_ALLOC+SHF_MERGE+SHF_STRINGS |
| .rodata1 | SHT_PROGBITS | SHF_ALLOC+SHF_MERGE+SHF_STRINGS |
| .shstrtab | SHT_STRTAB | 0 |
| .strtab | SHT_STRTAB | SHF_ALLOC |
| .symtab | SHT_SYMTAB | SHF_ALLOC |
| .tbss | SHT_NOBITS | SHF_ALLOC+SHF_WRITE+SHF_TLS |
| .tdata | SHT_PROGBITS | SHF_ALLOC+SHF_WRITE+SHF_TLS |
| .text | SHT_PROGBITS | SHF_ALLOC+SHF_EXECINSTR |
Object files in an LSB conforming application may also contain one or more of the additional special sections described below.
Table 11-4. Additional Special Sections
| Name | Type | Attributes |
|---|---|---|
| .ctors | SHT_PROGBITS | SHF_ALLOC+SHF_WRITE |
| .data.rel.ro | SHT_PROGBITS | SHF_ALLOC+SHF_WRITE |
| .dtors | SHT_PROGBITS | SHF_ALLOC+SHF_WRITE |
| .eh_frame | SHT_PROGBITS | SHF_ALLOC |
| .eh_frame_hdr | SHT_PROGBITS | SHF_ALLOC |
| .gcc_except_table | SHT_PROGBITS | SHF_ALLOC |
| .gnu.version | SHT_GNU_versym | SHF_ALLOC |
| .gnu.version_d | SHT_GNU_verdef | SHF_ALLOC |
| .gnu.version_r | SHT_GNU_verneed | SHF_ALLOC |
| .got.plt | SHT_PROGBITS | SHF_ALLOC+SHF_WRITE |
| .jcr | SHT_PROGBITS | SHF_ALLOC+SHF_WRITE |
| .note.ABI-tag | SHT_NOTE | SHF_ALLOC |
| .stab | SHT_PROGBITS | 0 |
| .stabstr | SHT_STRTAB | 0 |
| .ctors | This section contains a list of global constructor function pointers. | |
| .data.rel.ro | This section holds initialized data that contribute to the program's memory image. This section may be made read-only after relocations have been applied. | |
| .dtors | This section contains a list of global destructor function pointers. | |
| .eh_frame | This section contains information necessary for frame unwinding during exception handling. See Section 11.6.1. | |
| .eh_frame_hdr | This section contains a pointer to the .eh_frame section which is accessible to the runtime support code of a C++ application. This section may also contain a binary search table which may be used by the runtime support code to more efficiently access records in the .eh_frame section. See Section 11.6.2. | |
| .gcc_except_table | This section holds Language Specific Data. | |
| .gnu.version | This section contains the Symbol Version Table. See Section 11.7.2. | |
| .gnu.version_d | This section contains the Version Definitions. See Section 11.7.3. | |
| .gnu.version_r | This section contains the Version Requirements. See Section 11.7.4. | |
| .got.plt | This section holds the read-only portion of the GLobal Offset Table. This section may be made read-only after relocations have been applied. | |
| .jcr | This section contains information necessary for registering compiled Java classes. The contents are compiler-specific and used by compiler initialization functions. | |
| .note.ABI-tag | Specify ABI details. See Section 11.8. | |
| .stab | This section contains debugging information. The contents are not specified as part of the LSB. | |
| .stabstr | This section contains strings associated with the debugging infomation contained in the .stab section. |
Symbols in a source program are translated by the compilation system into symbols that exist in the object file.
The LSB does not specify debugging information, however, some additional sections contain information which is encoded using the the encoding as specified by DWARF Debugging Information Format, Revision 2.0.0 with extensions defined here.
Note: The extensions specified here also exist in DWARF Debugging Information Format, Revision 3.0.0 (Draft). It is expected that future versions of the LSB will reference the final version of that document, and that the definitions here will be taken from that document instead of being specified here.
The DWARF Exception Header Encoding is used to describe the type of data used in the .eh_frame and .eh_frame_hdr section. The upper 4 bits indicate how the value is to be applied. The lower 4 bits indicate the format of the data.
Table 11-5. DWARF Exception Header value format
| Name | Value | Meaning |
|---|---|---|
| DW_EH_PE_absptr | 0x00 | The Value is a literal pointer whose size is determined by the architecture. |
| DW_EH_PE_uleb128 | 0x01 | Unsigned value is encoded using the Little Endian Base 128 (LEB128) as defined by DWARF Debugging Information Format, Revision 2.0.0. |
| DW_EH_PE_udata2 | 0x02 | A 2 bytes unsigned value. |
| DW_EH_PE_udata4 | 0x03 | A 4 bytes unsigned value. |
| DW_EH_PE_udata8 | 0x04 | An 8 bytes unsigned value. |
| DW_EH_PE_sleb128 | 0x09 | Signed value is encoded using the Little Endian Base 128 (LEB128) as defined by DWARF Debugging Information Format, Revision 2.0.0. |
| DW_EH_PE_sdata2 | 0x0A | A 2 bytes signed value. |
| DW_EH_PE_sdata4 | 0x0B | A 4 bytes signed value. |
| DW_EH_PE_sdata8 | 0x0C | An 8 bytes signed value. |
Table 11-6. DWARF Exception Header application
| Name | Value | Meaning |
|---|---|---|
| DW_EH_PE_pcrel | 0x10 | Value is relative to the current program counter. |
| DW_EH_PE_textrel | 0x20 | Value is relative to the beginning of the .text section. |
| DW_EH_PE_datarel | 0x30 | Value is relative to the beginning of the .got or .eh_frame_hdr section. |
| DW_EH_PE_funcrel | 0x40 | Value is relative to the beginning of the function. |
| DW_EH_PE_aligned | 0x50 | Value is aligned to an address unit sized boundary. |
One special encoding, 0xff (DW_EH_PE_omit), shall be used to indicate that no value ispresent.
In addition to the Call Frame Instructions defined in section 6.4.2 of DWARF Debugging Information Format, Revision 2.0.0, the following additional Call Frame Instructions may also be used.
Table 11-7. Additional DWARF Call Frame Instructions
| Name | Value | Meaning |
|---|---|---|
| DW_CFA_expression | 0x10 | The DW_CFA_expression instruction takes two operands: an unsigned LEB128 value representing a register number, and a DW_FORM_block value representing a DWARF expression. The required action is to establish the DWARF expression as the means by which the address in which the given register contents are found may be computed. The value of the CFA is pushed on the DWARF evaluation stack prior to execution of the DWARF expression. The DW_OP_call2, DW_OP_call4, DW_OP_call_ref and DW_OP_push_object_address DWARF operators (see Section 2.4.1 of DWARF Debugging Information Format, Revision 2.0.0) cannot be used in such a DWARF expression. |
| DW_CFA_offset_extended_sf | 0x11 | The DW_CFA_offset_extended_sf instruction takes two operands: an unsigned LEB128 value representing a register number and a signed LEB128 factored offset. This instruction is identical to DW_CFA_offset_extended except that the second operand is signed. |
| DW_CFA_def_cfa_sf | 0x12 | The DW_CFA_def_cfa_sf instruction takes two operands: an unsigned LEB128 value representing a register number and a signed LEB128 factored offset. This instruction is identical to DW_CFA_def_cfa except that the second operand is signed and factored. |
| DW_CFA_def_cfa_offset_sf | 0x13 | The DW_CFA_def_cfa_offset_sf instruction takes a signed LEB128 operand representing a factored offset. This instruction is identical to DW_CFA_def_cfa_offset except that the operand is signed and factored. |
| DW_CFA_GNU_args_size | 0x2e | The DW_CFA_GNU_args_size instruction takes an unsigned LEB128 operand representing an argument size. This instruction specifies the total of the size of the arguments which have been pushed onto the stack. |
| DW_CFA_GNU_negative_offset_extended | 0x2f | The DW_CFA_def_cfa_sf instruction takes two operands: an unsigned LEB128 value representing a register number and an unsigned LEB128 which represents the magnitude of the offset. This instruction is identical to DW_CFA_offset_extended_sf except that the operand is subtracted to produce the offset. This instructions is obsoleted by DW_CFA_offset_extended_sf. |
When using languages that support exceptions, such as C++, additional information must be provided to the runtime environment that describes the call frames that must be unwound during the processing of an exception. This information is contained in the special sections .eh_frame and .eh_framehdr.
Note: The format of the .eh_frame section is similar in format and purpose to the .debug_frame section which is specified in DWARF Debugging Information Format, Revision 3.0.0 (Draft). Readers are advised that there are some subtle difference, and care should be taken when comparing the two sections.
The .eh_frame section shall contain 1 or more Call Frame Information (CFI) records. The number of records present shall be determined by size of the section as contained in the section header. Each CFI record contains a Common Information Entry (CIE) record followed by 1 or more Frame Description Entry (FDE) records. Both CIEs and FDEs shall be aligned to an addressing unit sized boundary.
Table 11-8. Call Frame Information Format
| Common Information Entry Record |
| Frame Description Entry Record(s) |
Table 11-9. Common Information Entry Format
| Length | Required |
| Extended Length | Optional |
| CIE ID | Required |
| Version | Required |
| Augmentation String | Required |
| Code Alignment Factor | Required |
| Data Alignment Factor | Required |
| Return Address Register | Required |
| Augmentation Data Length | Optional |
| Augmentation Data | Optional |
| Initial Instructions | Required |
| Padding |
LengthA 4 byte unsigned value indicating the length in bytes of the CIE structure,
not including the Length field itself. If
Length contains the value 0xffffffff, then the
length is contained in the Extended Length field.
If Length contains the value 0, then this CIE shall
be considered a terminator and processing shall end.
Extended LengthA 8 byte unsigned value indicating the length in bytes of the CIE structure,
not including the Length and
Extended Length fields.
CIE IDA 4 byte unsigned value that is used to distinguish CIE records from FDE records. This value shall always be 0, which indicates this record is a CIE.
VersionA 1 byte value that identifies the version number of the frame information structure. This value shall be 1.
Augmentation StringThis value is a NUL terminated string that identifies the augmentation to the CIE or to the FDEs associated with this CIE. A zero length string indicates that no augmentation data is present. The augmentation string is case sensitive and shall be interpreted as described below.
Code Alignment FactorAn unsigned LEB128 encoded value that is factored out of all advance location instructions that are associated with this CIE or its FDEs. This value shall be multiplied by the delta argument of an adavance location instruction to obtain the new location value.
Data Alignment FactorA signed LEB128 encoded value that is factored out of all offset instructions that are associated with this CIE or its FDEs. This value shall be multiplied by the register offset argument of an offset instruction to obtain the new offset value.
Augmentation LengthAn unsigned LEB128 encoded value indicating the length in bytes of the Augmentation Data. This field is only present if the Augmentation String contains the character 'z'.
Augmentation DataA block of data whose contents are defined by the contents of the Augmentation String as described below. This field is only present if the Augmentation String contains the character 'z'. The size of this data is given by the Augentation Length.
Initial InstructionsInitial set of Call Frame Instructions. The number of instructions is determined by the remaining space in the CIE record.
PaddingExtra bytes to align the CIE structure to an addressing unit size boundary.
The Agumentation String indicates the presence of some optional fields, and how those fields should be intepreted. This string is case sensitive. Each character in the augmentation string in the CIE can be interpreted as below:
Table 11-10. Frame Description Entry Format
| Length | Required |
| Extended Length | Optional |
| CIE Pointer | Required |
| PC Begin | Required |
| PC Range | Required |
| Augmentation Data Length | Optional |
| Augmentation Data | Optional |
| Call Frame Instructions | Required |
| Padding |
LengthA 4 byte unsigned value indicating the length in bytes of the CIE structure,
not including the Length field itself. If
Length contains the value 0xffffffff, then the
length is contained the Extended Length field.
If Length contains the value 0, then this CIE shall
be considered a terminator and processing shall end.
Extended LengthA 8 byte unsigned value indicating the length in bytes of the CIE structure,
not including the Length field itself.
CIE PointerA 4 byte unsigned value that when subtracted from the offset of the the CIE Pointer in the current FDE yields the offset of the start of the associated CIE. This value shall never be 0.
PC BeginAn encoded value that indicates the address of the initial location associated with this FDE. The encoding format is specified in the Augmentation Data.
PC RangeAn absolute value that indicates the number of bytes of instructions associated with this FDE.
Augmentation LengthAn unsigned LEB128 encoded value indicating the length in bytes of the Augmentation Data. This field is only present if the Augmentation String in the associated CIE contains the character 'z'.
Augmentation DataA block of data whose contents are defined by the contents of the Augmentation String in the associated CIE as described above. This field is only present if the Augmentation String in the associated CIE contains the character 'z'. The size of this data is given by the Augentation Length.
Call Frame InstructionsA set of Call Frame Instructions.
PaddingExtra bytes to align the FDE structure to an addressing unit size boundary.
The .eh_frame_hdr section contains additional information about the .eh_frame section. A pointer to the start of the .eh_frame data, and optionally, a binary search table of pointers to the .eh_frame records are found in this section.
Data in this section is encoded according to Section 11.5.1.
Table 11-11. .eh_frame_hdr Section Format
| Encoding | Field |
|---|---|
| unsigned byte | version |
| unsigned byte | eh_frame_ptr_enc |
| unsigned byte | fde_count_enc |
| unsigned byte | table_enc |
| encoded | eh_frame_ptr |
| encoded | fde_count |
| binary search table |
This chapter describes the Symbol Versioning mechanism. All ELF objects may provide or depend on versioned symbols. Symbol Versioning is implemented by 3 section types: SHT_GNU_versym, SHT_GNU_verdef, and SHT_GNU_verneed.
The prefix Elfxx in the following descriptions and code fragments stands for either "Elf32" or "Elf64", depending on the architecture.
Versions are described by strings. The structures that are used for symbol versions also contain a member that holds the ELF hashing values of the strings. This allows for more efficient processing.
The special section .gnu.version which has a section type of SHT_GNU_versym shall contain the Symbol Version Table. This section shall have the same number of entries as the Dynamic Symbol Table in the .dynsym section.
The .gnu.version section shall contain an array of elements of type Elfxx_Half. Each entry specifies the version defined for or required by the corresponding symbol in the Dynamic Symbol Table.
The values in the Symbol Version Table are specific to the object in which they
are located. These values are identifiers that are provided by the the
vna_other member of the
Elfxx_Vernaux structure or the
vd_ndx member of the
Elfxx_Verdef structure.
The values 0 and 1 are reserved.
| 0 | The symbol is local, not available outside the object. | |
| 1 | The symbol is defined in this object and is globally available. |
All other values are used to identify version strings located in one of the other Symbol Version sections. The value itself is not the version associated with the symbol. The string identified by the value defines the version of the symbol.
The special section .gnu.version_d which has a section type of SHT_GNU_verdef shall contain symbol version definitions. The number of entries in this section shall be contained in the DT_VERDEFNUM entry of the Dynamic Section .dynamic. The sh_link member of the section header (see figure 4-8 in the System V ABI) shall point to the section that contains the strings referenced by this section.
The section shall contain an array of Elfxx_Verdef structures, as described in Figure 11-1, optionally followed by an array of Elfxx_Verdaux structures, as defined in Figure 11-2.
typedef struct {
Elfxx_Half vd_version;
Elfxx_Half vd_flags;
Elfxx_Half vd_ndx;
Elfxx_Half vd_cnt;
Elfxx_Word vd_hash;
Elfxx_Word vd_aux;
Elfxx_Word vd_next;
} Elfxx_Verdef; |
Figure 11-1. Version Definition Entries
vd_version | Version revision. This field shall be set to 1. | |
vd_flags | Version information flag bitmask. | |
vd_ndx | Version index numeric value referencing the SHT_GNU_versym section. | |
vd_cnt | Number of associated verdaux array entries. | |
vd_hash | Version name hash value (ELF hash function). | |
vd_aux | Offset in bytes to a corresponding entry in an array of Elfxx_Verdaux structures as defined in Figure 11-2 | |
vd_next | Offset to the next verdef entry, in bytes. |
typedef struct {
Elfxx_Word vda_name;
Elfxx_Word vda_next;
} Elfxx_Verdaux; |
Figure 11-2. Version Definition Auxiliary Entries
vda_name | Offset to the version or dependency name string in the section header, in bytes. | |
vda_next | Offset to the next verdaux entry, in bytes. |
The special section .gnu.version_r which has a section type of
SHT_GNU_verneed
shall contain required symbol version definitions. The number of entries in
this section shall be contained in the DT_VERNEEDNUM entry of the Dynamic
Section .dynamic.
The sh_link member of the section header (see figure 4-8 in
System V ABI)
shall point to the section that contains the strings referenced by this section.
The section shall contain an array of Elfxx_Verneed structures, as described in Figure 11-3, optionally followed by an array of Elfxx_Vernaux structures, as defined in Figure 11-4.
typedef struct {
Elfxx_Half vn_version;
Elfxx_Half vn_cnt;
Elfxx_Word vn_file;
Elfxx_Word vn_aux;
Elfxx_Word vn_next;
} Elfxx_Verneed; |
Figure 11-3. Version Needed Entries
typedef struct {
Elfxx_Word vna_hash;
Elfxx_Half vna_flags;
Elfxx_Half vna_other;
Elfxx_Word vna_name;
Elfxx_Word vna_next;
} Elfxx_Vernaux; |
Figure 11-4. Version Needed Auxiliary Entries
When loading a sharable object the system shall analyze version definition data from the loaded object to assure that it meets the version requirements of the calling object. This step is referred to as definition testing. The dynamic loader shall retrieve the entries in the caller's Elfxx_Verneed array and attempt to find matching definition information in the loaded Elfxx_Verdef table.
Each object and dependency shall be tested in turn. If a symbol definition is missing and the vna_flags bit for VER_FLG_WEAK is not set, the loader shall return an error and exit. If the vna_flags bit for VER_FLG_WEAK is set in the Elfxx_Vernaux entry, and the loader shall issue a warning and continue operation.
When the versions referenced by undefined symbols in the loaded object are found, version availability is certified. The test completes without error and the object shall be made available.
When symbol versioning is used in an object, relocations extend definition testing beyond the simple match of symbol name strings: the version of the reference shall also equal the name of the definition.
The same index that is used in the symbol table can be referenced in the SHT_GNU_versym section, and the value of this index is then used to acquire name data. The corresponding requirement string is retrieved from the Elfxx_Verneed array, and likewise, the corresponding definition string from the Elfxx_Verdef table.
If the high order bit (bit number 15) of the version symbolis set, the object cannot be used and the static linker shall ignore the symbol's presence in the object.
When an object with a reference and an object with the definition are being linked, the following rules shall govern the result:
The object with the reference and the object with the definitions both use
versioning. All described matching is processed in this case. A fatal error
shall be triggered when no matching definition can be found in the object whose
name is the one referenced by the vn_name element in the
Elfxx_Verneed entry.
The object with the reference does not use versioning, while the object with the definitions does. In this instance, only the definitions with index numbers 1 and 2 will be used in the reference match, the same identified by the static linker as the base definition. In cases where the static linker was not used, such as in calls to dlopen(), a version that does not have the base definition index shall be acceptable if it is the only version for which the symbol is defined.
The object with the reference uses versioning, but the object with the definitions specifies none. A matching symbol shall be accepted in this case. A fatal error shall be triggered if a corruption in the required symbols list obscures an outdated object file and causes a match on the object filename in the Elfxx_Verneed entry.
Neither the object with the reference nor the object with the definitions use versioning. The behavior in this instance shall default to pre-existing symbol rules.
Every executable shall contain a section named .note.ABI-tag of type SHT_NOTE. This section is structured as a note section as documented in the ELF spec. The section shall contain at least the following entry. The name field (namesz/name) contains the string "GNU". The type field shall be 1. The descsz field shall be at least 16, and the first 16 bytes of the desc field shall be as follows.
The first 32-bit word of the desc field shall be 0 (this signifies a Linux executable). The second, third, and fourth 32-bit words of the desc field contain the earliest compatible kernel version. For example, if the 3 words are 2, 2, and 5, this signifies a 2.2.5 kernel.
LSB-conforming implementations shall support the object file information and system actions that create running programs as specified in the System V ABI and System V ABI Update and as further required by this specification and the relevant architecture specific part of ISO/IEC 23360.
Any shared object that is loaded shall contain sufficient DT_NEEDED records to satisfy the symbols on the shared library.
In addition to the Segment Types defined in the System V ABI and System V ABI Update the following Segment Types shall also be supported.
Table 12-1. Linux Segment Types
| Name | Value |
|---|---|
| PT_GNU_EH_FRAME | 0x6474e550 |
| PT_GNU_STACK | 0x6474e551 |
| PT_GNU_RELRO | 0x6474e552 |
As described in System V ABI, if an object file participates in dynamic linking, its program header table shall have an element of type PT_DYNAMIC. This `segment' contains the .dynamic section. A special symbol, _DYNAMIC, labels the section, which contains an array of the following structures.
typedef struct {
Elf32_Sword d_tag;
union {
Elf32_Word d_val;
Elf32_Addr d_ptr;
} d_un;
} Elf32_Dyn;
extern Elf32_Dyn _DYNAMIC[];
typedef struct {
Elf64_Sxword d_tag;
union {
Elf64_Xword d_val;
Elf64_Addr d_ptr;
} d_un;
} Elf64_Dyn;
extern Elf64_Dyn _DYNAMIC[]; |
Figure 12-1. Dynamic Structure
For each object with this type, d_tag
controls the interpretation of d_un.
The following dynamic entries are defined in the System V ABI and System V ABI Update.
An LSB conforming object may also use the following additional Dynamic Entry types.
An LSB-conforming implementation shall support the following base libraries which provide interfaces for accessing the operating system, processor and other hardware in the system.
libc
libm
libgcc_s
libdl
librt
libcrypt
libpam
There are three main parts to the definition of each of these libraries.
The "Interfaces" section defines the required library name and version, and the required public symbols (interfaces and global data), as well as symbol versions, if any.
The "Interface Definitions" section provides complete or partial definitions of certain interfaces where either this specification is the source specification, or where there are variations from the source specification. If an interface definition requires one or more header files, one of those headers shall include the function prototype for the interface.
For source definitions of interfaces which include a reference to a header file, the contents of such header files form a part of the specification. The "Data Definitions" section provides the binary-level details for the header files from the source specifications, such as values for macros and enumerated types, as well as structure layouts, sizes and padding, etc. These data definitions, although presented in the form of header files for convenience, should not be taken a representing complete header files, as they are a supplement to the source specifications. Application developers should follow the guidelines of the source specifications when determining which header files need to be included to completely resolve all references.
Note: While the Data Definitions supplement the source specifications, this specification itself does not require conforming implementations to supply any header files.
The Program Interpreter is specified in the appropriate architecture specific part of ISO/IEC 23360.
Table 13-1 defines the library name and shared object name for the libc library
The behavior of the interfaces in this library is specified by the following specifications:
| [LFS] Large File Support |
| [LSB] This Specification |
| [RPC & XDR] RFC 1831/1832 RPC & XDR |
| [SUSv2] SUSv2 |
| [SUSv3] ISO POSIX (2003) |
| [SUSv4] POSIX 1003.1 2008 |
| [SVID.3] SVID Issue 3 |
| [SVID.4] SVID Issue 4 |
An LSB conforming implementation shall provide the generic functions for RPC specified in Table 13-2, with the full mandatory functionality as described in the referenced underlying specification.
Table 13-2. libc - RPC Function Interfaces
| authnone_create [SVID.4] | callrpc [RPC & XDR] | clnt_create [SVID.4] | clnt_pcreateerror [SVID.4] |
| clnt_perrno [SVID.4] | clnt_perror [SVID.4] | clnt_spcreateerror [SVID.4] | clnt_sperrno [SVID.4] |
| clnt_sperror [SVID.4] | clntraw_create [RPC & XDR] | clnttcp_create [RPC & XDR] | clntudp_bufcreate [RPC & XDR] |
| clntudp_create [RPC & XDR] | key_decryptsession [SVID.3] | pmap_getport [LSB] | pmap_set [LSB] |
| pmap_unset [LSB] | svc_getreqset [SVID.3] | svc_register [LSB] | svc_run [LSB] |
| svc_sendreply [LSB] | svcerr_auth [SVID.3] | svcerr_decode [SVID.3] | svcerr_noproc [SVID.3] |
| svcerr_noprog [SVID.3] | svcerr_progvers [SVID.3] | svcerr_systemerr [SVID.3] | svcerr_weakauth [SVID.3] |
| svcfd_create [RPC & XDR] | svcraw_create [RPC & XDR] | svctcp_create [LSB] | svcudp_create [LSB] |
| xdr_accepted_reply [SVID.3] | xdr_array [SVID.3] | xdr_bool [SVID.3] | xdr_bytes [SVID.3] |
| xdr_callhdr [SVID.3] | xdr_callmsg [SVID.3] | xdr_char [SVID.3] | xdr_double [SVID.3] |
| xdr_enum [SVID.3] | xdr_float [SVID.3] | xdr_free [SVID.3] | xdr_int [SVID.3] |
| xdr_long [SVID.3] | xdr_opaque [SVID.3] | xdr_opaque_auth [SVID.3] | xdr_pointer [SVID.3] |
| xdr_reference [SVID.3] | xdr_rejected_reply [SVID.3] | xdr_replymsg [SVID.3] | xdr_short [SVID.3] |
| xdr_string [SVID.3] | xdr_u_char [SVID.3] | xdr_u_int [LSB] | xdr_u_long [SVID.3] |
| xdr_u_short [SVID.3] | xdr_union [SVID.3] | xdr_vector [SVID.3] | xdr_void [SVID.3] |
| xdr_wrapstring [SVID.3] | xdrmem_create [SVID.3] | xdrrec_create [SVID.3] | xdrrec_endofrecord [RPC & XDR] |
| xdrrec_eof [SVID.3] | xdrrec_skiprecord [RPC & XDR] | xdrstdio_create [LSB] |
An LSB conforming implementation shall provide the generic deprecated functions for RPC specified in Table 13-3, with the full mandatory functionality as described in the referenced underlying specification.
Note: These interfaces are deprecated, and applications should avoid using them. These interfaces may be withdrawn in future releases of this specification.
An LSB conforming implementation shall provide the generic functions for Epoll specified in Table 13-4, with the full mandatory functionality as described in the referenced underlying specification.
An LSB conforming implementation shall provide the generic functions for System Calls specified in Table 13-5, with the full mandatory functionality as described in the referenced underlying specification.
Table 13-5. libc - System Calls Function Interfaces
| __chk_fail(GLIBC_2.3.4) [LSB] | __fxstat [LSB] | __fxstatat(GLIBC_2.4) [LSB] | __getgroups_chk(GLIBC_2.4) [LSB] |
| __getpgid [LSB] | __lxstat [LSB] | __read_chk(GLIBC_2.4) [LSB] | __readlink_chk(GLIBC_2.4) [LSB] |
| __stack_chk_fail(GLIBC_2.4) [LSB] | __xmknod [LSB] | __xmknodat(GLIBC_2.4) [LSB] | __xstat [LSB] |
| access [SUSv3] | acct [LSB] | alarm [SUSv3] | brk [SUSv2] |
| chdir [SUSv3] | chmod [SUSv3] | chown [SUSv3] | chroot [SUSv2] |
| clock [SUSv3] | close [SUSv3] | closedir [SUSv3] | creat [SUSv3] |
| dup [SUSv3] | dup2 [SUSv3] | execl [SUSv3] | execle [SUSv3] |
| execlp [SUSv3] | execv [SUSv3] | execve [SUSv3] | execvp [SUSv3] |
| exit [SUSv3] | faccessat(GLIBC_2.4) [SUSv4] | fchdir [SUSv3] | fchmod [SUSv3] |
| fchmodat(GLIBC_2.4) [SUSv4] | fchown [SUSv3] | fchownat(GLIBC_2.4) [SUSv4] | fcntl [LSB] |
| fdatasync [SUSv3] | fdopendir(GLIBC_2.4) [SUSv4] | fexecve [SUSv4] | flock [LSB] |
| fork [SUSv3] | fstatfs [LSB] | fstatvfs [SUSv3] | fsync [SUSv3] |
| ftime [SUSv3] | ftruncate [SUSv3] | getcontext [SUSv3] | getdtablesize [LSB] |
| getegid [SUSv3] | geteuid [SUSv3] | getgid [SUSv3] | getgroups [SUSv3] |
| getitimer [SUSv3] | getloadavg [LSB] | getpagesize [LSB] | getpgid [SUSv3] |
| getpgrp [SUSv3] | getpid [SUSv3] | getppid [SUSv3] | getpriority [SUSv3] |
| getrlimit [SUSv3] | getrusage [SUSv3] | getsid [SUSv3] | getuid [SUSv3] |
| getwd [SUSv3] | initgroups [LSB] | ioctl [LSB] | kill [LSB] |
| killpg [SUSv3] | lchown [SUSv3] | link [LSB] | linkat(GLIBC_2.4) [SUSv4] |
| lockf [SUSv3] | lseek [SUSv3] | mkdir [SUSv3] | mkdirat(GLIBC_2.4) [SUSv4] |
| mkfifo [SUSv3] | mkfifoat(GLIBC_2.4) [SUSv4] | mlock [SUSv3] | mlockall [SUSv3] |
| mmap [SUSv3] | mprotect [SUSv3] | mremap [LSB] | msync [SUSv3] |
| munlock [SUSv3] | munlockall [SUSv3] | munmap [SUSv3] | nanosleep [SUSv3] |
| nice [SUSv3] | open [SUSv3] | openat(GLIBC_2.4) [SUSv4] | opendir [SUSv3] |
| pathconf [SUSv3] | pause [SUSv3] | pipe [SUSv3] | poll [SUSv3] |
| pselect [SUSv3] | read [SUSv3] | readdir [SUSv3] | readdir_r [SUSv3] |
| readlink [SUSv3] | readlinkat(GLIBC_2.4) [SUSv4] | readv [SUSv3] | rename [SUSv3] |
| renameat(GLIBC_2.4) [SUSv4] | rmdir [SUSv3] | sbrk [SUSv2] | sched_get_priority_max [SUSv3] |
| sched_get_priority_min [SUSv3] | sched_getaffinity(GLIBC_2.3.4) [LSB] | sched_getparam [SUSv3] | sched_getscheduler [SUSv3] |
| sched_rr_get_interval [SUSv3] | sched_setaffinity(GLIBC_2.3.4) [LSB] | sched_setparam [SUSv3] | sched_setscheduler [LSB] |
| sched_yield [SUSv3] | select [SUSv3] | setcontext [SUSv3] | setegid [SUSv3] |
| seteuid [SUSv3] | setgid [SUSv3] | setitimer [SUSv3] | setpgid [SUSv3] |
| setpgrp [SUSv3] | setpriority [SUSv3] | setregid [SUSv3] | setreuid [SUSv3] |
| setrlimit [SUSv3] | setrlimit64 [LFS] | setsid [SUSv3] | setuid [SUSv3] |
| sleep [SUSv3] | statfs [LSB] | statvfs [SUSv3] | stime [LSB] |
| symlink [SUSv3] | symlinkat(GLIBC_2.4) [SUSv4] | sync [SUSv3] | sysconf [LSB] |
| time [SUSv3] | times [SUSv3] | truncate [SUSv3] | ulimit [SUSv3] |
| umask [SUSv3] | uname [SUSv3] | unlink [LSB] | unlinkat(GLIBC_2.4) [SUSv4] |
| utime [SUSv3] | utimes [SUSv3] | vfork [SUSv3] | wait [SUSv3] |
| wait4 [LSB] | waitid [SUSv3] | waitpid [SUSv3] | write [SUSv3] |
| writev [SUSv3] |
An LSB conforming implementation shall provide the generic deprecated functions for System Calls specified in Table 13-6, with the full mandatory functionality as described in the referenced underlying specification.
Note: These interfaces are deprecated, and applications should avoid using them. These interfaces may be withdrawn in future releases of this specification.
An LSB conforming implementation shall provide the generic functions for Standard I/O specified in Table 13-7, with the full mandatory functionality as described in the referenced underlying specification.
Table 13-7. libc - Standard I/O Function Interfaces
| _IO_feof [LSB] | _IO_getc [LSB] | _IO_putc [LSB] | _IO_puts [LSB] |
| __fgets_chk(GLIBC_2.4) [LSB] | __fgets_unlocked_chk(GLIBC_2.4) [LSB] | __fgetws_unlocked_chk(GLIBC_2.4) [LSB] | __fprintf_chk [LSB] |
| __printf_chk [LSB] | __snprintf_chk [LSB] | __sprintf_chk [LSB] | __vfprintf_chk [LSB] |
| __vprintf_chk [LSB] | __vsnprintf_chk [LSB] | __vsprintf_chk [LSB] | asprintf [LSB] |
| clearerr [SUSv3] | clearerr_unlocked [LSB] | ctermid [SUSv3] | dprintf [SUSv4] |
| fclose [SUSv3] | fdopen [SUSv3] | feof [SUSv3] | feof_unlocked [LSB] |
| ferror [SUSv3] | ferror_unlocked [LSB] | fflush [SUSv3] | fflush_unlocked [LSB] |
| fgetc [SUSv3] | fgetc_unlocked [LSB] | fgetpos [SUSv3] | fgets [SUSv3] |
| fgets_unlocked [LSB] | fgetwc_unlocked [LSB] | fgetws_unlocked [LSB] | fileno [SUSv3] |
| fileno_unlocked [LSB] | flockfile [SUSv3] | fopen [SUSv3] | fprintf [SUSv3] |
| fputc [SUSv3] | fputc_unlocked [LSB] | fputs [SUSv3] | fputs_unlocked [LSB] |
| fputwc_unlocked [LSB] | fputws_unlocked [LSB] | fread [SUSv3] | fread_unlocked [LSB] |
| freopen [SUSv3] | fscanf [LSB] | fseek [SUSv3] | fseeko [SUSv3] |
| fsetpos [SUSv3] | ftell [SUSv3] | ftello [SUSv3] | fwrite [SUSv3] |
| fwrite_unlocked [LSB] | getc [SUSv3] | getc_unlocked [SUSv3] | getchar [SUSv3] |
| getchar_unlocked [SUSv3] | getdelim [SUSv4] | getline [SUSv4] | getw [SUSv2] |
| getwchar_unlocked [LSB] | pclose [SUSv3] | popen [SUSv3] | printf [SUSv3] |
| putc [SUSv3] | putc_unlocked [SUSv3] | putchar [SUSv3] | putchar_unlocked [SUSv3] |
| puts [SUSv3] | putw [SUSv2] | putwc_unlocked [LSB] | putwchar_unlocked [LSB] |
| remove [SUSv3] | rewind [SUSv3] | rewinddir [SUSv3] | scanf [LSB] |
| seekdir [SUSv3] | setbuf [SUSv3] | setbuffer [LSB] | setvbuf [SUSv3] |
| snprintf [SUSv3] | sprintf [SUSv3] | sscanf [LSB] | telldir [SUSv3] |
| tempnam [SUSv3] | ungetc [SUSv3] | vasprintf [LSB] | vdprintf [LSB] |
| vfprintf [SUSv3] | vprintf [SUSv3] | vsnprintf [SUSv3] | vsprintf [SUSv3] |
An LSB conforming implementation shall provide the generic deprecated functions for Standard I/O specified in Table 13-8, with the full mandatory functionality as described in the referenced underlying specification.
Note: These interfaces are deprecated, and applications should avoid using them. These interfaces may be withdrawn in future releases of this specification.
An LSB conforming implementation shall provide the generic data interfaces for Standard I/O specified in Table 13-9, with the full mandatory functionality as described in the referenced underlying specification.
An LSB conforming implementation shall provide the generic functions for Signal Handling specified in Table 13-10, with the full mandatory functionality as described in the referenced underlying specification.
Table 13-10. libc - Signal Handling Function Interfaces
| __libc_current_sigrtmax [LSB] | __libc_current_sigrtmin [LSB] | __sigsetjmp [LSB] | __sysv_signal [LSB] |
| __xpg_sigpause [LSB] | bsd_signal [SUSv3] | psignal [LSB] | raise [SUSv3] |
| sigaction [SUSv3] | sigaddset [SUSv3] | sigaltstack [SUSv3] | sigandset [LSB] |
| sigdelset [SUSv3] | sigemptyset [SUSv3] | sigfillset [SUSv3] | sighold [SUSv3] |
| sigignore [SUSv3] | siginterrupt [SUSv3] | sigisemptyset [LSB] | sigismember [SUSv3] |
| siglongjmp [SUSv3] | signal [SUSv3] | sigorset [LSB] | sigpause [LSB] |
| sigpending [SUSv3] | sigprocmask [SUSv3] | sigqueue [SUSv3] | sigrelse [SUSv3] |
| sigreturn [LSB] | sigset [SUSv3] | sigsuspend [SUSv3] | sigtimedwait [SUSv3] |
| sigwait [SUSv3] | sigwaitinfo [SUSv3] |
An LSB conforming implementation shall provide the generic deprecated functions for Signal Handling specified in Table 13-11, with the full mandatory functionality as described in the referenced underlying specification.
Note: These interfaces are deprecated, and applications should avoid using them. These interfaces may be withdrawn in future releases of this specification.
An LSB conforming implementation shall provide the generic data interfaces for Signal Handling specified in Table 13-12, with the full mandatory functionality as described in the referenced underlying specification.
An LSB conforming implementation shall provide the generic functions for Localization Functions specified in Table 13-13, with the full mandatory functionality as described in the referenced underlying specification.
Table 13-13. libc - Localization Functions Function Interfaces
| bind_textdomain_codeset [LSB] | bindtextdomain [LSB] | catclose [SUSv3] | catgets [SUSv3] |
| catopen [SUSv3] | dcgettext [LSB] | dcngettext [LSB] | dgettext [LSB] |
| dngettext [LSB] | duplocale(GLIBC_2.3) [LSB] | freelocale(GLIBC_2.3) [LSB] | gettext [LSB] |
| iconv [SUSv3] | iconv_close [SUSv3] | iconv_open [SUSv3] | localeconv [SUSv3] |
| newlocale(GLIBC_2.3) [LSB] | ngettext [LSB] | nl_langinfo [SUSv3] | setlocale [SUSv3] |
| textdomain [LSB] | uselocale(GLIBC_2.3) [LSB] |
An LSB conforming implementation shall provide the generic data interfaces for Localization Functions specified in Table 13-14, with the full mandatory functionality as described in the referenced underlying specification.
An LSB conforming implementation shall provide the generic functions for Posix Spawn Option specified in Table 13-15, with the full mandatory functionality as described in the referenced underlying specification.
Table 13-15. libc - Posix Spawn Option Function Interfaces
| posix_spawn [SUSv3] | posix_spawn_file_actions_addclose [SUSv3] | posix_spawn_file_actions_adddup2 [SUSv3] | posix_spawn_file_actions_addopen [SUSv3] |
| posix_spawn_file_actions_destroy [SUSv3] | posix_spawn_file_actions_init [SUSv3] | posix_spawnattr_destroy [SUSv3] | posix_spawnattr_getflags [SUSv3] |
| posix_spawnattr_getpgroup [SUSv3] | posix_spawnattr_getschedparam [SUSv3] | posix_spawnattr_getschedpolicy [SUSv3] | posix_spawnattr_getsigdefault [SUSv3] |
| posix_spawnattr_getsigmask [SUSv3] | posix_spawnattr_init [SUSv3] | posix_spawnattr_setflags [SUSv3] | posix_spawnattr_setpgroup [SUSv3] |
| posix_spawnattr_setschedparam [SUSv3] | posix_spawnattr_setschedpolicy [SUSv3] | posix_spawnattr_setsigdefault [SUSv3] | posix_spawnattr_setsigmask [SUSv3] |
| posix_spawnp [SUSv3] |
An LSB conforming implementation shall provide the generic functions for Posix Advisory Option specified in Table 13-16, with the full mandatory functionality as described in the referenced underlying specification.
An LSB conforming implementation shall provide the generic functions for Socket Interface specified in Table 13-17, with the full mandatory functionality as described in the referenced underlying specification.
Table 13-17. libc - Socket Interface Function Interfaces
| __gethostname_chk(GLIBC_2.4) [LSB] | __h_errno_location [LSB] | __recv_chk(GLIBC_2.4) [LSB] | __recvfrom_chk(GLIBC_2.4) [LSB] |
| accept [SUSv3] | bind [SUSv3] | bindresvport [LSB] | connect [SUSv3] |
| gethostid [SUSv3] | gethostname [SUSv3] | getpeername [SUSv3] | getsockname [SUSv3] |
| getsockopt [LSB] | if_freenameindex [SUSv3] | if_indextoname [SUSv3] | if_nameindex [SUSv3] |
| if_nametoindex [SUSv3] | listen [SUSv3] | recv [SUSv3] | recvfrom [SUSv3] |
| recvmsg [SUSv3] | send [SUSv4] | sendmsg [SUSv4] | sendto [SUSv4] |
| setsockopt [LSB] | shutdown [SUSv3] | sockatmark [SUSv3] | socket [SUSv3] |
| socketpair [SUSv3] |
An LSB conforming implementation shall provide the generic data interfaces for Socket Interface specified in Table 13-18, with the full mandatory functionality as described in the referenced underlying specification.
An LSB conforming implementation shall provide the generic functions for Wide Characters specified in Table 13-19, with the full mandatory functionality as described in the referenced underlying specification.
Table 13-19. libc - Wide Characters Function Interfaces
| __fgetws_chk(GLIBC_2.4) [LSB] | __fwprintf_chk(GLIBC_2.4) [LSB] | __mbsnrtowcs_chk(GLIBC_2.4) [LSB] | __mbsrtowcs_chk(GLIBC_2.4) [LSB] |
| __mbstowcs_chk(GLIBC_2.4) [LSB] | __swprintf_chk(GLIBC_2.4) [LSB] | __vfwprintf_chk(GLIBC_2.4) [LSB] | __vswprintf_chk(GLIBC_2.4) [LSB] |
| __vwprintf_chk(GLIBC_2.4) [LSB] | __wcpcpy_chk(GLIBC_2.4) [LSB] | __wcpncpy_chk(GLIBC_2.4) [LSB] | __wcrtomb_chk(GLIBC_2.4) [LSB] |
| __wcscat_chk(GLIBC_2.4) [LSB] | __wcscpy_chk(GLIBC_2.4) [LSB] | __wcsncat_chk(GLIBC_2.4) [LSB] | __wcsncpy_chk(GLIBC_2.4) [LSB] |
| __wcsnrtombs_chk(GLIBC_2.4) [LSB] | __wcsrtombs_chk(GLIBC_2.4) [LSB] | __wcstod_internal [LSB] | __wcstof_internal [LSB] |
| __wcstol_internal [LSB] | __wcstold_internal [LSB] | __wcstombs_chk(GLIBC_2.4) [LSB] | __wcstoul_internal [LSB] |
| __wctomb_chk(GLIBC_2.4) [LSB] | __wmemcpy_chk(GLIBC_2.4) [LSB] | __wmemmove_chk(GLIBC_2.4) [LSB] | __wmempcpy_chk(GLIBC_2.4) [LSB] |
| __wmemset_chk(GLIBC_2.4) [LSB] | __wprintf_chk(GLIBC_2.4) [LSB] | btowc [SUSv3] | fgetwc [SUSv3] |
| fgetws [SUSv3] | fputwc [SUSv3] | fputws [SUSv3] | fwide [SUSv3] |
| fwprintf [SUSv3] | fwscanf [LSB] | getwc [SUSv3] | getwchar [SUSv3] |
| mblen [SUSv3] | mbrlen [SUSv3] | mbrtowc [SUSv3] | mbsinit [SUSv3] |
| mbsnrtowcs [LSB] | mbsrtowcs [SUSv3] | mbstowcs [SUSv3] | mbtowc [SUSv3] |
| putwc [SUSv3] | putwchar [SUSv3] | swprintf [SUSv3] | swscanf [LSB] |
| towctrans [SUSv3] | towlower [SUSv3] | towupper [SUSv3] | ungetwc [SUSv3] |
| vfwprintf [SUSv3] | vfwscanf [LSB] | vswprintf [SUSv3] | vswscanf [LSB] |
| vwprintf [SUSv3] | vwscanf [LSB] | wcpcpy [LSB] | wcpncpy [LSB] |
| wcrtomb [SUSv3] | wcscasecmp [LSB] | wcscat [SUSv3] | wcschr [SUSv3] |
| wcscmp [SUSv3] | wcscoll [SUSv3] | wcscpy [SUSv3] | wcscspn [SUSv3] |
| wcsdup [LSB] | wcsftime [SUSv3] | wcslen [SUSv3] | wcsncasecmp [LSB] |
| wcsncat [SUSv3] | wcsncmp [SUSv3] | wcsncpy [SUSv3] | wcsnlen [LSB] |
| wcsnrtombs [LSB] | wcspbrk [SUSv3] | wcsrchr [SUSv3] | wcsrtombs [SUSv3] |
| wcsspn [SUSv3] | wcsstr [SUSv3] | wcstod [SUSv3] | wcstof [SUSv3] |
| wcstoimax [SUSv3] | wcstok [SUSv3] | wcstol [SUSv3] | wcstold [SUSv3] |
| wcstoll [SUSv3] | wcstombs [SUSv3] | wcstoq [LSB] | wcstoul [SUSv3] |
| wcstoull [SUSv3] | wcstoumax [SUSv3] | wcstouq [LSB] | wcswcs [SUSv3] |
| wcswidth [SUSv3] | wcsxfrm [SUSv3] | wctob [SUSv3] | wctomb [SUSv3] |
| wctrans [SUSv3] | wctype [SUSv3] | wcwidth [SUSv3] | wmemchr [SUSv3] |
| wmemcmp [SUSv3] | wmemcpy [SUSv3] | wmemmove [SUSv3] | wmemset [SUSv3] |
| wprintf [SUSv3] | wscanf [LSB] |
An LSB conforming implementation shall provide the generic functions for String Functions specified in Table 13-20, with the full mandatory functionality as described in the referenced underlying specification.
Table 13-20. libc - String Functions Function Interfaces
| __memcpy_chk(GLIBC_2.3.4) [LSB] | __memmove_chk(GLIBC_2.3.4) [LSB] | __mempcpy [LSB] | __mempcpy_chk(GLIBC_2.3.4) [LSB] |
| __memset_chk(GLIBC_2.3.4) [LSB] | __rawmemchr [LSB] | __stpcpy [LSB] | __stpcpy_chk(GLIBC_2.3.4) [LSB] |
| __stpncpy_chk(GLIBC_2.4) [LSB] | __strcat_chk(GLIBC_2.3.4) [LSB] | __strcpy_chk(GLIBC_2.3.4) [LSB] | __strdup [LSB] |
| __strncat_chk(GLIBC_2.3.4) [LSB] | __strncpy_chk(GLIBC_2.3.4) [LSB] | __strtod_internal [LSB] | __strtof_internal [LSB] |
| __strtok_r [LSB] | __strtol_internal [LSB] | __strtold_internal [LSB] | __strtoll_internal [LSB] |
| __strtoul_internal [LSB] | __strtoull_internal [LSB] | __xpg_strerror_r(GLIBC_2.3.4) [LSB] | bcmp [SUSv3] |
| bcopy [SUSv3] | bzero [SUSv3] | ffs [SUSv3] | index [SUSv3] |
| memccpy [SUSv3] | memchr [SUSv3] | memcmp [SUSv3] | memcpy [SUSv3] |
| memmove [SUSv3] | memrchr [LSB] | memset [SUSv3] | rindex [SUSv3] |
| stpcpy [LSB] | stpncpy [LSB] | strcasecmp [SUSv3] | strcasestr [LSB] |
| strcat [SUSv3] | strchr [SUSv3] | strcmp [SUSv3] | strcoll [SUSv3] |
| strcpy [SUSv3] | strcspn [SUSv3] | strdup [SUSv3] | strerror [SUSv3] |
| strerror_r [LSB] | strfmon [SUSv3] | strftime [SUSv3] | strlen [SUSv3] |
| strncasecmp [SUSv3] | strncat [SUSv3] | strncmp [SUSv3] | strncpy [SUSv3] |
| strndup [LSB] | strnlen [LSB] | strpbrk [SUSv3] | strptime [LSB] |
| strrchr [SUSv3] | strsep [LSB] | strsignal [LSB] | strspn [SUSv3] |
| strstr [SUSv3] | strtof [SUSv3] | strtoimax [SUSv3] | strtok [SUSv3] |
| strtok_r [SUSv3] | strtold [SUSv3] | strtoll [SUSv3] | strtoq [LSB] |
| strtoull [SUSv3] | strtoumax [SUSv3] | strtouq [LSB] | strxfrm [SUSv3] |
| swab [SUSv3] |
An LSB conforming implementation shall provide the generic deprecated functions for String Functions specified in Table 13-21, with the full mandatory functionality as described in the referenced underlying specification.
Note: These interfaces are deprecated, and applications should avoid using them. These interfaces may be withdrawn in future releases of this specification.
An LSB conforming implementation shall provide the generic functions for IPC Functions specified in Table 13-22, with the full mandatory functionality as described in the referenced underlying specification.
An LSB conforming implementation shall provide the generic functions for Regular Expressions specified in Table 13-23, with the full mandatory functionality as described in the referenced underlying specification.
An LSB conforming implementation shall provide the generic functions for Character Type Functions specified in Table 13-24, with the full mandatory functionality as described in the referenced underlying specification.
Table 13-24. libc - Character Type Functions Function Interfaces
| __ctype_b_loc(GLIBC_2.3) [LSB] | __ctype_get_mb_cur_max [LSB] | __ctype_tolower_loc(GLIBC_2.3) [LSB] | __ctype_toupper_loc(GLIBC_2.3) [LSB] |
| _tolower [SUSv3] | _toupper [SUSv3] | isalnum [SUSv3] | isalpha [SUSv3] |
| isascii [SUSv3] | iscntrl [SUSv3] | isdigit [SUSv3] | isgraph [SUSv3] |
| islower [SUSv3] | isprint [SUSv3] | ispunct [SUSv3] | isspace [SUSv3] |
| isupper [SUSv3] | iswalnum [SUSv3] | iswalpha [SUSv3] | iswblank [SUSv3] |
| iswcntrl [SUSv3] | iswctype [SUSv3] | iswdigit [SUSv3] | iswgraph [SUSv3] |
| iswlower [SUSv3] | iswprint [SUSv3] | iswpunct [SUSv3] | iswspace [SUSv3] |
| iswupper [SUSv3] | iswxdigit [SUSv3] | isxdigit [SUSv3] | toascii [SUSv3] |
| tolower [SUSv3] | toupper [SUSv3] |
An LSB conforming implementation shall provide the generic functions for Time Manipulation specified in Table 13-25, with the full mandatory functionality as described in the referenced underlying specification.
Table 13-25. libc - Time Manipulation Function Interfaces
| adjtime [LSB] | asctime [SUSv3] | asctime_r [SUSv3] | ctime [SUSv3] |
| ctime_r [SUSv3] | difftime [SUSv3] | gmtime [SUSv3] | gmtime_r [SUSv3] |
| localtime [SUSv3] | localtime_r [SUSv3] | mktime [SUSv3] | tzset [SUSv3] |
| ualarm [SUSv3] |
An LSB conforming implementation shall provide the generic data interfaces for Time Manipulation specified in Table 13-26, with the full mandatory functionality as described in the referenced underlying specification.
An LSB conforming implementation shall provide the generic functions for Terminal Interface Functions specified in Table 13-27, with the full mandatory functionality as described in the referenced underlying specification.
Table 13-27. libc - Terminal Interface Functions Function Interfaces
| cfgetispeed [SUSv3] | cfgetospeed [SUSv3] | cfmakeraw [LSB] | cfsetispeed [SUSv3] |
| cfsetospeed [SUSv3] | cfsetspeed [LSB] | tcdrain [SUSv3] | tcflow [SUSv3] |
| tcflush [SUSv3] | tcgetattr [SUSv3] | tcgetpgrp [SUSv3] | tcgetsid [SUSv3] |
| tcsendbreak [SUSv3] | tcsetattr [SUSv3] | tcsetpgrp [SUSv3] |
An LSB conforming implementation shall provide the generic functions for System Database Interface specified in Table 13-28, with the full mandatory functionality as described in the referenced underlying specification.
Table 13-28. libc - System Database Interface Function Interfaces
| endgrent [SUSv3] | endprotoent [SUSv3] | endpwent [SUSv3] | endservent [SUSv3] |
| endutent [LSB] | endutxent [SUSv3] | getgrent [SUSv3] | getgrent_r [LSB] |
| getgrgid [SUSv3] | getgrgid_r [SUSv3] | getgrnam [SUSv3] | getgrnam_r [SUSv3] |
| getgrouplist [LSB] | gethostbyaddr [SUSv3] | gethostbyaddr_r [LSB] | gethostbyname [SUSv3] |
| gethostbyname2 [LSB] | gethostbyname2_r [LSB] | gethostbyname_r [LSB] | getprotobyname [SUSv3] |
| getprotobyname_r [LSB] | getprotobynumber [SUSv3] | getprotobynumber_r [LSB] | getprotoent [SUSv3] |
| getprotoent_r [LSB] | getpwent [SUSv3] | getpwent_r [LSB] | getpwnam [SUSv3] |
| getpwnam_r [SUSv3] | getpwuid [SUSv3] | getpwuid_r [SUSv3] | getservbyname [SUSv3] |
| getservbyname_r [LSB] | getservbyport [SUSv3] | getservbyport_r [LSB] | getservent [SUSv3] |
| getservent_r [LSB] | getutent [LSB] | getutent_r [LSB] | getutxent [SUSv3] |
| getutxid [SUSv3] | getutxline [SUSv3] | pututxline [SUSv3] | setgrent [SUSv3] |
| setgroups [LSB] | setprotoent [SUSv3] | setpwent [SUSv3] | setservent [SUSv3] |
| setutent [LSB] | setutxent [SUSv3] | utmpname [LSB] |
An LSB conforming implementation shall provide the generic deprecated functions for System Database Interface specified in Table 13-29, with the full mandatory functionality as described in the referenced underlying specification.
Note: These interfaces are deprecated, and applications should avoid using them. These interfaces may be withdrawn in future releases of this specification.
An LSB conforming implementation shall provide the generic functions for Language Support specified in Table 13-30, with the full mandatory functionality as described in the referenced underlying specification.
An LSB conforming implementation shall provide the generic functions for Large File Support specified in Table 13-31, with the full mandatory functionality as described in the referenced underlying specification.
Table 13-31. libc - Large File Support Function Interfaces
| __fxstat64 [LSB] | __fxstatat64(GLIBC_2.4) [LSB] | __lxstat64 [LSB] | __xstat64 [LSB] |
| creat64 [LFS] | fgetpos64 [LFS] | fopen64 [LFS] | freopen64 [LFS] |
| fseeko64 [LFS] | fsetpos64 [LFS] | fstatfs64 [LSB] | fstatvfs64 [LFS] |
| ftello64 [LFS] | ftruncate64 [LFS] | ftw64 [LFS] | getrlimit64 [LFS] |
| lockf64 [LFS] | mkstemp64 [LSB] | mmap64 [LFS] | nftw64 [LFS] |
| openat64(GLIBC_2.4) [LSB] | posix_fadvise64 [LSB] | posix_fallocate64 [LSB] | readdir64 [LFS] |
| readdir64_r [LSB] | statfs64 [LSB] | statvfs64 [LFS] | tmpfile64 [LFS] |
| truncate64 [LFS] |
An LSB conforming implementation shall provide the generic deprecated functions for Large File Support specified in Table 13-32, with the full mandatory functionality as described in the referenced underlying specification.
Note: These interfaces are deprecated, and applications should avoid using them. These interfaces may be withdrawn in future releases of this specification.
An LSB conforming implementation shall provide the generic functions for Inotify specified in Table 13-33, with the full mandatory functionality as described in the referenced underlying specification.
An LSB conforming implementation shall provide the generic functions for Standard Library specified in Table 13-34, with the full mandatory functionality as described in the referenced underlying specification.
Table 13-34. libc - Standard Library Function Interfaces
| _Exit [SUSv3] | __assert_fail [LSB] | __confstr_chk(GLIBC_2.4) [LSB] | __cxa_atexit [LSB] |
| __cxa_finalize [LSB] | __errno_location [LSB] | __fpending [LSB] | __getcwd_chk(GLIBC_2.4) [LSB] |
| __getlogin_r_chk(GLIBC_2.4) [LSB] | __getpagesize [LSB] | __isinf [LSB] | __isinff [LSB] |
| __isinfl [LSB] | __isnan [LSB] | __isnanf [LSB] | __isnanl [LSB] |
| __pread64_chk(GLIBC_2.4) [LSB] | __pread_chk(GLIBC_2.4) [LSB] | __realpath_chk(GLIBC_2.4) [LSB] | __sysconf [LSB] |
| __syslog_chk(GLIBC_2.4) [LSB] | __ttyname_r_chk(GLIBC_2.4) [LSB] | __vsyslog_chk(GLIBC_2.4) [LSB] | __xpg_basename [LSB] |
| _exit [SUSv3] | _longjmp [SUSv3] | _setjmp [SUSv3] | a64l [SUSv3] |
| abort [SUSv3] | abs [SUSv3] | alphasort [SUSv4] | alphasort64 [LSB] |
| atof [SUSv3] | atoi [SUSv3] | atol [SUSv3] | atoll [SUSv3] |
| basename [LSB] | bsearch [SUSv3] | calloc [SUSv3] | closelog [SUSv3] |
| confstr [SUSv3] | cuserid [SUSv2] | daemon [LSB] | dirfd [SUSv4] |
| dirname [SUSv3] | div [SUSv3] | drand48 [SUSv3] | drand48_r [LSB] |
| ecvt [SUSv3] | erand48 [SUSv3] | erand48_r [LSB] | err [LSB] |
| error [LSB] | errx [LSB] | fcvt [SUSv3] | fmemopen [SUSv4] |
| fmtmsg [SUSv3] | fnmatch [SUSv3] | fpathconf [SUSv3] | free [SUSv3] |
| freeaddrinfo [SUSv3] | ftrylockfile [SUSv3] | ftw [SUSv3] | funlockfile [SUSv3] |
| gai_strerror [SUSv3] | gcvt [SUSv3] | getaddrinfo [SUSv3] | getcwd [SUSv3] |
| getdate [SUSv3] | getdomainname [LSB] | getenv [SUSv3] | getlogin [SUSv3] |
| getlogin_r [SUSv3] | getnameinfo [SUSv3] | getopt [LSB] | getopt_long [LSB] |
| getopt_long_only [LSB] | getsubopt [SUSv3] | gettimeofday [SUSv3] | glob [SUSv3] |
| glob64 [LSB] | globfree [SUSv3] | globfree64 [LSB] | grantpt [SUSv3] |
| hcreate [SUSv3] | hcreate_r [LSB] | hdestroy [SUSv3] | hdestroy_r [LSB] |
| hsearch [SUSv3] | hsearch_r [LSB] | htonl [SUSv3] | htons [SUSv3] |
| imaxabs [SUSv3] | imaxdiv [SUSv3] | inet_addr [SUSv3] | inet_aton [LSB] |
| inet_ntoa [SUSv3] | inet_ntop [SUSv3] | inet_pton [SUSv3] | initstate [SUSv3] |
| initstate_r [LSB] | insque [SUSv3] | isatty [SUSv3] | isblank [SUSv3] |
| jrand48 [SUSv3] | jrand48_r [LSB] | l64a [SUSv3] | labs [SUSv3] |
| lcong48 [SUSv3] | lcong48_r [LSB] | ldiv [SUSv3] | lfind [SUSv3] |
| llabs [SUSv3] | lldiv [SUSv3] | longjmp [SUSv3] | lrand48 [SUSv3] |
| lrand48_r [LSB] | lsearch [SUSv3] | makecontext [SUSv3] | malloc [SUSv3] |
| memmem [LSB] | mkdtemp [SUSv4] | mkstemp [SUSv3] | mktemp [SUSv3] |
| mrand48 [SUSv3] | mrand48_r [LSB] | nftw [SUSv3] | nrand48 [SUSv3] |
| nrand48_r [LSB] | ntohl [SUSv3] | ntohs [SUSv3] | open_memstream [SUSv4] |
| open_wmemstream(GLIBC_2.4) [SUSv4] | openlog [SUSv3] | perror [SUSv3] | posix_openpt [SUSv3] |
| ptsname [SUSv3] | putenv [SUSv3] | qsort [SUSv3] | rand [SUSv3] |
| rand_r [SUSv3] | random [SUSv3] | random_r [LSB] | realloc [SUSv3] |
| realpath [SUSv3] | remque [SUSv3] | scandir [SUSv4] | scandir64 [LSB] |
| seed48 [SUSv3] | seed48_r [LSB] | sendfile [LSB] | sendfile64(GLIBC_2.3) [LSB] |
| setenv [SUSv3] | sethostname [LSB] | setlogmask [SUSv3] | setstate [SUSv3] |
| setstate_r [LSB] | srand [SUSv3] | srand48 [SUSv3] | srand48_r [LSB] |
| srandom [SUSv3] | srandom_r [LSB] | strtod [SUSv3] | strtol [SUSv3] |
| strtoul [SUSv3] | swapcontext [SUSv3] | syslog [SUSv3] | system [LSB] |
| tdelete [SUSv3] | tfind [SUSv3] | tmpfile [SUSv3] | tmpnam [SUSv3] |
| tsearch [SUSv3] | ttyname [SUSv3] | ttyname_r [SUSv3] | twalk [SUSv3] |
| unlockpt [SUSv3] | unsetenv [SUSv3] | usleep [SUSv3] | verrx [LSB] |
| vfscanf [LSB] | vscanf [LSB] | vsscanf [LSB] | vsyslog [LSB] |
| warn [LSB] | warnx [LSB] | wordexp [SUSv3] | wordfree [SUSv3] |
An LSB conforming implementation shall provide the generic deprecated functions for Standard Library specified in Table 13-35, with the full mandatory functionality as described in the referenced underlying specification.
Note: These interfaces are deprecated, and applications should avoid using them. These interfaces may be withdrawn in future releases of this specification.
Table 13-35. libc - Standard Library Deprecated Function Interfaces
| basename [LSB] | getdomainname [LSB] | inet_aton [LSB] | tmpnam [SUSv3] |
An LSB conforming implementation shall provide the generic data interfaces for Standard Library specified in Table 13-36, with the full mandatory functionality as described in the referenced underlying specification.
This section defines global identifiers and their values that are associated with interfaces contained in libc. These definitions are organized into groups that correspond to system headers. This convention is used as a convenience for the reader, and does not imply the existence of these headers, or their content. Where an interface is defined as requiring a particular system header file all of the data definitions for that system header file presented here shall be in effect.
This section gives data definitions to promote binary application portability, not to repeat source interface definitions available elsewhere. System providers and application developers should use this ABI to supplement - not to replace - source interface definition specifications.
This specification uses the ISO C (1999) C Language as the reference programming language, and data definitions are specified in ISO C format. The C language is used here as a convenient notation. Using a C language description of these data objects does not preclude their use by other programming languages.
extern uint32_t htonl(uint32_t); extern uint16_t htons(uint16_t); extern in_addr_t inet_addr(const char *); extern int inet_aton(const char *, struct in_addr *); extern char *inet_ntoa(struct in_addr); extern const char *inet_ntop(int, const void *, char *, socklen_t); extern int inet_pton(int, const char *, void *); extern uint32_t ntohl(uint32_t); extern uint16_t ntohs(uint16_t); |
#ifdef NDEBUG #define assert(expr) ((void)0) #else #define assert(expr) ((void) ((expr) ? 0 : (__assert_fail (#expr, __FILE__, __LINE__, __PRETTY_FUNCTION__), 0))) #endif extern void __assert_fail(const char *, const char *, unsigned int, const char *); |
#define C_IXOTH 000001 #define C_IWOTH 000002 #define C_IROTH 000004 #define C_IXGRP 000010 #define C_IWGRP 000020 #define C_IRGRP 000040 #define C_IXUSR 000100 #define C_IWUSR 000200 #define C_IRUSR 000400 #define C_ISVTX 001000 #define C_ISGID 002000 #define C_ISUID 004000 #define C_ISFIFO 010000 #define C_ISREG 0100000 #define C_ISCTG 0110000 #define C_ISLNK 0120000 #define C_ISSOCK 0140000 #define C_ISCHR 020000 #define C_ISDIR 040000 #define C_ISBLK 060000 #define MAGIC "070707" |
extern int _tolower(int); extern int _toupper(int); extern int isalnum(int); extern int isalpha(int); extern int isascii(int); extern int iscntrl(int); extern int isdigit(int); extern int isgraph(int); extern int islower(int); extern int isprint(int); extern int ispunct(int); extern int isspace(int); extern int isupper(int); extern int isxdigit(int); extern int toascii(int); extern int tolower(int); extern int toupper(int); extern int isblank(int); extern const unsigned short **__ctype_b_loc(void); extern const int32_t **__ctype_toupper_loc(void); extern const int32_t **__ctype_tolower_loc(void); |
typedef struct __dirstream DIR;
struct dirent {
long int d_ino;
off_t d_off;
unsigned short d_reclen;
unsigned char d_type;
char d_name[256];
};
struct dirent64 {
uint64_t d_ino;
int64_t d_off;
unsigned short d_reclen;
unsigned char d_type;
char d_name[256];
};
extern int readdir64_r(DIR *, struct dirent64 *, struct dirent64 **);
extern int alphasort(const struct dirent **, const struct dirent **);
extern int alphasort64(const struct dirent64 **, const struct dirent64 **);
extern int dirfd(DIR *);
extern void rewinddir(DIR *);
extern int scandir(const char *, struct dirent ***,
int (*)(const struct dirent *)
, int (*)(const struct dirent *, const struct dirent *)
);
extern void seekdir(DIR *, long int);
extern long int telldir(DIR *);
extern int closedir(DIR *);
extern DIR *opendir(const char *);
extern struct dirent *readdir(DIR *);
extern struct dirent64 *readdir64(DIR *);
extern int readdir_r(DIR *, struct dirent *, struct dirent **);
extern int scandir64(const char *, struct dirent64 ***,
int (*)(const struct dirent64 *)
, int (*)(const struct dirent64 *,
const struct dirent64 *)
);
extern DIR *fdopendir(int); |
#define __LITTLE_ENDIAN 1234 #define __BIG_ENDIAN 4321 #define BIG_ENDIAN __BIG_ENDIAN #define BYTE_ORDER __BYTE_ORDER #define LITTLE_ENDIAN __LITTLE_ENDIAN |
extern void err(int, const char *, ...); extern void errx(int, const char *, ...); extern void warn(const char *, ...); extern void warnx(const char *, ...); extern void error(int, int, const char *, ...); |
#define errno (*__errno_location()) #define EPERM 1 /* Operation not permitted */ #define ECHILD 10 /* No child processes */ #define ENETDOWN 100 /* Network is down */ #define ENETUNREACH 101 /* Network is unreachable */ #define ENETRESET 102 /* Network dropped connection because of reset */ #define ECONNABORTED 103 /* Software caused connection abort */ #define ECONNRESET 104 /* Connection reset by peer */ #define ENOBUFS 105 /* No buffer space available */ #define EISCONN 106 /* Transport endpoint is already connected */ #define ENOTCONN 107 /* Transport endpoint is not connected */ #define ESHUTDOWN 108 /* Cannot send after transport endpoint shutdown */ #define ETOOMANYREFS 109 /* Too many references: cannot splice */ #define EAGAIN 11 /* Try again */ #define ETIMEDOUT 110 /* Connection timed out */ #define ECONNREFUSED 111 /* Connection refused */ #define EHOSTDOWN 112 /* Host is down */ #define EHOSTUNREACH 113 /* No route to host */ #define EALREADY 114 /* Operation already in progress */ #define EINPROGRESS 115 /* Operation now in progress */ #define ESTALE 116 /* Stale NFS file handle */ #define EUCLEAN 117 /* Structure needs cleaning */ #define ENOTNAM 118 /* Not a XENIX named type file */ #define ENAVAIL 119 /* No XENIX semaphores available */ #define ENOMEM 12 /* Out of memory */ #define EISNAM 120 /* Is a named type file */ #define EREMOTEIO 121 /* Remote I/O error */ #define EDQUOT 122 /* Quota exceeded */ #define ENOMEDIUM 123 /* No medium found */ #define EMEDIUMTYPE 124 /* Wrong medium type */ #define ECANCELED 125 /* Operation Canceled */ #define EACCES 13 /* Permission denied */ #define EFAULT 14 /* Bad address */ #define ENOTBLK 15 /* Block device required */ #define EBUSY 16 /* Device or resource busy */ #define EEXIST 17 /* File exists */ #define EXDEV 18 /* Cross-device link */ #define ENODEV 19 /* No such device */ #define ENOENT 2 /* No such file or directory */ #define ENOTDIR 20 /* Not a directory */ #define EISDIR 21 /* Is a directory */ #define EINVAL 22 /* Invalid argument */ #define ENFILE 23 /* File table overflow */ #define EMFILE 24 /* Too many open files */ #define ENOTTY 25 /* Not a typewriter */ #define ETXTBSY 26 /* Text file busy */ #define EFBIG 27 /* File too large */ #define ENOSPC 28 /* No space left on device */ #define ESPIPE 29 /* Illegal seek */ #define ESRCH 3 /* No such process */ #define EROFS 30 /* Read-only file system */ #define EMLINK 31 /* Too many links */ #define EPIPE 32 /* Broken pipe */ #define EDOM 33 /* Math argument out of domain of func */ #define ERANGE 34 /* Math result not representable */ #define EDEADLK 35 /* Resource deadlock would occur */ #define ENAMETOOLONG 36 /* File name too long */ #define ENOLCK 37 /* No record locks available */ #define ENOSYS 38 /* Function not implemented */ #define ENOTEMPTY 39 /* Directory not empty */ #define EINTR 4 /* Interrupted system call */ #define ELOOP 40 /* Too many symbolic links encountered */ #define ENOMSG 42 /* No message of desired type */ #define EIDRM 43 /* Identifier removed */ #define ECHRNG 44 /* Channel number out of range */ #define EL2NSYNC 45 /* Level 2 not synchronized */ #define EL3HLT 46 /* Level 3 halted */ #define EL3RST 47 /* Level 3 reset */ #define ELNRNG 48 /* Link number out of range */ #define EUNATCH 49 /* Protocol driver not attached */ #define EIO 5 /* I/O error */ #define ENOANO 55 /* No anode */ #define EBADRQC 56 /* Invalid request code */ #define EBADSLT 57 /* Invalid slot */ #define EBFONT 59 /* Bad font file format */ #define ENXIO 6 /* No such device or address */ #define ENOSTR 60 /* Device not a stream */ #define ENODATA 61 /* No data available */ #define ETIME 62 /* Timer expired */ #define ENOSR 63 /* Out of streams resources */ #define ENONET 64 /* Machine is not on the network */ #define ENOPKG 65 /* Package not installed */ #define EREMOTE 66 /* Object is remote */ #define ENOLINK 67 /* Link has been severed */ #define EADV 68 /* Advertise error */ #define ESRMNT 69 /* Srmount error */ #define E2BIG 7 /* Argument list too long */ #define ECOMM 70 /* Communication error on send */ #define EPROTO 71 /* Protocol error */ #define EMULTIHOP 72 /* Multihop attempted */ #define EDOTDOT 73 /* RFS specific error */ #define EBADMSG 74 /* Not a data message */ #define EOVERFLOW 75 /* Value too large for defined data type */ #define ENOTUNIQ 76 /* Name not unique on network */ #define EBADFD 77 /* File descriptor in bad state */ #define EREMCHG 78 /* Remote address changed */ #define ELIBACC 79 /* Can not access a needed shared library */ #define ENOEXEC 8 /* Exec format error */ #define ELIBBAD 80 /* Accessing a corrupted shared library */ #define ELIBSCN 81 /* .lib section in a.out corrupted */ #define ELIBMAX 82 /* Attempting to link in too many shared libraries */ #define ELIBEXEC 83 /* Cannot exec a shared library directly */ #define EILSEQ 84 /* Illegal byte sequence */ #define ERESTART 85 /* Interrupted system call should be restarted */ #define ESTRPIPE 86 /* Streams pipe error */ #define EUSERS 87 /* Too many users */ #define ENOTSOCK 88 /* Socket operation on non-socket */ #define EDESTADDRREQ 89 /* Destination address required */ #define EBADF 9 /* Bad file number */ #define EMSGSIZE 90 /* Message too long */ #define EPROTOTYPE 91 /* Protocol wrong type for socket */ #define ENOPROTOOPT 92 /* Protocol not available */ #define EPROTONOSUPPORT 93 /* Protocol not supported */ #define ESOCKTNOSUPPORT 94 /* Socket type not supported */ #define EOPNOTSUPP 95 /* Operation not supported on transport endpoint */ #define EPFNOSUPPORT 96 /* Protocol family not supported */ #define EAFNOSUPPORT 97 /* Address family not supported by protocol */ #define EADDRINUSE 98 /* Address already in use */ #define EADDRNOTAVAIL 99 /* Cannot assign requested address */ #define EWOULDBLOCK EAGAIN /* Operation would block */ #define ENOTSUP EOPNOTSUPP extern int *__errno_location(void); |
#define POSIX_FADV_NORMAL 0
#define O_RDONLY 00
#define O_ACCMODE 0003
#define O_WRONLY 01
#define O_CREAT 0100
#define O_TRUNC 01000
#define O_DSYNC 010000
#define O_RSYNC 010000
#define O_SYNC 010000
#define O_RDWR 02
#define O_EXCL 0200
#define O_APPEND 02000
#define O_ASYNC 020000
#define O_NOCTTY 0400
#define O_NDELAY 04000
#define O_NONBLOCK 04000
#define FD_CLOEXEC 1
#define POSIX_FADV_RANDOM 1
#define POSIX_FADV_SEQUENTIAL 2
#define POSIX_FADV_WILLNEED 3
struct flock {
short l_type;
short l_whence;
off_t l_start;
off_t l_len;
pid_t l_pid;
};
struct flock64 {
short l_type;
short l_whence;
loff_t l_start;
loff_t l_len;
pid_t l_pid;
};
#define AT_FDCWD -100
#define AT_SYMLINK_NOFOLLOW 0x100
#define AT_EACCESS 0x200
#define AT_REMOVEDIR 0x200
#define AT_SYMLINK_FOLLOW 0x400
#define F_DUPFD 0
#define F_RDLCK 0
#define F_GETFD 1
#define F_WRLCK 1
#define F_SETSIG 10
#define F_GETSIG 11
#define F_SETFD 2
#define F_UNLCK 2
#define F_GETFL 3
#define F_SETFL 4
#define F_GETLK 5
#define F_SETLK 6
#define F_SETLKW 7
#define F_SETOWN 8
#define F_GETOWN 9
extern int posix_fadvise(int, off_t, off_t, int);
extern int posix_fallocate(int, off_t, off_t);
extern int posix_fadvise64(int, off64_t, off64_t, int);
extern int posix_fallocate64(int, off64_t, off64_t);
extern int creat(const char *, mode_t);
extern int creat64(const char *, mode_t);
extern int fcntl(int, int, ...);
extern int open(const char *, int, ...);
extern int open64(const char *, int, ...);
extern int openat(int, const char *, int, ...);
extern int openat64(int, const char *, int, ...); |
#define MM_HARD 1 /* Source of the condition is hardware. */ #define MM_NRECOV 128 /* Non-recoverable error. */ #define MM_UTIL 16 /* Condition detected by utility. */ #define MM_SOFT 2 /* Source of the condition is software. */ #define MM_PRINT 256 /* Display message in standard error. */ #define MM_OPSYS 32 /* Condition detected by operating system. */ #define MM_FIRM 4 /* Source of the condition is firmware. */ #define MM_CONSOLE 512 /* Display message on system console. */ #define MM_RECOVER 64 /* Recoverable error. */ #define MM_APPL 8 /* Condition detected by application. */ #define MM_NOSEV 0 /* No severity level provided for the message. */ #define MM_HALT 1 /* Error causing application to halt. */ #define MM_ERROR 2 /* Application has encountered a non-fatal fault. */ #define MM_WARNING 3 /* Application has detected unusual non-error condition. */ #define MM_INFO 4 /* Informative message. */ #define MM_NULLACT ((char *) 0) #define MM_NULLLBL ((char *) 0) #define MM_NULLTAG ((char *) 0) #define MM_NULLTXT ((char *) 0) #define MM_NULLMC ((long int) 0) #define MM_NULLSEV 0 #define MM_NOTOK -1 /* The function failed completely. */ #define MM_OK 0 /* The function succeeded. */ #define MM_NOMSG 1 /* The function was unable to generate a message on standard error, but otherwise succeeded. */ #define MM_NOCON 4 /* The function was unable to generate a console message, but otherwise succeeded. */ extern int fmtmsg(long int, const char *, int, const char *, const char *, const char *); |
#define FNM_PATHNAME (1<<0) #define FNM_NOESCAPE (1<<1) #define FNM_PERIOD (1<<2) #define FNM_NOMATCH 1 extern int fnmatch(const char *, const char *, int); |
#define FTW_D FTW_D
#define FTW_DNR FTW_DNR
#define FTW_DP FTW_DP
#define FTW_F FTW_F
#define FTW_NS FTW_NS
#define FTW_SL FTW_SL
#define FTW_SLN FTW_SLN
enum {
FTW_F,
FTW_D,
FTW_DNR,
FTW_NS,
FTW_SL,
FTW_DP,
FTW_SLN
};
enum {
FTW_PHYS = 1,
FTW_MOUNT = 2,
FTW_CHDIR = 4,
FTW_DEPTH = 8
};
struct FTW {
int base;
int level;
};
typedef int (*__ftw_func_t) (const char *__filename,
const struct stat * __status, int __flag);
typedef int (*__ftw64_func_t) (const char *__filename,
const struct stat64 * __status, int __flag);
typedef int (*__nftw_func_t) (const char *__filename,
const struct stat * __status, int __flag,
struct FTW * __info);
typedef int (*__nftw64_func_t) (const char *__filename,
const struct stat64 * __status, int __flag,
struct FTW * __info);
extern int ftw(const char *, __ftw_func_t, int);
extern int ftw64(const char *, __ftw64_func_t, int);
extern int nftw(const char *, __nftw_func_t, int, int);
extern int nftw64(const char *, __nftw64_func_t, int, int); |
#define no_argument 0
#define required_argument 1
#define optional_argument 2
struct option {
const char *name;
int has_arg;
int *flag;
int val;
};
extern int getopt_long(int, char *const[], const char *,
const struct option *, int *);
extern int getopt_long_only(int, char *const[], const char *,
const struct option *, int *); |
#define GLOB_ERR (1<<0)
#define GLOB_MARK (1<<1)
#define GLOB_BRACE (1<<10)
#define GLOB_NOMAGIC (1<<11)
#define GLOB_TILDE (1<<12)
#define GLOB_ONLYDIR (1<<13)
#define GLOB_TILDE_CHECK (1<<14)
#define GLOB_NOSORT (1<<2)
#define GLOB_DOOFFS (1<<3)
#define GLOB_NOCHECK (1<<4)
#define GLOB_APPEND (1<<5)
#define GLOB_NOESCAPE (1<<6)
#define GLOB_PERIOD (1<<7)
#define GLOB_MAGCHAR (1<<8)
#define GLOB_ALTDIRFUNC (1<<9)
#define GLOB_NOSPACE 1
#define GLOB_ABORTED 2
#define GLOB_NOMATCH 3
#define GLOB_NOSYS 4
typedef struct {
size_t gl_pathc;
char **gl_pathv;
size_t gl_offs;
int gl_flags;
void (*gl_closedir) (void *);
struct dirent *(*gl_readdir) (void *);
void *(*gl_opendir) (const char *);
int (*gl_lstat) (const char *, struct stat *);
int (*gl_stat) (const char *, struct stat *);
} glob_t;
typedef struct {
size_t gl_pathc;
char **gl_pathv;
size_t gl_offs;
int gl_flags;
void (*gl_closedir) (void *);
struct dirent64 *(*gl_readdir) (void *);
void *(*gl_opendir) (const char *);
int (*gl_lstat) (const char *, struct stat *);
int (*gl_stat) (const char *, struct stat *);
} glob64_t;
extern int glob(const char *, int, int (*)(const char *p1, int p2)
, glob_t *);
extern int glob64(const char *, int, int (*)(const char *p1, int p2)
, glob64_t *);
extern void globfree(glob_t *);
extern void globfree64(glob64_t *); |
struct group {
char *gr_name;
char *gr_passwd;
gid_t gr_gid;
char **gr_mem;
};
extern void endgrent(void);
extern struct group *getgrent(void);
extern struct group *getgrgid(gid_t);
extern struct group *getgrnam(const char *);
extern int initgroups(const char *, gid_t);
extern void setgrent(void);
extern int setgroups(size_t, const gid_t *);
extern int getgrgid_r(gid_t, struct group *, char *, size_t,
struct group **);
extern int getgrnam_r(const char *, struct group *, char *, size_t,
struct group **);
extern int getgrent_r(struct group *, char *, size_t, struct group **);
extern int getgrouplist(const char *, gid_t, gid_t *, int *); |
typedef void *iconv_t; extern size_t iconv(iconv_t, char **, size_t *, char **, size_t *); extern int iconv_close(iconv_t); extern iconv_t iconv_open(const char *, const char *); |
typedef lldiv_t imaxdiv_t; #define __PDP_ENDIAN 3412 #define PDP_ENDIAN __PDP_ENDIAN extern intmax_t strtoimax(const char *, char **, int); extern uintmax_t strtoumax(const char *, char **, int); extern intmax_t wcstoimax(const wchar_t *, wchar_t * *, int); extern uintmax_t wcstoumax(const wchar_t *, wchar_t * *, int); extern intmax_t imaxabs(intmax_t); extern imaxdiv_t imaxdiv(intmax_t, intmax_t); |
#define ABDAY_1 0x20000 /* Sun. */ #define ABDAY_2 0x20001 #define ABDAY_3 0x20002 #define ABDAY_4 0x20003 #define ABDAY_5 0x20004 #define ABDAY_6 0x20005 #define ABDAY_7 0x20006 #define DAY_1 0x20007 #define DAY_2 0x20008 #define DAY_3 0x20009 #define DAY_4 0x2000A #define DAY_5 0x2000B #define DAY_6 0x2000C #define DAY_7 0x2000D #define ABMON_1 0x2000E #define ABMON_2 0x2000F #define ABMON_3 0x20010 #define ABMON_4 0x20011 #define ABMON_5 0x20012 #define ABMON_6 0x20013 #define ABMON_7 0x20014 #define ABMON_8 0x20015 #define ABMON_9 0x20016 #define ABMON_10 0x20017 #define ABMON_11 0x20018 #define ABMON_12 0x20019 #define MON_1 0x2001A #define MON_2 0x2001B #define MON_3 0x2001C #define MON_4 0x2001D #define MON_5 0x2001E #define MON_6 0x2001F #define MON_7 0x20020 #define MON_8 0x20021 #define MON_9 0x20022 #define MON_10 0x20023 #define MON_11 0x20024 #define MON_12 0x20025 #define AM_STR 0x20026 #define PM_STR 0x20027 #define D_T_FMT 0x20028 #define D_FMT 0x20029 #define T_FMT 0x2002A #define T_FMT_AMPM 0x2002B #define ERA 0x2002C #define ERA_D_FMT 0x2002E #define ALT_DIGITS 0x2002F #define ERA_D_T_FMT 0x20030 #define ERA_T_FMT 0x20031 #define CODESET 14 #define CRNCYSTR 0x4000F #define RADIXCHAR 0x10000 #define THOUSEP 0x10001 #define YESEXPR 0x50000 #define NOEXPR 0x50001 #define YESSTR 0x50002 #define NOSTR 0x50003 extern char *nl_langinfo(nl_item); |
#define basename __xpg_basename extern char *dirname(char *); extern char *__xpg_basename(char *); |
extern char *bindtextdomain(const char *, const char *); extern char *dcgettext(const char *, const char *, int); extern char *dgettext(const char *, const char *); extern char *gettext(const char *); extern char *textdomain(const char *); extern char *bind_textdomain_codeset(const char *, const char *); extern char *dcngettext(const char *, const char *, const char *, unsigned long int, int); extern char *dngettext(const char *, const char *, const char *, unsigned long int); extern char *ngettext(const char *, const char *, unsigned long int); |
#define LLONG_MIN (-LLONG_MAX-1LL) #define _POSIX_AIO_MAX 1 #define _POSIX_QLIMIT 1 #define _POSIX2_BC_STRING_MAX 1000 #define _POSIX2_CHARCLASS_NAME_MAX 14 #define _POSIX_NAME_MAX 14 #define _POSIX_UIO_MAXIOV 16 #define ULLONG_MAX 18446744073709551615ULL #define _POSIX2_COLL_WEIGHTS_MAX 2 #define _POSIX_AIO_LISTIO_MAX 2 #define _POSIX_OPEN_MAX 20 #define _POSIX_CLOCKRES_MIN 20000000 #define CHARCLASS_NAME_MAX 2048 #define LINE_MAX 2048 #define _POSIX2_BC_DIM_MAX 2048 #define _POSIX2_LINE_MAX 2048 #define _POSIX_CHILD_MAX 25 #define COLL_WEIGHTS_MAX 255 #define _POSIX2_RE_DUP_MAX 255 #define _POSIX_HOST_NAME_MAX 255 #define _POSIX_MAX_CANON 255 #define _POSIX_MAX_INPUT 255 #define _POSIX_RE_DUP_MAX 255 #define _POSIX_SYMLINK_MAX 255 #define _POSIX_PATH_MAX 256 #define _POSIX_SEM_NSEMS_MAX 256 #define NGROUPS_MAX 32 #define _POSIX2_EXPR_NEST_MAX 32 #define _POSIX_DELAYTIMER_MAX 32 #define _POSIX_MQ_PRIO_MAX 32 #define _POSIX_SIGQUEUE_MAX 32 #define _POSIX_TIMER_MAX 32 #define _POSIX_SEM_VALUE_MAX 32767 #define _POSIX_SSIZE_MAX 32767 #define PATH_MAX 4096 #define _POSIX_ARG_MAX 4096 #define _POSIX_PIPE_BUF 512 #define _POSIX_TZNAME_MAX 6 #define _POSIX_LINK_MAX 8 #define _POSIX_MQ_OPEN_MAX 8 #define _POSIX_NGROUPS_MAX 8 #define _POSIX_RTSIG_MAX 8 #define _POSIX_STREAM_MAX 8 #define _POSIX_SYMLOOP_MAX 8 #define _POSIX_LOGIN_NAME_MAX 9 #define _POSIX_TTY_NAME_MAX 9 #define LLONG_MAX 9223372036854775807LL #define _POSIX2_BC_BASE_MAX 99 #define _POSIX2_BC_SCALE_MAX 99 #define SSIZE_MAX LONG_MAX /* Maximum value of an object of type ssize_t */ #define BC_BASE_MAX _POSIX2_BC_BASE_MAX #define BC_DIM_MAX _POSIX2_BC_DIM_MAX #define BC_SCALE_MAX _POSIX2_BC_SCALE_MAX #define BC_STRING_MAX _POSIX2_BC_STRING_MAX #define EXPR_NEST_MAX _POSIX2_EXPR_NEST_MAX #define _POSIX_FD_SETSIZE _POSIX_OPEN_MAX #define _POSIX_HIWAT _POSIX_PIPE_BUF #define MB_LEN_MAX 16 #define SCHAR_MIN (-128) #define SCHAR_MAX 127 #define UCHAR_MAX 255 #define CHAR_BIT 8 #define SHRT_MIN (-32768) #define SHRT_MAX 32767 #define USHRT_MAX 65535 #define INT_MIN (-INT_MAX-1) #define INT_MAX 2147483647 #define UINT_MAX 4294967295U #define LONG_MIN (-LONG_MAX-1L) #define PTHREAD_KEYS_MAX 1024 #define PTHREAD_THREADS_MAX 16384 #define PTHREAD_DESTRUCTOR_ITERATIONS 4 |
struct lconv {
char *decimal_point;
char *thousands_sep;
char *grouping;
char *int_curr_symbol;
char *currency_symbol;
char *mon_decimal_point;
char *mon_thousands_sep;
char *mon_grouping;
char *positive_sign;
char *negative_sign;
char int_frac_digits;
char frac_digits;
char p_cs_precedes;
char p_sep_by_space;
char n_cs_precedes;
char n_sep_by_space;
char p_sign_posn;
char n_sign_posn;
char int_p_cs_precedes;
char int_p_sep_by_space;
char int_n_cs_precedes;
char int_n_sep_by_space;
char int_p_sign_posn;
char int_n_sign_posn;
};
#define LC_GLOBAL_LOCALE ((locale_t) -1L)
#define LC_CTYPE 0
#define LC_NUMERIC 1
#define LC_TELEPHONE 10
#define LC_MEASUREMENT 11
#define LC_IDENTIFICATION 12
#define LC_TIME 2
#define LC_COLLATE 3
#define LC_MONETARY 4
#define LC_MESSAGES 5
#define LC_ALL 6
#define LC_PAPER 7
#define LC_NAME 8
#define LC_ADDRESS 9
struct __locale_struct {
struct locale_data *__locales[13];
const unsigned short *__ctype_b;
const int *__ctype_tolower;
const int *__ctype_toupper;
const char *__names[13];
};
typedef struct __locale_struct *__locale_t;
typedef struct __locale_struct *locale_t;
#define LC_ADDRESS_MASK (1 << LC_ADDRESS)
#define LC_COLLATE_MASK (1 << LC_COLLATE)
#define LC_IDENTIFICATION_MASK (1 << LC_IDENTIFICATION)
#define LC_MEASUREMENT_MASK (1 << LC_MEASUREMENT)
#define LC_MESSAGES_MASK (1 << LC_MESSAGES)
#define LC_MONETARY_MASK (1 << LC_MONETARY)
#define LC_NAME_MASK (1 << LC_NAME)
#define LC_NUMERIC_MASK (1 << LC_NUMERIC)
#define LC_PAPER_MASK (1 << LC_PAPER)
#define LC_TELEPHONE_MASK (1 << LC_TELEPHONE)
#define LC_TIME_MASK (1 << LC_TIME)
#define LC_CTYPE_MASK (1<<LC_CTYPE)
#define LC_ALL_MASK \
(LC_CTYPE_MASK| LC_NUMERIC_MASK| LC_TIME_MASK| LC_COLLATE_MASK| LC_MONETARY_MASK|\
LC_MESSAGES_MASK| LC_PAPER_MASK| LC_NAME_MASK| LC_ADDRESS_MASK| LC_TELEPHONE_MASK|\
LC_MEASUREMENT_MASK| LC_IDENTIFICATION_MASK)
extern struct lconv *localeconv(void);
extern char *setlocale(int, const char *);
extern locale_t uselocale(locale_t);
extern void freelocale(locale_t);
extern locale_t duplocale(locale_t);
extern locale_t newlocale(int, const char *, locale_t); |
#define IF_NAMESIZE 16
#define IFF_UP 0x01 /* Interface is up. */
#define IFF_BROADCAST 0x02 /* Broadcast address valid. */
#define IFF_DEBUG 0x04 /* Turn on debugging. */
#define IFF_LOOPBACK 0x08 /* Is a loopback net. */
#define IFF_POINTOPOINT 0x10 /* Interface is point-to-point link. */
#define IFF_PROMISC 0x100 /* Receive all packets. */
#define IFF_MULTICAST 0x1000 /* Supports multicast. */
#define IFF_NOTRAILERS 0x20 /* Avoid use of trailers. */
#define IFF_RUNNING 0x40 /* Resources allocated. */
#define IFF_NOARP 0x80 /* No address resolution protocol. */
struct if_nameindex {
unsigned int if_index;
char *if_name;
};
struct ifaddr {
struct sockaddr ifa_addr;
union {
struct sockaddr ifu_broadaddr;
struct sockaddr ifu_dstaddr;
} ifa_ifu;
void *ifa_ifp;
void *ifa_next;
};
#define ifr_name ifr_ifrn.ifrn_name /* interface name */
#define ifr_addr ifr_ifru.ifru_addr /* address */
#define ifr_broadaddr ifr_ifru.ifru_broadaddr /* broadcast address */
#define ifr_data ifr_ifru.ifru_data /* for use by interface */
#define ifr_dstaddr ifr_ifru.ifru_dstaddr /* other end of p-p lnk */
#define ifr_flags ifr_ifru.ifru_flags /* flags */
#define ifr_hwaddr ifr_ifru.ifru_hwaddr /* interface name */
#define ifr_bandwidth ifr_ifru.ifru_ivalue /* link bandwidth */
#define ifr_ifindex ifr_ifru.ifru_ivalue /* interface index */
#define ifr_metric ifr_ifru.ifru_ivalue /* metric */
#define ifr_qlen ifr_ifru.ifru_ivalue /* queue length */
#define ifr_mtu ifr_ifru.ifru_mtu /* mtu */
#define ifr_netmask ifr_ifru.ifru_netmask /* interface net mask */
#define ifr_slave ifr_ifru.ifru_slave /* slave device */
#define IFNAMSIZ IF_NAMESIZE
struct ifreq {
union {
char ifrn_name[IFNAMSIZ];
} ifr_ifrn;
union {
struct sockaddr ifru_addr;
struct sockaddr ifru_dstaddr;
struct sockaddr ifru_broadaddr;
struct sockaddr ifru_netmask;
struct sockaddr ifru_hwaddr;
short ifru_flags;
int ifru_ivalue;
int ifru_mtu;
char ifru_slave[IFNAMSIZ];
char ifru_newname[IFNAMSIZ];
caddr_t ifru_data;
struct ifmap ifru_map;
} ifr_ifru;
};
#define ifc_buf ifc_ifcu.ifcu_buf /* Buffer address. */
#define ifc_req ifc_ifcu.ifcu_req /* Array of structures. */
struct ifconf {
int ifc_len;
union {
caddr_t ifcu_buf;
struct ifreq *ifcu_req;
} ifc_ifcu;
};
extern void if_freenameindex(struct if_nameindex *);
extern char *if_indextoname(unsigned int, char *);
extern struct if_nameindex *if_nameindex(void);
extern unsigned int if_nametoindex(const char *); |
#define h_errno (*__h_errno_location ())
#define NETDB_INTERNAL -1 /* See errno. */
#define NETDB_SUCCESS 0 /* No problem. */
#define HOST_NOT_FOUND 1 /* Authoritative Answer Host not found. */
#define IPPORT_RESERVED 1024
#define NI_MAXHOST 1025
#define TRY_AGAIN 2 /* Non-Authoritative Host not found, or SERVERFAIL. */
#define NO_RECOVERY 3 /* Non recoverable errors, FORMERR, REFUSED, NOTIMP. */
#define NI_MAXSERV 32
#define NO_DATA 4 /* Valid name, no data record of requested type. */
#define h_addr h_addr_list[0]
#define NO_ADDRESS NO_DATA /* No address, look for MX record. */
struct servent {
char *s_name;
char **s_aliases;
int s_port;
char *s_proto;
};
struct hostent {
char *h_name;
char **h_aliases;
int h_addrtype;
int h_length;
char **h_addr_list;
};
struct protoent {
char *p_name;
char **p_aliases;
int p_proto;
};
struct netent {
char *n_name;
char **n_aliases;
int n_addrtype;
unsigned int n_net;
};
#define AI_PASSIVE 0x0001 /* Socket address is intended for `bind' */
#define AI_CANONNAME 0x0002 /* Request for canonical name */
#define AI_NUMERICHOST 0x0004 /* Don't use name resolution */
#define AI_V4MAPPED 0x0008 /* IPv4 mapped addresses are acceptable. */
#define AI_ALL 0x0010 /* Return IPv4 mapped and IPv6 addresses. */
#define AI_ADDRCONFIG 0x0020 /* Use configuration of this host to choose returned address type.. */
#define AI_NUMERICSERV 0x0400 /* Don't use name resolution */
struct addrinfo {
int ai_flags;
int ai_family;
int ai_socktype;
int ai_protocol;
socklen_t ai_addrlen;
struct sockaddr *ai_addr;
char *ai_canonname;
struct addrinfo *ai_next;
};
#define NI_NUMERICHOST 1
#define NI_DGRAM 16
#define NI_NUMERICSERV 2
#define NI_NOFQDN 4
#define NI_NAMEREQD 8
#define EAI_BADFLAGS -1 /* Invalid value for `ai_flags' field. */
#define EAI_MEMORY -10 /* Memory allocation failure. */
#define EAI_SYSTEM -11 /* System error returned in `errno'. */
#define EAI_NONAME -2 /* NAME or SERVICE is unknown. */
#define EAI_AGAIN -3 /* Temporary failure in name resolution. */
#define EAI_FAIL -4 /* Non-recoverable failure in name res. */
#define EAI_NODATA -5 /* No address associated with NAME. */
#define EAI_FAMILY -6 /* `ai_family' not supported. */
#define EAI_SOCKTYPE -7 /* `ai_family' not supported. */
#define EAI_SERVICE -8 /* SERVICE not supported for `ai_socktype'. */
#define EAI_ADDRFAMILY -9 /* Address family for NAME not supported. */
extern int gethostbyname2_r(const char *, int, struct hostent *, char *,
size_t, struct hostent **, int *);
extern int getprotobyname_r(const char *, struct protoent *, char *,
size_t, struct protoent **);
extern int getprotobynumber_r(int, struct protoent *, char *, size_t,
struct protoent **);
extern int getprotoent_r(struct protoent *, char *, size_t,
struct protoent **);
extern int getservbyname_r(const char *, const char *, struct servent *,
char *, size_t, struct servent **);
extern int getservbyport_r(int, const char *, struct servent *, char *,
size_t, struct servent **);
extern int getservent_r(struct servent *, char *, size_t,
struct servent **);
extern void endprotoent(void);
extern void endservent(void);
extern void freeaddrinfo(struct addrinfo *);
extern const char *gai_strerror(int);
extern int getaddrinfo(const char *, const char *, const struct addrinfo *,
struct addrinfo **);
extern struct hostent *gethostbyaddr(const void *, socklen_t, int);
extern struct hostent *gethostbyname(const char *);
extern struct hostent *gethostbyname2(const char *, int);
extern struct protoent *getprotobyname(const char *);
extern struct protoent *getprotobynumber(int);
extern struct protoent *getprotoent(void);
extern struct servent *getservbyname(const char *, const char *);
extern struct servent *getservbyport(int, const char *);
extern struct servent *getservent(void);
extern void setprotoent(int);
extern void setservent(int);
extern int *__h_errno_location(void);
extern int gethostbyaddr_r(const void *, socklen_t, int, struct hostent *,
char *, size_t, struct hostent **, int *);
extern int gethostbyname_r(const char *, struct hostent *, char *, size_t,
struct hostent **, int *); |
#define IPPROTO_IP 0
#define IPPROTO_ICMP 1
#define IPPROTO_UDP 17
#define IPPROTO_IGMP 2
#define IPPROTO_RAW 255
#define IPPROTO_IPV6 41
#define IPPROTO_ICMPV6 58
#define IPPROTO_TCP 6
typedef uint16_t in_port_t;
struct in_addr {
uint32_t s_addr;
};
typedef uint32_t in_addr_t;
#define INADDR_NONE ((in_addr_t) 0xffffffff)
#define INADDR_BROADCAST (0xffffffff)
#define INADDR_ANY 0
#define INADDR_LOOPBACK 0x7f000001 /* 127.0.0.1 */
#define s6_addr16 in6_u.u6_addr16
#define s6_addr32 in6_u.u6_addr32
#define s6_addr in6_u.u6_addr8
struct in6_addr {
union {
uint8_t u6_addr8[16];
uint16_t u6_addr16[8];
uint32_t u6_addr32[4];
} in6_u;
};
#define IN6ADDR_ANY_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } }
#define IN6ADDR_LOOPBACK_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 } } }
#define IN_MULTICAST(a) ((((in_addr_t)(a))&0xf0000000)==0xe0000000)
#define INET_ADDRSTRLEN 16
struct sockaddr_in {
sa_family_t sin_family;
unsigned short sin_port;
struct in_addr sin_addr;
unsigned char sin_zero[8];
};
#define IN6_IS_ADDR_LINKLOCAL(a) ((((const uint32_t *) (a))[0] & htonl (0xffc00000)) == htonl (0xfe800000))
#define IN6_IS_ADDR_SITELOCAL(a) ((((const uint32_t *) (a))[0] & htonl (0xffc00000)) == htonl (0xfec00000))
#define IN6_ARE_ADDR_EQUAL(a,b) ((((const uint32_t *) (a))[0] == ((const uint32_t *) (b))[0]) && (((const uint32_t *) (a))[1] == ((const uint32_t *) (b))[1]) && (((const uint32_t *) (a))[2] == ((const uint32_t *) (b))[2]) && (((const uint32_t *) (a))[3] == ((const uint32_t *) (b))[3]))
#define IN6_IS_ADDR_V4COMPAT(a) ((((const uint32_t *) (a))[0] == 0) && (((const uint32_t *) (a))[1] == 0) && (((const uint32_t *) (a))[2] == 0) && (ntohl (((const uint32_t *) (a))[3]) > 1))
#define IN6_IS_ADDR_V4MAPPED(a) ((((const uint32_t *) (a))[0] == 0) && (((const uint32_t *) (a))[1] == 0) && (((const uint32_t *) (a))[2] == htonl (0xffff)))
#define IN6_IS_ADDR_UNSPECIFIED(a) (((const uint32_t *) (a))[0] == 0 && ((const uint32_t *) (a))[1] == 0 && ((const uint32_t *) (a))[2] == 0 && ((const uint32_t *) (a))[3] == 0)
#define IN6_IS_ADDR_LOOPBACK(a) (((const uint32_t *) (a))[0] == 0 && ((const uint32_t *) (a))[1] == 0 && ((const uint32_t *) (a))[2] == 0 && ((const uint32_t *) (a))[3] == htonl (1))
#define IN6_IS_ADDR_MULTICAST(a) (((const uint8_t *) (a))[0] == 0xff)
#define IN6_IS_ADDR_MC_NODELOCAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0x1))
#define IN6_IS_ADDR_MC_LINKLOCAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0x2))
#define IN6_IS_ADDR_MC_SITELOCAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0x5))
#define IN6_IS_ADDR_MC_ORGLOCAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0x8))
#define IN6_IS_ADDR_MC_GLOBAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0xe))
#define INET6_ADDRSTRLEN 46
struct sockaddr_in6 {
unsigned short sin6_family;
uint16_t sin6_port;
uint32_t sin6_flowinfo;
struct in6_addr sin6_addr;
uint32_t sin6_scope_id;
};
#define SOL_IP 0
#define IP_TOS 1 /* IP type of service and precedence */
#define IPV6_UNICAST_HOPS 16
#define IPV6_MULTICAST_IF 17
#define IPV6_MULTICAST_HOPS 18
#define IPV6_MULTICAST_LOOP 19
#define IP_TTL 2 /* IP time to live */
#define IPV6_JOIN_GROUP 20
#define IPV6_LEAVE_GROUP 21
#define IPV6_V6ONLY 26
#define IP_MULTICAST_IF 32 /* set/get IP multicast i/f */
#define IP_MULTICAST_TTL 33 /* set/get IP multicast ttl */
#define IP_MULTICAST_LOOP 34 /* set/get IP multicast loopback */
#define IP_ADD_MEMBERSHIP 35 /* add an IP group membership */
#define IP_DROP_MEMBERSHIP 36 /* drop an IP group membership */
#define IP_OPTIONS 4 /* IP per-packet options */
#define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
#define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
struct ipv6_mreq {
struct in6_addr ipv6mr_multiaddr;
int ipv6mr_interface;
};
struct ip_mreq {
struct in_addr imr_multiaddr;
struct in_addr imr_interface;
};
extern int bindresvport(int, struct sockaddr_in *);
extern const struct in6_addr in6addr_any;
extern const struct in6_addr in6addr_loopback; |
#define IPOPT_EOL #define IPOPT_OPTVAL #define IPOPT_TS_TSONLY #define IPOPT_CLASS(o) ((o) & IPOPT_CLASS_MASK) #define IPOPT_COPIED(o) ((o) & IPOPT_COPY) #define IPOPT_NUMBER(o) ((o) & IPOPT_NUMBER_MASK) #define IPOPT_CONTROL 0x00 #define IPOPT_SECUR_UNCLASS 0x0000 #define IPOPT_NUMBER_MASK 0x1f #define IP_OFFMASK 0x1fff #define IPOPT_RESERVED1 0x20 #define IP_MF 0x2000 #define IPOPT_DEBMEAS 0x40 #define IP_DF 0x4000 #define IPOPT_CLASS_MASK 0x60 #define IPOPT_RESERVED2 0x60 #define IPOPT_SECUR_TOPSECRET 0x6bc5 #define IPOPT_SECUR_EFTO 0x789a #define IPOPT_COPY 0x80 #define IP_RF 0x8000 #define IPOPT_SECUR_RESTR 0xaf13 #define IPOPT_SECUR_MMMM 0xbc4d #define IPOPT_SECUR_SECRET 0xd788 #define IPOPT_SECUR_CONFID 0xf135 #define IPOPT_NOP 1 #define IPOPT_OLEN 1 #define IPOPT_TS_TSANDADDR 1 #define IPTTLDEC 1 #define IPOPT_SECURITY 130 #define IPOPT_LSRR 131 #define IPOPT_SATID 136 #define IPOPT_SSRR 137 #define IPOPT_RA 148 #define IPOPT_OFFSET 2 #define MAXTTL 255 #define IPOPT_TS_PRESPEC 3 #define IPOPT_MINOFF 4 #define IPVERSION 4 #define MAX_IPOPTLEN 40 #define IP_MSS 576 #define IPFRAGTTL 60 #define IPDEFTTL 64 #define IP_MAXPACKET 65535 #define IPOPT_TS 68 #define IPOPT_RR 7 #define IPOPT_MEASUREMENT IPOPT_DEBMEAS #define IPOPT_END IPOPT_EOL #define IPOPT_NOOP IPOPT_NOP #define IPOPT_SID IPOPT_SATID #define IPOPT_SEC IPOPT_SECURITY #define IPOPT_TIMESTAMP IPOPT_TS #define IPTOS_TOS(tos) ((tos) & IPTOS_TOS_MASK) #define IPTOS_LOWCOST 0x02 #define IPTOS_RELIABILITY 0x04 #define IPTOS_THROUGHPUT 0x08 #define IPTOS_LOWDELAY 0x10 #define IPTOS_TOS_MASK 0x1e #define IPTOS_MINCOST IPTOS_LOWCOST #define IPTOS_PREC(tos) ((tos) & IPTOS_PREC_MASK) #define IPTOS_PREC_MASK 0xe0 |
#define IP6OPT_PAD1
#define IP6OPT_TYPE(o) ((o) & 0xc0)
#define IP6OPT_TYPE_SKIP 0x00
#define IP6OPT_TUNNEL_LIMIT 0x04
#define IP6OPT_ROUTER_ALERT 0x05
#define IP6OPT_TYPE_MUTABLE 0x20
#define IP6OPT_TYPE_DISCARD 0x40
#define IP6OPT_TYPE_FORCEICMP 0x80
#define IP6OPT_TYPE_ICMP 0xc0
#define IP6OPT_JUMBO 0xc2
#define IP6OPT_NSAP_ADDR 0xc3
#define IP6OPT_PADN 1
#define IP6OPT_JUMBO_LEN 6
#define ip6_flow ip6_ctlun.ip6_un1.ip6_un1_flow
#define ip6_hlim ip6_ctlun.ip6_un1.ip6_un1_hlim
#define ip6_hops ip6_ctlun.ip6_un1.ip6_un1_hlim
#define ip6_nxt ip6_ctlun.ip6_un1.ip6_un1_nxt
#define ip6_plen ip6_ctlun.ip6_un1.ip6_un1_plen
#define ip6_vfc ip6_ctlun.ip6_un2_vfc
struct ip6_hdrctl {
uint32_t ip6_un1_flow;
uint16_t ip6_un1_plen;
uint8_t ip6_un1_nxt;
uint8_t ip6_un1_hlim;
};
struct ip6_hdr {
struct in6_addr ip6_src;
struct in6_addr ip6_dst;
};
struct ip6_ext {
uint8_t ip6e_nxt;
uint8_t ip6e_len;
};
struct ip6_hbh {
uint8_t ip6h_nxt;
uint8_t ip6h_len;
};
struct ip6_dest {
uint8_t ip6d_nxt;
uint8_t ip6d_len;
};
struct ip6_rthdr {
uint8_t ip6r_nxt;
uint8_t ip6r_len;
uint8_t ip6r_type;
uint8_t ip6r_segleft;
};
struct ip6_frag {
uint8_t ip6f_nxt;
uint8_t ip6f_reserved;
uint16_t ip6f_offlg;
uint32_t ip6f_ident;
};
struct ip6_opt {
uint8_t ip6o_type;
uint8_t ip6o_len;
};
struct ip6_opt_jumbo {
uint8_t ip6oj_type;
uint8_t ip6oj_len;
uint8_t ip6oj_jumbo_len[4];
};
struct ip6_opt_nsap {
uint8_t ip6on_type;
uint8_t ip6on_len;
uint8_t ip6on_src_nsap_len;
uint8_t ip6on_dst_nsap_len;
};
struct ip6_opt_tunnel {
uint8_t ip6ot_type;
uint8_t ip6ot_len;
uint8_t ip6ot_encap_limit;
};
struct ip6_opt_router {
uint8_t ip6or_type;
uint8_t ip6or_len;
uint8_t ip6or_value[2];
}; |
#define TCPOLEN_TSTAMP_APPA (TCPOLEN_TIMESTAMP+2)
#define TCPOPT_TSTAMP_HDR (TCPOPT_NOP<<24|TCPOPT_NOP<<16|TCPOPT_TIMESTAMP<<8|TCPOLEN_TIMESTAMP)
#define TCPOPT_EOL 0
#define TCPI_OPT_TIMESTAMPS 1
#define TCPOPT_NOP 1
#define TCP_NODELAY 1
#define TCPOLEN_TIMESTAMP 10
#define TCP_WINDOW_CLAMP 10
#define TCP_INFO 11
#define TCP_QUICKACK 12
#define TCP_CONGESTION 13
#define TCP_MAX_WINSHIFT 14
#define TCPI_OPT_SACK 2
#define TCPOLEN_SACK_PERMITTED 2
#define TCPOPT_MAXSEG 2
#define TCP_MAXSEG 2
#define TCPOLEN_WINDOW 3
#define TCPOPT_WINDOW 3
#define TCP_CORK 3
#define TCPI_OPT_WSCALE 4
#define TCPOLEN_MAXSEG 4
#define TCPOPT_SACK_PERMITTED 4
#define TCP_KEEPIDLE 4
#define TCPOPT_SACK 5
#define TCP_KEEPINTVL 5
#define TCP_MSS 512
#define SOL_TCP 6
#define TCP_KEEPCNT 6
#define TCP_MAXWIN 65535
#define TCP_SYNCNT 7
#define TCPI_OPT_ECN 8
#define TCPOPT_TIMESTAMP 8
#define TCP_LINGER2 8
#define TCP_DEFER_ACCEPT 9
enum tcp_ca_state {
TCP_CA_Open,
TCP_CA_Disorder,
TCP_CA_CWR,
TCP_CA_Recovery,
TCP_CA_Loss
};
struct tcp_info {
uint8_t tcpi_state;
uint8_t tcpi_ca_state;
uint8_t tcpi_retransmits;
uint8_t tcpi_probes;
uint8_t tcpi_backoff;
uint8_t tcpi_options;
uint8_t tcpi_snd_wscale:4;
uint8_t tcpi_rcv_wscale:4;
uint32_t tcpi_rto;
uint32_t tcpi_ato;
uint32_t tcpi_snd_mss;
uint32_t tcpi_rcv_mss;
uint32_t tcpi_unacked;
uint32_t tcpi_sacked;
uint32_t tcpi_lost;
uint32_t tcpi_retrans;
uint32_t tcpi_fackets;
uint32_t tcpi_last_data_sent;
uint32_t tcpi_last_ack_sent;
uint32_t tcpi_last_data_recv;
uint32_t tcpi_last_ack_recv;
uint32_t tcpi_pmtu;
uint32_t tcpi_rcv_ssthresh;
uint32_t tcpi_rtt;
uint32_t tcpi_rttvar;
uint32_t tcpi_snd_ssthresh;
uint32_t tcpi_snd_cwnd;
uint32_t tcpi_advmss;
uint32_t tcpi_reordering;
};
enum {
TCP_ESTABLISHED = 1,
TCP_SYN_SENT = 2,
TCP_SYN_RECV = 3,
TCP_FIN_WAIT1 = 4,
TCP_FIN_WAIT2 = 5,
TCP_TIME_WAIT = 6,
TCP_CLOSE = 7,
TCP_CLOSE_WAIT = 8,
TCP_LAST_ACK = 9,
TCP_LISTEN = 10,
TCP_CLOSING = 11
}; |
#define SOL_UDP 17
struct udphdr {
u_int16_t source;
u_int16_t dest;
u_int16_t len;
u_int16_t check;
}; |
#define NL_CAT_LOCALE 1 #define NL_SETD 1 typedef void *nl_catd; typedef int nl_item; extern int catclose(nl_catd); extern char *catgets(nl_catd, int, int, const char *); extern nl_catd catopen(const char *, int); |
extern int openpty(int *, int *, char *, struct termios *, struct winsize *); extern int forkpty(int *, char *, struct termios *, struct winsize *); |
struct passwd {
char *pw_name;
char *pw_passwd;
uid_t pw_uid;
gid_t pw_gid;
char *pw_gecos;
char *pw_dir;
char *pw_shell;
};
extern int getpwent_r(struct passwd *, char *, size_t, struct passwd **);
extern void endpwent(void);
extern struct passwd *getpwent(void);
extern struct passwd *getpwnam(const char *);
extern struct passwd *getpwuid(uid_t);
extern void setpwent(void);
extern int getpwnam_r(const char *, struct passwd *, char *, size_t,
struct passwd **);
extern int getpwuid_r(uid_t, struct passwd *, char *, size_t,
struct passwd **); |
#define RE_DUP_MAX (0x7fff)
typedef unsigned long int reg_syntax_t;
typedef struct re_pattern_buffer {
unsigned char *buffer;
unsigned long int allocated;
unsigned long int used;
reg_syntax_t syntax;
char *fastmap;
char *translate;
size_t re_nsub;
unsigned int can_be_null:1;
unsigned int regs_allocated:2;
unsigned int fastmap_accurate:1;
unsigned int no_sub:1;
unsigned int not_bol:1;
unsigned int not_eol:1;
unsigned int newline_anchor:1;
} regex_t;
typedef int regoff_t;
typedef struct {
regoff_t rm_so;
regoff_t rm_eo;
} regmatch_t;
#define REG_ICASE (REG_EXTENDED<<1)
#define REG_NEWLINE (REG_ICASE<<1)
#define REG_NOSUB (REG_NEWLINE<<1)
#define REG_EXTENDED 1
#define REG_NOTEOL (1<<1)
#define REG_NOTBOL 1
typedef enum {
REG_ENOSYS = -1,
REG_NOERROR = 0,
REG_NOMATCH = 1,
REG_BADPAT = 2,
REG_ECOLLATE = 3,
REG_ECTYPE = 4,
REG_EESCAPE = 5,
REG_ESUBREG = 6,
REG_EBRACK = 7,
REG_EPAREN = 8,
REG_EBRACE = 9,
REG_BADBR = 10,
REG_ERANGE = 11,
REG_ESPACE = 12,
REG_BADRPT = 13,
REG_EEND = 14,
REG_ESIZE = 15,
REG_ERPAREN = 16
} reg_errcode_t;
extern int regcomp(regex_t *, const char *, int);
extern size_t regerror(int, const regex_t *, char *, size_t);
extern int regexec(const regex_t *, const char *, size_t, regmatch_t[],
int);
extern void regfree(regex_t *); |
#define auth_destroy(auth) ((*((auth)->ah_ops->ah_destroy))(auth))
enum auth_stat {
AUTH_OK = 0,
AUTH_BADCRED = 1,
AUTH_REJECTEDCRED = 2,
AUTH_BADVERF = 3,
AUTH_REJECTEDVERF = 4,
AUTH_TOOWEAK = 5,
AUTH_INVALIDRESP = 6,
AUTH_FAILED = 7
};
union des_block {
struct {
u_int32_t high;
u_int32_t low;
} key;
char c[8];
};
struct opaque_auth {
enum_t oa_flavor;
caddr_t oa_base;
u_int oa_length;
};
typedef struct AUTH {
struct opaque_auth ah_cred;
struct opaque_auth ah_verf;
union des_block ah_key;
struct auth_ops *ah_ops;
caddr_t ah_private;
} AUTH;
struct auth_ops {
void (*ah_nextverf) (struct AUTH *);
int (*ah_marshal) (struct AUTH *, XDR *);
int (*ah_validate) (struct AUTH *, struct opaque_auth *);
int (*ah_refresh) (struct AUTH *);
void (*ah_destroy) (struct AUTH *);
};
extern struct AUTH *authnone_create(void);
extern int key_decryptsession(char *, union des_block *);
extern bool_t xdr_opaque_auth(XDR *, struct opaque_auth *); |
#define clnt_control(cl,rq,in) ((*(cl)->cl_ops->cl_control)(cl,rq,in))
#define clnt_abort(rh) ((*(rh)->cl_ops->cl_abort)(rh))
#define clnt_destroy(rh) ((*(rh)->cl_ops->cl_destroy)(rh))
#define clnt_freeres(rh,xres,resp) ((*(rh)->cl_ops->cl_freeres)(rh,xres,resp))
#define clnt_geterr(rh,errp) ((*(rh)->cl_ops->cl_geterr)(rh, errp))
#define NULLPROC ((u_long)0) /* By convention, procedure 0 takes null arguments and returns */
#define CLSET_TIMEOUT 1 /* set timeout (timeval) */
#define CLGET_XID 10 /* Get xid */
#define CLSET_XID 11 /* Set xid */
#define CLGET_VERS 12 /* Get version number */
#define CLSET_VERS 13 /* Set version number */
#define CLGET_PROG 14 /* Get program number */
#define CLSET_PROG 15 /* Set program number */
#define CLGET_TIMEOUT 2 /* get timeout (timeval) */
#define CLGET_SERVER_ADDR 3 /* get server's address (sockaddr) */
#define CLSET_RETRY_TIMEOUT 4 /* set retry timeout (timeval) */
#define CLGET_RETRY_TIMEOUT 5 /* get retry timeout (timeval) */
#define CLGET_FD 6 /* get connections file descriptor */
#define CLGET_SVC_ADDR 7 /* get server's address (netbuf) */
#define CLSET_FD_CLOSE 8 /* close fd while clnt_destroy */
#define CLSET_FD_NCLOSE 9 /* Do not close fd while clnt_destroy */
#define clnt_call(rh, proc, xargs, argsp, xres, resp, secs) \
((*(rh)->cl_ops->cl_call)(rh, proc, xargs, argsp, xres, resp, secs))
enum clnt_stat {
RPC_SUCCESS = 0,
RPC_CANTENCODEARGS = 1,
RPC_CANTDECODERES = 2,
RPC_CANTSEND = 3,
RPC_CANTRECV = 4,
RPC_TIMEDOUT = 5,
RPC_VERSMISMATCH = 6,
RPC_AUTHERROR = 7,
RPC_PROGUNAVAIL = 8,
RPC_PROGVERSMISMATCH = 9,
RPC_PROCUNAVAIL = 10,
RPC_CANTDECODEARGS = 11,
RPC_SYSTEMERROR = 12,
RPC_NOBROADCAST = 21,
RPC_UNKNOWNHOST = 13,
RPC_UNKNOWNPROTO = 17,
RPC_UNKNOWNADDR = 19,
RPC_RPCBFAILURE = 14,
RPC_PROGNOTREGISTERED = 15,
RPC_N2AXLATEFAILURE = 22,
RPC_FAILED = 16,
RPC_INTR = 18,
RPC_TLIERROR = 20,
RPC_UDERROR = 23,
RPC_INPROGRESS = 24,
RPC_STALERACHANDLE = 25
};
struct rpc_err {
enum clnt_stat re_status;
union {
int RE_errno;
enum auth_stat RE_why;
struct {
u_long low;
u_long high;
} RE_vers;
struct {
long int s1;
long int s2;
} RE_lb;
} ru;
};
typedef struct CLIENT {
struct AUTH *cl_auth;
struct clnt_ops *cl_ops;
caddr_t cl_private;
} CLIENT;
struct clnt_ops {
enum clnt_stat (*cl_call) (struct CLIENT *, u_long, xdrproc_t, caddr_t,
xdrproc_t, caddr_t, struct timeval);
void (*cl_abort) (void);
void (*cl_geterr) (struct CLIENT *, struct rpc_err *);
bool_t(*cl_freeres) (struct CLIENT *, xdrproc_t, caddr_t);
void (*cl_destroy) (struct CLIENT *);
bool_t(*cl_control) (struct CLIENT *, int, char *);
};
extern struct CLIENT *clntraw_create(u_long, u_long);
extern struct CLIENT *clnttcp_create(struct sockaddr_in *, u_long, u_long,
int *, u_int, u_int);
extern struct CLIENT *clntudp_bufcreate(struct sockaddr_in *, u_long,
u_long, struct timeval, int *,
u_int, u_int);
extern struct CLIENT *clntudp_create(struct sockaddr_in *, u_long, u_long,
struct timeval, int *);
extern int callrpc(const char *, const u_long, const u_long, const u_long,
const xdrproc_t, const char *, const xdrproc_t, char *);
extern struct CLIENT *clnt_create(const char *, const u_long, const u_long,
const char *);
extern void clnt_pcreateerror(const char *);
extern void clnt_perrno(enum clnt_stat);
extern void clnt_perror(struct CLIENT *, const char *);
extern char *clnt_spcreateerror(const char *);
extern char *clnt_sperrno(enum clnt_stat);
extern char *clnt_sperror(struct CLIENT *, const char *); |
extern u_short pmap_getport(struct sockaddr_in *, const u_long, const u_long, u_int); extern bool_t pmap_set(const u_long, const u_long, int, u_short); extern bool_t pmap_unset(u_long, u_long); |
enum msg_type {
CALL = 0,
REPLY = 1
};
enum reply_stat {
MSG_ACCEPTED = 0,
MSG_DENIED = 1
};
enum accept_stat {
SUCCESS = 0,
PROG_UNAVAIL = 1,
PROG_MISMATCH = 2,
PROC_UNAVAIL = 3,
GARBAGE_ARGS = 4,
SYSTEM_ERR = 5
};
enum reject_stat {
RPC_MISMATCH = 0,
AUTH_ERROR = 1
};
#define ar_results ru.AR_results
#define ar_vers ru.AR_versions
struct accepted_reply {
struct opaque_auth ar_verf;
enum accept_stat ar_stat;
union {
struct {
unsigned long int low;
unsigned long int high;
} AR_versions;
struct {
caddr_t where;
xdrproc_t proc;
} AR_results;
} ru;
};
#define rj_vers ru.RJ_versions
#define rj_why ru.RJ_why
struct rejected_reply {
enum reject_stat rj_stat;
union {
struct {
unsigned long int low;
unsigned long int high;
} RJ_versions;
enum auth_stat RJ_why;
} ru;
};
#define rp_acpt ru.RP_ar
#define rp_rjct ru.RP_dr
struct reply_body {
enum reply_stat rp_stat;
union {
struct accepted_reply RP_ar;
struct rejected_reply RP_dr;
} ru;
};
struct call_body {
unsigned long int cb_rpcvers;
unsigned long int cb_prog;
unsigned long int cb_vers;
unsigned long int cb_proc;
struct opaque_auth cb_cred;
struct opaque_auth cb_verf;
};
#define rm_call ru.RM_cmb
#define rm_reply ru.RM_rmb
#define acpted_rply ru.RM_rmb.ru.RP_ar
#define rjcted_rply ru.RM_rmb.ru.RP_dr
struct rpc_msg {
unsigned long int rm_xid;
enum msg_type rm_direction;
union {
struct call_body RM_cmb;
struct reply_body RM_rmb;
} ru;
};
extern bool_t xdr_accepted_reply(XDR *, struct accepted_reply *);
extern bool_t xdr_callhdr(XDR *, struct rpc_msg *);
extern bool_t xdr_callmsg(XDR *, struct rpc_msg *);
extern bool_t xdr_rejected_reply(XDR *, struct rejected_reply *);
extern bool_t xdr_replymsg(XDR *, struct rpc_msg *); |
#define svc_getcaller(x) (&(x)->xp_raddr)
#define svc_destroy(xprt) (*(xprt)->xp_ops->xp_destroy)(xprt)
#define svc_recv(xprt,msg) (*(xprt)->xp_ops->xp_recv)((xprt), (msg))
#define svc_reply(xprt,msg) (*(xprt)->xp_ops->xp_reply) ((xprt), (msg))
#define svc_stat(xprt) (*(xprt)->xp_ops->xp_stat)(xprt)
#define RPC_ANYSOCK -1
#define svc_freeargs(xprt,xargs, argsp) \
(*(xprt)->xp_ops->xp_freeargs)((xprt), (xargs), (argsp))
#define svc_getargs(xprt,xargs, argsp) \
(*(xprt)->xp_ops->xp_getargs)((xprt), (xargs), (argsp))
enum xprt_stat {
XPRT_DIED,
XPRT_MOREREQS,
XPRT_IDLE
};
typedef struct SVCXPRT {
int xp_sock;
u_short xp_port;
struct xp_ops *xp_ops;
int xp_addrlen;
struct sockaddr_in xp_raddr;
struct opaque_auth xp_verf;
caddr_t xp_p1;
caddr_t xp_p2;
char xp_pad[256];
} SVCXPRT;
struct svc_req {
rpcprog_t rq_prog;
rpcvers_t rq_vers;
rpcproc_t rq_proc;
struct opaque_auth rq_cred;
caddr_t rq_clntcred;
SVCXPRT *rq_xprt;
};
typedef void (*__dispatch_fn_t) (struct svc_req *, SVCXPRT *);
struct xp_ops {
bool_t(*xp_recv) (SVCXPRT * __xprt, struct rpc_msg * __msg);
enum xprt_stat (*xp_stat) (SVCXPRT * __xprt);
bool_t(*xp_getargs) (SVCXPRT * __xprt, xdrproc_t __xdr_args,
caddr_t args_ptr);
bool_t(*xp_reply) (SVCXPRT * __xprt, struct rpc_msg * __msg);
bool_t(*xp_freeargs) (SVCXPRT * __xprt, xdrproc_t __xdr_args,
caddr_t args_ptr);
void (*xp_destroy) (SVCXPRT * __xprt);
};
extern SVCXPRT *svcraw_create(void);
extern void svc_getreqset(fd_set *);
extern bool_t svc_register(SVCXPRT *, rpcprog_t, rpcvers_t,
__dispatch_fn_t, rpcprot_t);
extern void svc_run(void);
extern bool_t svc_sendreply(SVCXPRT *, xdrproc_t, caddr_t);
extern void svcerr_auth(SVCXPRT *, enum auth_stat);
extern void svcerr_decode(SVCXPRT *);
extern void svcerr_noproc(SVCXPRT *);
extern void svcerr_noprog(SVCXPRT *);
extern void svcerr_progvers(SVCXPRT *, rpcvers_t, rpcvers_t);
extern void svcerr_systemerr(SVCXPRT *);
extern void svcerr_weakauth(SVCXPRT *);
extern SVCXPRT *svctcp_create(int, u_int, u_int);
extern SVCXPRT *svcudp_create(int); |
typedef int bool_t; typedef int enum_t; typedef unsigned long int rpcprog_t; typedef unsigned long int rpcvers_t; typedef unsigned long int rpcproc_t; typedef unsigned long int rpcprot_t; |
#define XDR_DESTROY(xdrs) \
do { if ((xdrs)->x_ops->x_destroy) (*(xdrs)->x_ops->x_destroy)(xdrs); \
} while (0)
#define xdr_destroy(xdrs) \
do { if ((xdrs)->x_ops->x_destroy) (*(xdrs)->x_ops->x_destroy)(xdrs); \
} while (0)
#define XDR_GETBYTES(xdrs,addr,len) (*(xdrs)->x_ops->x_getbytes)(xdrs, addr, len)
#define xdr_getbytes(xdrs,addr,len) (*(xdrs)->x_ops->x_getbytes)(xdrs, addr, len)
#define XDR_GETINT32(xdrs,int32p) (*(xdrs)->x_ops->x_getint32)(xdrs, int32p)
#define xdr_getint32(xdrs,int32p) (*(xdrs)->x_ops->x_getint32)(xdrs, int32p)
#define XDR_GETLONG(xdrs,longp) (*(xdrs)->x_ops->x_getlong)(xdrs, longp)
#define xdr_getlong(xdrs,longp) (*(xdrs)->x_ops->x_getlong)(xdrs, longp)
#define XDR_GETPOS(xdrs) (*(xdrs)->x_ops->x_getpostn)(xdrs)
#define xdr_getpos(xdrs) (*(xdrs)->x_ops->x_getpostn)(xdrs)
#define XDR_INLINE(xdrs,len) (*(xdrs)->x_ops->x_inline)(xdrs, len)
#define xdr_inline(xdrs,len) (*(xdrs)->x_ops->x_inline)(xdrs, len)
#define XDR_PUTBYTES(xdrs,addr,len) (*(xdrs)->x_ops->x_putbytes)(xdrs, addr, len)
#define xdr_putbytes(xdrs,addr,len) (*(xdrs)->x_ops->x_putbytes)(xdrs, addr, len)
#define XDR_PUTINT32(xdrs,int32p) (*(xdrs)->x_ops->x_putint32)(xdrs, int32p)
#define xdr_putint32(xdrs,int32p) (*(xdrs)->x_ops->x_putint32)(xdrs, int32p)
#define XDR_PUTLONG(xdrs,longp) (*(xdrs)->x_ops->x_putlong)(xdrs, longp)
#define xdr_putlong(xdrs,longp) (*(xdrs)->x_ops->x_putlong)(xdrs, longp)
#define XDR_SETPOS(xdrs,pos) (*(xdrs)->x_ops->x_setpostn)(xdrs, pos)
#define xdr_setpos(xdrs,pos) (*(xdrs)->x_ops->x_setpostn)(xdrs, pos)
enum xdr_op {
XDR_ENCODE,
XDR_DECODE,
XDR_FREE
};
typedef struct XDR {
enum xdr_op x_op;
struct xdr_ops *x_ops;
caddr_t x_public;
caddr_t x_private;
caddr_t x_base;
int x_handy;
} XDR;
struct xdr_ops {
bool_t(*x_getlong) (XDR * __xdrs, long int *__lp);
bool_t(*x_putlong) (XDR * __xdrs, long int *__lp);
bool_t(*x_getbytes) (XDR * __xdrs, caddr_t __addr, u_int __len);
bool_t(*x_putbytes) (XDR * __xdrs, char *__addr, u_int __len);
u_int(*x_getpostn) (XDR * __xdrs);
bool_t(*x_setpostn) (XDR * __xdrs, u_int __pos);
int32_t *(*x_inline) (XDR * __xdrs, int __len);
void (*x_destroy) (XDR * __xdrs);
bool_t(*x_getint32) (XDR * __xdrs, int32_t * __ip);
bool_t(*x_putint32) (XDR * __xdrs, int32_t * __ip);
};
typedef bool_t(*xdrproc_t) (XDR *, void *, ...);
struct xdr_discrim {
int value;
xdrproc_t proc;
};
extern bool_t xdrrec_endofrecord(XDR *, bool_t);
extern bool_t xdrrec_skiprecord(XDR *);
extern void xdrstdio_create(XDR *, FILE *, enum xdr_op);
extern bool_t xdr_array(XDR *, caddr_t *, u_int *, u_int, u_int,
xdrproc_t);
extern bool_t xdr_bool(XDR *, bool_t *);
extern bool_t xdr_bytes(XDR *, char **, u_int *, u_int);
extern bool_t xdr_char(XDR *, char *);
extern bool_t xdr_double(XDR *, double *);
extern bool_t xdr_enum(XDR *, enum_t *);
extern bool_t xdr_float(XDR *, float *);
extern void xdr_free(xdrproc_t, char *);
extern bool_t xdr_int(XDR *, int *);
extern bool_t xdr_long(XDR *, long int *);
extern bool_t xdr_opaque(XDR *, caddr_t, u_int);
extern bool_t xdr_pointer(XDR *, char **, u_int, xdrproc_t);
extern bool_t xdr_reference(XDR *, caddr_t *, u_int, xdrproc_t);
extern bool_t xdr_short(XDR *, short *);
extern bool_t xdr_string(XDR *, char **, u_int);
extern bool_t xdr_u_char(XDR *, u_char *);
extern bool_t xdr_u_int(XDR *, u_int *);
extern bool_t xdr_u_long(XDR *, u_long *);
extern bool_t xdr_u_short(XDR *, u_short *);
extern bool_t xdr_union(XDR *, enum_t *, char *,
const struct xdr_discrim *, xdrproc_t);
extern bool_t xdr_vector(XDR *, char *, u_int, u_int, xdrproc_t);
extern bool_t xdr_void(void);
extern bool_t xdr_wrapstring(XDR *, char **);
extern void xdrmem_create(XDR *, caddr_t, u_int, enum xdr_op);
extern void xdrrec_create(XDR *, u_int, u_int, caddr_t,
int (*)(char *p1, char *p2, int p3)
, int (*)(char *p1, char *p2, int p3)
);
extern bool_t xdrrec_eof(XDR *); |
#define __CPUELT(cpu) ((cpu) / __NCPUBITS)
#define __CPUMASK(cpu) ((__cpu_mask) 1 << ((cpu) % __NCPUBITS))
#define __NCPUBITS (8 * sizeof (__cpu_mask))
#define SCHED_OTHER 0
#define SCHED_FIFO 1
#define __CPU_SETSIZE 1024
#define SCHED_RR 2
#define CPU_ALLOC(count) __CPU_ALLOC (count)
#define CPU_ALLOC_SIZE(count) __CPU_ALLOC_SIZE (count)
#define CPU_COUNT(cpusetp) __CPU_COUNT_S (sizeof (cpu_set_t), cpusetp)
#define CPU_FREE(cpuset) __CPU_FREE (cpuset)
#define CPU_SETSIZE __CPU_SETSIZE
#define CPU_ZERO(cpusetp) __CPU_ZERO_S (sizeof (cpu_set_t), cpusetp)
struct sched_param {
int sched_priority;
};
typedef unsigned long int __cpu_mask;
typedef struct {
__cpu_mask __bits[__CPU_SETSIZE / __NCPUBITS];
} cpu_set_t;
extern int sched_get_priority_max(int);
extern int sched_get_priority_min(int);
extern int sched_getparam(pid_t, struct sched_param *);
extern int sched_getscheduler(pid_t);
extern int sched_rr_get_interval(pid_t, struct timespec *);
extern int sched_setparam(pid_t, const struct sched_param *);
extern int sched_setscheduler(pid_t, int, const struct sched_param *);
extern int sched_yield(void);
extern int sched_getaffinity(pid_t, size_t, cpu_set_t *);
extern int sched_setaffinity(pid_t, size_t, const cpu_set_t *); |
typedef struct entry {
char *key;
void *data;
} ENTRY;
typedef enum {
FIND,
ENTER
} ACTION;
struct _ENTRY;
typedef enum {
preorder,
postorder,
endorder,
leaf
} VISIT;
struct hsearch_data {
struct _ENTRY *table;
unsigned int size;
unsigned int filled;
};
typedef void (*__action_fn_t) (const void *__nodep, VISIT __value,
int __level);
extern int hcreate_r(size_t, struct hsearch_data *);
extern void hdestroy_r(struct hsearch_data *);
extern int hsearch_r(ENTRY, ACTION, ENTRY * *, struct hsearch_data *);
extern int hcreate(size_t);
extern ENTRY *hsearch(ENTRY, ACTION);
extern void insque(void *, void *);
extern void *lfind(const void *, const void *, size_t *, size_t,
__compar_fn_t);
extern void *lsearch(const void *, void *, size_t *, size_t,
__compar_fn_t);
extern void remque(void *);
extern void hdestroy(void);
extern void *tdelete(const void *, void **, __compar_fn_t);
extern void *tfind(const void *, void *const *, __compar_fn_t);
extern void *tsearch(const void *, void **, __compar_fn_t);
extern void twalk(const void *, __action_fn_t); |
#define setjmp(env) _setjmp(env)
#define sigsetjmp(a,b) __sigsetjmp(a,b)
struct __jmp_buf_tag {
__jmp_buf __jmpbuf;
int __mask_was_saved;
sigset_t __saved_mask;
};
typedef struct __jmp_buf_tag jmp_buf[1];
typedef jmp_buf sigjmp_buf;
extern int __sigsetjmp(jmp_buf, int);
extern void longjmp(jmp_buf, int);
extern void siglongjmp(sigjmp_buf, int);
extern void _longjmp(jmp_buf, int);
extern int _setjmp(jmp_buf); |
#define sigpause __xpg_sigpause
#define _SIGSET_NWORDS (1024/(8*sizeof(unsigned long)))
#define SIGRTMAX (__libc_current_sigrtmax ())
#define SIGRTMIN (__libc_current_sigrtmin ())
#define NSIG 65
#define SIG_BLOCK 0 /* Block signals. */
#define SIG_UNBLOCK 1 /* Unblock signals. */
#define SIG_SETMASK 2 /* Set the set of blocked signals. */
typedef int sig_atomic_t;
typedef void (*sighandler_t) (int);
#define SIG_HOLD ((sighandler_t) 2) /* Request that signal be held. */
#define SIG_DFL ((sighandler_t)0) /* Request for default signal handling. */
#define SIG_IGN ((sighandler_t)1) /* Request that signal be ignored. */
#define SIG_ERR ((sighandler_t)-1) /* Return value from signal() in case of error. */
#define SIGHUP 1 /* Hangup. */
#define SIGINT 2 /* Terminal interrupt signal. */
#define SIGQUIT 3 /* Terminal quit signal. */
#define SIGILL 4 /* Illegal instruction. */
#define SIGTRAP 5 /* Trace/breakpoint trap. */
#define SIGABRT 6 /* Process abort signal. */
#define SIGIOT 6 /* IOT trap */
#define SIGBUS 7 /* Access to an undefined portion of a memory object. */
#define SIGFPE 8 /* Erroneous arithmetic operation. */
#define SIGKILL 9 /* Kill (cannot be caught or ignored). */
#define SIGUSR1 10 /* User-defined signal 1. */
#define SIGSEGV 11 /* Invalid memory reference. */
#define SIGUSR2 12 /* User-defined signal 2. */
#define SIGPIPE 13 /* Write on a pipe with no one to read it. */
#define SIGALRM 14 /* Alarm clock. */
#define SIGTERM 15 /* Termination signal. */
#define SIGSTKFLT 16 /* Stack fault. */
#define SIGCHLD 17 /* Child process terminated, stopped, or continued. */
#define SIGCLD SIGCHLD /* Same as SIGCHLD */
#define SIGCONT 18 /* Continue executing, if stopped. */
#define SIGSTOP 19 /* Stop executing (cannot be caught or ignored). */
#define SIGTSTP 20 /* Terminal stop signal. */
#define SIGTTIN 21 /* Background process attempting read. */
#define SIGTTOU 22 /* Background process attempting write. */
#define SIGURG 23 /* High bandwidth data is available at a socket. */
#define SIGXCPU 24 /* CPU time limit exceeded. */
#define SIGXFSZ 25 /* File size limit exceeded. */
#define SIGVTALRM 26 /* Virtual timer expired. */
#define SIGPROF 27 /* Profiling timer expired. */
#define SIGWINCH 28 /* Window size change. */
#define SIGIO 29 /* I/O now possible. */
#define SIGPOLL SIGIO /* Pollable event. */
#define SIGPWR 30 /* Power failure restart */
#define SIGSYS 31 /* Bad system call. */
#define SIGUNUSED 31
#define SV_ONSTACK (1<<0) /* Take the signal on the signal stack. */
#define SV_INTERRUPT (1<<1) /* Do not restart system calls. */
#define SV_RESETHAND (1<<2) /* Reset handler to SIG_DFL on receipt. */
typedef union sigval {
int sival_int;
void *sival_ptr;
} sigval_t;
#define SIGEV_SIGNAL 0 /* Notify via signal. */
#define SIGEV_NONE 1 /* Other notification: meaningless. */
#define SIGEV_THREAD 2 /* Deliver via thread creation. */
#define SIGEV_MAX_SIZE 64
typedef struct sigevent {
sigval_t sigev_value;
int sigev_signo;
int sigev_notify;
union {
int _pad[SIGEV_PAD_SIZE];
struct {
void (*_function) (sigval_t);
void *_attribute;
} _sigev_thread;
} _sigev_un;
} sigevent_t;
#define SI_MAX_SIZE 128
#define si_pid _sifields._kill._pid
#define si_uid _sifields._kill._uid
#define si_value _sifields._rt._sigval
#define si_int _sifields._rt._sigval.sival_int
#define si_ptr _sifields._rt._sigval.sival_ptr
#define si_status _sifields._sigchld._status
#define si_stime _sifields._sigchld._stime
#define si_utime _sifields._sigchld._utime
#define si_addr _sifields._sigfault._addr
#define si_band _sifields._sigpoll._band
#define si_fd _sifields._sigpoll._fd
#define si_timer1 _sifields._timer._timer1
#define si_timer2 _sifields._timer._timer2
typedef struct siginfo {
int si_signo;
int si_errno;
int si_code;
union {
int _pad[SI_PAD_SIZE];
struct {
pid_t _pid;
uid_t _uid;
} _kill;
struct {
unsigned int _timer1;
unsigned int _timer2;
} _timer;
struct {
pid_t _pid;
uid_t _uid;
sigval_t _sigval;
} _rt;
struct {
pid_t _pid;
uid_t _uid;
int _status;
clock_t _utime;
clock_t _stime;
} _sigchld;
struct {
void *_addr;
} _sigfault;
struct {
int _band;
int _fd;
} _sigpoll;
} _sifields;
} siginfo_t;
#define SI_QUEUE -1 /* Sent by sigqueue. */
#define SI_TIMER -2 /* Sent by timer expiration. */
#define SI_MESGQ -3 /* Sent by real time mesq state change. */
#define SI_ASYNCIO -4 /* Sent by AIO completion. */
#define SI_SIGIO -5 /* Sent by queued SIGIO. */
#define SI_TKILL -6 /* Sent by tkill. */
#define SI_ASYNCNL -60 /* Sent by asynch name lookup completion. */
#define SI_USER 0 /* Sent by kill, sigsend, raise. */
#define SI_KERNEL 0x80 /* Sent by kernel. */
#define ILL_ILLOPC 1 /* Illegal opcode. */
#define ILL_ILLOPN 2 /* Illegal operand. */
#define ILL_ILLADR 3 /* Illegal addressing mode. */
#define ILL_ILLTRP 4 /* Illegal trap. */
#define ILL_PRVOPC 5 /* Privileged opcode. */
#define ILL_PRVREG 6 /* Privileged register. */
#define ILL_COPROC 7 /* Coprocessor error. */
#define ILL_BADSTK 8 /* Internal stack error. */
#define FPE_INTDIV 1 /* Integer divide by zero. */
#define FPE_INTOVF 2 /* Integer overflow. */
#define FPE_FLTDIV 3 /* Floating-point divide by zero. */
#define FPE_FLTOVF 4 /* Floating-point overflow. */
#define FPE_FLTUND 5 /* Floating-point underflow. */
#define FPE_FLTRES 6 /* Floating-point inexact result. */
#define FPE_FLTINV 7 /* Invalid floating-point operation. */
#define FPE_FLTSUB 8 /* Subscript out of range. */
#define SEGV_MAPERR 1 /* Address not mapped to object. */
#define SEGV_ACCERR 2 /* Invalid permissions for mapped object. */
#define BUS_ADRALN 1 /* Invalid address alignment. */
#define BUS_ADRERR 2 /* Nonexistent physical address. */
#define BUS_OBJERR 3 /* Object-specific hardware error. */
#define TRAP_BRKPT 1 /* Process breakpoint. */
#define TRAP_TRACE 2 /* Process trace trap. */
#define CLD_EXITED 1 /* Child has exited. */
#define CLD_KILLED 2 /* Child has terminated abnormally and did not create a core fi */
#define CLD_DUMPED 3 /* Child has terminated abnormally and created a core file. */
#define CLD_TRAPPED 4 /* Traced child has trapped. */
#define CLD_STOPPED 5 /* Child has stopped. */
#define CLD_CONTINUED 6 /* Stopped child has continued. */
#define POLL_IN 1 /* Data input available. */
#define POLL_OUT 2 /* Output buffers available. */
#define POLL_MSG 3 /* Input message available. */
#define POLL_ERR 4 /* I/O error. */
#define POLL_PRI 5 /* High priority input available. */
#define POLL_HUP 6 /* Device disconnected. */
typedef struct {
unsigned long int sig[_SIGSET_NWORDS];
} sigset_t;
#define SA_INTERRUPT 0x20000000
#define sa_handler __sigaction_handler._sa_handler
#define sa_sigaction __sigaction_handler._sa_sigaction
#define SA_ONSTACK 0x08000000 /* Use signal stack by using `sa_restorer`. */
#define SA_RESETHAND 0x80000000 /* Reset to SIG_DFL on entry to handler. */
#define SA_NOCLDSTOP 0x00000001 /* Don't send SIGCHLD when children stop. */
#define SA_SIGINFO 0x00000004 /* Invoke signal-catching function with three arguments instead of one. */
#define SA_NODEFER 0x40000000 /* Don't automatically block the signal when its handler is being executed. */
#define SA_RESTART 0x10000000 /* Restart syscall on signal return. */
#define SA_NOCLDWAIT 0x00000002 /* Don't create zombie on child death. */
#define SA_NOMASK SA_NODEFER
#define SA_ONESHOT SA_RESETHAND
typedef struct sigaltstack {
void *ss_sp;
int ss_flags;
size_t ss_size;
} stack_t;
#define SS_ONSTACK 1
#define SS_DISABLE 2
extern int __libc_current_sigrtmax(void);
extern int __libc_current_sigrtmin(void);
extern sighandler_t __sysv_signal(int, sighandler_t);
extern char *const _sys_siglist[];
extern int killpg(pid_t, int);
extern void psignal(int, const char *);
extern int raise(int);
extern int sigaddset(sigset_t *, int);
extern int sigandset(sigset_t *, const sigset_t *, const sigset_t *);
extern int sigdelset(sigset_t *, int);
extern int sigemptyset(sigset_t *);
extern int sigfillset(sigset_t *);
extern int sighold(int);
extern int sigignore(int);
extern int siginterrupt(int, int);
extern int sigisemptyset(const sigset_t *);
extern int sigismember(const sigset_t *, int);
extern int sigorset(sigset_t *, const sigset_t *, const sigset_t *);
extern int sigpending(sigset_t *);
extern int sigrelse(int);
extern sighandler_t sigset(int, sighandler_t);
extern int pthread_kill(pthread_t, int);
extern int pthread_sigmask(int, const sigset_t *, sigset_t *);
extern int sigaction(int, const struct sigaction *, struct sigaction *);
extern int sigwait(const sigset_t *, int *);
extern int kill(pid_t, int);
extern int sigaltstack(const struct sigaltstack *, struct sigaltstack *);
extern sighandler_t signal(int, sighandler_t);
extern int sigprocmask(int, const sigset_t *, sigset_t *);
extern int sigreturn(struct sigcontext *);
extern int sigsuspend(const sigset_t *);
extern int sigqueue(pid_t, int, const union sigval);
extern int sigwaitinfo(const sigset_t *, siginfo_t *);
extern int sigtimedwait(const sigset_t *, siginfo_t *,
const struct timespec *);
extern sighandler_t bsd_signal(int, sighandler_t);
extern int __xpg_sigpause(int); |
#define POSIX_SPAWN_RESETIDS 0x01
#define POSIX_SPAWN_SETPGROUP 0x02
#define POSIX_SPAWN_SETSIGDEF 0x04
#define POSIX_SPAWN_SETSIGMASK 0x08
#define POSIX_SPAWN_SETSCHEDPARAM 0x10
#define POSIX_SPAWN_SETSCHEDULER 0x20
typedef struct {
int __allocated;
int __used;
struct __spawn_action *__actions;
int __pad[16];
} posix_spawn_file_actions_t;
typedef struct {
short __flags;
pid_t __pgrp;
sigset_t __sd;
sigset_t __ss;
struct sched_param __sp;
int __policy;
int __pad[16];
} posix_spawnattr_t;
extern int posix_spawn(pid_t *, const char *,
const posix_spawn_file_actions_t *,
const posix_spawnattr_t *, char *const[],
char *const[]);
extern int posix_spawn_file_actions_addclose(posix_spawn_file_actions_t *,
int);
extern int posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t *,
int, int);
extern int posix_spawn_file_actions_addopen(posix_spawn_file_actions_t *,
int, const char *, int,
mode_t);
extern int posix_spawn_file_actions_destroy(posix_spawn_file_actions_t *);
extern int posix_spawn_file_actions_init(posix_spawn_file_actions_t *);
extern int posix_spawnattr_destroy(posix_spawnattr_t *);
extern int posix_spawnattr_getflags(const posix_spawnattr_t *,
short int *);
extern int posix_spawnattr_getpgroup(const posix_spawnattr_t *, pid_t *);
extern int posix_spawnattr_getschedparam(const posix_spawnattr_t *,
struct sched_param *);
extern int posix_spawnattr_getschedpolicy(const posix_spawnattr_t *,
int *);
extern int posix_spawnattr_getsigdefault(const posix_spawnattr_t *,
sigset_t *);
extern int posix_spawnattr_getsigmask(const posix_spawnattr_t *,
sigset_t *);
extern int posix_spawnattr_init(posix_spawnattr_t *);
extern int posix_spawnattr_setflags(posix_spawnattr_t *, short int);
extern int posix_spawnattr_setpgroup(posix_spawnattr_t *, pid_t);
extern int posix_spawnattr_setschedparam(posix_spawnattr_t *,
const struct sched_param *);
extern int posix_spawnattr_setschedpolicy(posix_spawnattr_t *, int);
extern int posix_spawnattr_setsigdefault(posix_spawnattr_t *,
const sigset_t *);
extern int posix_spawnattr_setsigmask(posix_spawnattr_t *,
const sigset_t *);
extern int posix_spawnp(pid_t *, const char *,
const posix_spawn_file_actions_t *,
const posix_spawnattr_t *, char *const[],
char *const[]); |
#define offsetof(TYPE,MEMBER) ((size_t)&((TYPE*)0)->MEMBER) #ifndef NULL # ifdef __cplusplus # define NULL (0L) # else # define NULL ((void*) 0) # endif #endif |
#define INT16_C(c) c #define INT32_C(c) c #define INT8_C(c) c #define UINT16_C(c) c #define UINT8_C(c) c #define UINT32_C(c) c ## U #define INT8_MIN (-128) #define INT_FAST8_MIN (-128) #define INT_LEAST8_MIN (-128) #define INT32_MIN (-2147483647-1) #define INT_LEAST32_MIN (-2147483647-1) #define SIG_ATOMIC_MIN (-2147483647-1) #define INT16_MIN (-32767-1) #define INT_LEAST16_MIN (-32767-1) #define INT64_MIN (-__INT64_C(9223372036854775807)-1) #define INTMAX_MIN (-__INT64_C(9223372036854775807)-1) #define INT_FAST64_MIN (-__INT64_C(9223372036854775807)-1) #define INT_LEAST64_MIN (-__INT64_C(9223372036854775807)-1) #define WINT_MIN (0u) #define INT8_MAX (127) #define INT_FAST8_MAX (127) #define INT_LEAST8_MAX (127) #define INT32_MAX (2147483647) #define INT_LEAST32_MAX (2147483647) #define SIG_ATOMIC_MAX (2147483647) #define UINT8_MAX (255) #define UINT_FAST8_MAX (255) #define UINT_LEAST8_MAX (255) #define INT16_MAX (32767) #define INT_LEAST16_MAX (32767) #define UINT32_MAX (4294967295U) #define UINT_LEAST32_MAX (4294967295U) #define WINT_MAX (4294967295u) #define UINT16_MAX (65535) #define UINT_LEAST16_MAX (65535) #define INT64_MAX (__INT64_C(9223372036854775807)) #define INTMAX_MAX (__INT64_C(9223372036854775807)) #define INT_FAST64_MAX (__INT64_C(9223372036854775807)) #define INT_LEAST64_MAX (__INT64_C(9223372036854775807)) #define UINT64_MAX (__UINT64_C(18446744073709551615)) #define UINTMAX_MAX (__UINT64_C(18446744073709551615)) #define UINT_FAST64_MAX (__UINT64_C(18446744073709551615)) #define UINT_LEAST64_MAX (__UINT64_C(18446744073709551615)) typedef signed char int8_t; typedef short int16_t; typedef int int32_t; typedef unsigned char uint8_t; typedef unsigned short uint16_t; typedef unsigned int uint32_t; typedef signed char int_least8_t; typedef short int int_least16_t; typedef int int_least32_t; typedef unsigned char uint_least8_t; typedef unsigned short uint_least16_t; typedef unsigned int uint_least32_t; typedef signed char int_fast8_t; typedef unsigned char uint_fast8_t; |
#define EOF (-1)
#define P_tmpdir "/tmp"
#define FOPEN_MAX 16
#define L_tmpnam 20
#define FILENAME_MAX 4096
#define BUFSIZ 8192
#define L_ctermid 9
#define L_cuserid 9
typedef struct {
off_t __pos;
mbstate_t __state;
} fpos_t;
typedef struct {
off64_t __pos;
mbstate_t __state;
} fpos64_t;
typedef struct _IO_FILE FILE;
#define _IOFBF 0
#define _IOLBF 1
#define _IONBF 2
extern void clearerr_unlocked(FILE *);
extern int feof_unlocked(FILE *);
extern int ferror_unlocked(FILE *);
extern char *fgets_unlocked(char *, int, FILE *);
extern int fputc_unlocked(int, FILE *);
extern int fputs_unlocked(const char *, FILE *);
extern size_t fread_unlocked(void *, size_t, size_t, FILE *);
extern size_t fwrite_unlocked(const void *, size_t, size_t, FILE *);
extern FILE *open_memstream(char **, size_t *);
extern int fgetc_unlocked(FILE *);
extern int fileno_unlocked(FILE *);
extern ssize_t getdelim(char **, size_t *, int, FILE *);
extern ssize_t getline(char **, size_t *, FILE *);
extern FILE *fmemopen(void *, size_t, const char *);
extern char *const _sys_errlist[];
extern void clearerr(FILE *);
extern int fclose(FILE *);
extern FILE *fdopen(int, const char *);
extern int fflush_unlocked(FILE *);
extern int fileno(FILE *);
extern FILE *fopen(const char *, const char *);
extern int fprintf(FILE *, const char *, ...);
extern int fputc(int, FILE *);
extern FILE *freopen(const char *, const char *, FILE *);
extern FILE *freopen64(const char *, const char *, FILE *);
extern int fscanf(FILE *, const char *, ...);
extern int fseek(FILE *, long int, int);
extern int fseeko(FILE *, off_t, int);
extern int fseeko64(FILE *, loff_t, int);
extern off_t ftello(FILE *);
extern loff_t ftello64(FILE *);
extern int getchar(void);
extern int getchar_unlocked(void);
extern int getw(FILE *);
extern int pclose(FILE *);
extern void perror(const char *);
extern FILE *popen(const char *, const char *);
extern int printf(const char *, ...);
extern int putc_unlocked(int, FILE *);
extern int putchar(int);
extern int putchar_unlocked(int);
extern int putw(int, FILE *);
extern int remove(const char *);
extern void rewind(FILE *);
extern int scanf(const char *, ...);
extern void setbuf(FILE *, char *);
extern int sprintf(char *, const char *, ...);
extern int sscanf(const char *, const char *, ...);
extern FILE *stderr;
extern FILE *stdin;
extern FILE *stdout;
extern char *tempnam(const char *, const char *);
extern FILE *tmpfile64(void);
extern FILE *tmpfile(void);
extern char *tmpnam(char *);
extern int vfprintf(FILE *, const char *, va_list);
extern int vprintf(const char *, va_list);
extern int feof(FILE *);
extern int ferror(FILE *);
extern int fflush(FILE *);
extern int fgetc(FILE *);
extern int fgetpos(FILE *, fpos_t *);
extern char *fgets(char *, int, FILE *);
extern int fputs(const char *, FILE *);
extern size_t fread(void *, size_t, size_t, FILE *);
extern int fsetpos(FILE *, const fpos_t *);
extern long int ftell(FILE *);
extern size_t fwrite(const void *, size_t, size_t, FILE *);
extern int getc(FILE *);
extern int putc(int, FILE *);
extern int puts(const char *);
extern int setvbuf(FILE *, char *, int, size_t);
extern int snprintf(char *, size_t, const char *, ...);
extern int ungetc(int, FILE *);
extern int vsnprintf(char *, size_t, const char *, va_list);
extern int vsprintf(char *, const char *, va_list);
extern void flockfile(FILE *);
extern int asprintf(char **, const char *, ...);
extern int fgetpos64(FILE *, fpos64_t *);
extern FILE *fopen64(const char *, const char *);
extern int fsetpos64(FILE *, const fpos64_t *);
extern int ftrylockfile(FILE *);
extern void funlockfile(FILE *);
extern int getc_unlocked(FILE *);
extern void setbuffer(FILE *, char *, size_t);
extern int vasprintf(char **, const char *, va_list);
extern int vdprintf(int, const char *, va_list);
extern int vfscanf(FILE *, const char *, va_list);
extern int vscanf(const char *, va_list);
extern int vsscanf(const char *, const char *, va_list);
extern size_t __fpending(FILE *);
extern char *__fgets_chk(char *, size_t, int, FILE *);
extern char *__fgets_unlocked_chk(char *, size_t, int, FILE *);
extern int __vsprintf_chk(char *, int, size_t, const char *, va_list);
extern int __vprintf_chk(int, const char *, va_list);
extern int __printf_chk(int, const char *, ...);
extern int __vsnprintf_chk(char *, size_t, int, size_t, const char *,
va_list);
extern int __snprintf_chk(char *, size_t, int, size_t, const char *, ...);
extern int __sprintf_chk(char *, int, size_t, const char *, ...);
extern int dprintf(int, const char *, ...);
extern int renameat(int, const char *, int, const char *); |
#define MB_CUR_MAX (__ctype_get_mb_cur_max())
#define EXIT_SUCCESS 0
#define EXIT_FAILURE 1
#define RAND_MAX 2147483647
struct drand48_data {
unsigned short __x[3];
unsigned short __old_x[3];
unsigned short __c;
unsigned short __init;
unsigned long long int __a;
};
typedef int (*__compar_fn_t) (const void *, const void *);
struct random_data {
int32_t *fptr;
int32_t *rptr;
int32_t *state;
int rand_type;
int rand_deg;
int rand_sep;
int32_t *end_ptr;
};
typedef struct {
int quot;
int rem;
} div_t;
typedef struct {
long int quot;
long int rem;
} ldiv_t;
typedef struct {
long long int quot;
long long int rem;
} lldiv_t;
extern int initstate_r(unsigned int, char *, size_t, struct random_data *);
extern int srandom_r(unsigned int, struct random_data *);
extern double __strtod_internal(const char *, char **, int);
extern float __strtof_internal(const char *, char **, int);
extern long int __strtol_internal(const char *, char **, int, int);
extern long double __strtold_internal(const char *, char **, int);
extern long long int __strtoll_internal(const char *, char **, int, int);
extern unsigned long int __strtoul_internal(const char *, char **, int,
int);
extern unsigned long long int __strtoull_internal(const char *, char **,
int, int);
extern long int a64l(const char *);
extern void abort(void);
extern int abs(int);
extern double atof(const char *);
extern int atoi(const char *);
extern long int atol(const char *);
extern long long int atoll(const char *);
extern void *bsearch(const void *, const void *, size_t, size_t,
__compar_fn_t);
extern div_t div(int, int);
extern double drand48(void);
extern int drand48_r(struct drand48_data *, double *);
extern char *ecvt(double, int, int *, int *);
extern double erand48(unsigned short[3]);
extern void exit(int);
extern char *fcvt(double, int, int *, int *);
extern char *gcvt(double, int, char *);
extern char *getenv(const char *);
extern int getsubopt(char **, char *const *, char **);
extern int grantpt(int);
extern long int jrand48(unsigned short[3]);
extern char *l64a(long int);
extern long int labs(long int);
extern void lcong48(unsigned short[7]);
extern ldiv_t ldiv(long int, long int);
extern long long int llabs(long long int);
extern lldiv_t lldiv(long long int, long long int);
extern long int lrand48(void);
extern int lrand48_r(struct drand48_data *, long int *);
extern int mblen(const char *, size_t);
extern size_t mbstowcs(wchar_t *, const char *, size_t);
extern int mbtowc(wchar_t *, const char *, size_t);
extern char *mktemp(char *);
extern long int mrand48(void);
extern int mrand48_r(struct drand48_data *, long int *);
extern long int nrand48(unsigned short[3]);
extern char *ptsname(int);
extern int putenv(char *);
extern void qsort(void *, size_t, size_t, const __compar_fn_t);
extern int rand(void);
extern int rand_r(unsigned int *);
extern unsigned short *seed48(unsigned short[3]);
extern void srand48(long int);
extern int unlockpt(int);
extern size_t wcstombs(char *, const wchar_t *, size_t);
extern int wctomb(char *, wchar_t);
extern int system(const char *);
extern void *calloc(size_t, size_t);
extern void free(void *);
extern char *initstate(unsigned int, char *, size_t);
extern void *malloc(size_t);
extern long int random(void);
extern void *realloc(void *, size_t);
extern char *setstate(char *);
extern void srand(unsigned int);
extern void srandom(unsigned int);
extern double strtod(const char *, char **);
extern float strtof(const char *, char **);
extern long int strtol(const char *, char **, int);
extern long double strtold(const char *, char **);
extern long long int strtoll(const char *, char **, int);
extern long long int strtoq(const char *, char **, int);
extern unsigned long int strtoul(const char *, char **, int);
extern unsigned long long int strtoull(const char *, char **, int);
extern unsigned long long int strtouq(const char *, char **, int);
extern void _Exit(int);
extern size_t __ctype_get_mb_cur_max(void);
extern char **environ;
extern int erand48_r(unsigned short[3], struct drand48_data *, double *);
extern int jrand48_r(unsigned short[3], struct drand48_data *, long int *);
extern int lcong48_r(unsigned short[7], struct drand48_data *);
extern int nrand48_r(unsigned short[3], struct drand48_data *, long int *);
extern int random_r(struct random_data *, int32_t *);
extern char *realpath(const char *, char *);
extern int seed48_r(unsigned short[3], struct drand48_data *);
extern int setenv(const char *, const char *, int);
extern int setstate_r(char *, struct random_data *);
extern int srand48_r(long int, struct drand48_data *);
extern int unsetenv(const char *);
extern int getloadavg(double[], int);
extern int mkstemp64(char *);
extern int posix_memalign(void **, size_t, size_t);
extern int posix_openpt(int);
extern size_t __mbstowcs_chk(wchar_t *, const char *, size_t, size_t);
extern char *__realpath_chk(const char *, char *, size_t);
extern size_t __wcstombs_chk(char *, const wchar_t *, size_t, size_t);
extern int __wctomb_chk(char *, wchar_t, size_t);
extern char *mkdtemp(char *); |
#define strerror_r __xpg_strerror_r extern void *__mempcpy(void *, const void *, size_t); extern char *__stpcpy(char *, const char *); extern char *__strtok_r(char *, const char *, char **); extern void *memchr(const void *, int, size_t); extern int memcmp(const void *, const void *, size_t); extern void *memcpy(void *, const void *, size_t); extern void *memmem(const void *, size_t, const void *, size_t); extern void *memmove(void *, const void *, size_t); extern void *memset(void *, int, size_t); extern char *strcat(char *, const char *); extern char *strchr(const char *, int); extern int strcmp(const char *, const char *); extern int strcoll(const char *, const char *); extern char *strcpy(char *, const char *); extern size_t strcspn(const char *, const char *); extern char *strerror(int); extern size_t strlen(const char *); extern char *strncat(char *, const char *, size_t); extern int strncmp(const char *, const char *, size_t); extern char *strncpy(char *, const char *, size_t); extern char *strpbrk(const char *, const char *); extern char *strrchr(const char *, int); extern char *strsignal(int); extern size_t strspn(const char *, const char *); extern char *strstr(const char *, const char *); extern char *strtok(char *, const char *); extern size_t strxfrm(char *, const char *, size_t); extern void *memccpy(void *, const void *, int, size_t); extern char *strdup(const char *); extern char *strndup(const char *, size_t); extern size_t strnlen(const char *, size_t); extern char *strsep(char **, const char *); extern char *strtok_r(char *, const char *, char **); extern char *strcasestr(const char *, const char *); extern char *stpcpy(char *, const char *); extern char *stpncpy(char *, const char *, size_t); extern void *memrchr(const void *, int, size_t); extern int __xpg_strerror_r(int, char *, size_t); extern void *__memmove_chk(void *, const void *, size_t, size_t); extern char *__strcat_chk(char *, const char *, size_t); extern char *__strncat_chk(char *, const char *, size_t, size_t); extern char *__strncpy_chk(char *, const char *, size_t, size_t); extern char *__stpcpy_chk(char *, const char *, size_t); extern char *__strcpy_chk(char *, const char *, size_t); extern void *__memset_chk(void *, int, size_t, size_t); extern void *__mempcpy_chk(void *, const void *, size_t, size_t); extern void *__memcpy_chk(void *, const void *, size_t, size_t); |
extern void bcopy(const void *, void *, size_t); extern int bcmp(const void *, const void *, size_t); extern void bzero(void *, size_t); extern int ffs(int); extern char *index(const char *, int); extern char *rindex(const char *, int); extern int strcasecmp(const char *, const char *); extern int strncasecmp(const char *, const char *, size_t); |
#define EPOLL_CTL_ADD 1 /* Add a file decriptor to the interface. */
#define EPOLL_CTL_DEL 2 /* Remove a file decriptor from the interface. */
#define EPOLL_CTL_MOD 3 /* Change file decriptor epoll_event structure. */
#define EPOLLIN 1
#define EPOLLPRI 2
#define EPOLLOUT 4
#define EPOLLERR 8
#define EPOLLHUP 16
#define EPOLLRDHUP
#define EPOLLONESHOT (1 << 30)
#define EPOLLET (1 << 31)
typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
struct epoll_event {
uint32_t events;
epoll_data_t data;
};
extern int epoll_wait(int, struct epoll_event *, int, int);
extern int epoll_ctl(int, int, int, struct epoll_event *);
extern int epoll_create(int); |
#define LOCK_SH 1 #define LOCK_EX 2 #define LOCK_NB 4 #define LOCK_UN 8 extern int flock(int, int); |
#define IN_ACCESS 0x00000001
#define IN_MODIFY 0x00000002
#define IN_ATTRIB 0x00000004
#define IN_CLOSE_WRITE 0x00000008
#define IN_CLOSE_NOWRITE 0x00000010
#define IN_OPEN 0x00000020
#define IN_MOVED_FROM 0x00000040
#define IN_MOVED_TO 0x00000080
#define IN_CREATE 0x00000100
#define IN_DELETE 0x00000200
#define IN_DELETE_SELF 0x00000400
#define IN_MOVE_SELF 0x00000800
#define IN_UNMOUNT 0x00002000
#define IN_Q_OVERFLOW 0x00004000
#define IN_IGNORED 0x00008000
#define IN_ISDIR 0x40000000
#define IN_ONESHOT 0x80000000
#define IN_CLOSE (IN_CLOSE_WRITE | IN_CLOSE_NOWRITE)
#define IN_MOVE (IN_MOVED_FROM | IN_MOVED_TO)
#define IN_ALL_EVENTS \
(IN_ACCESS | IN_MODIFY | IN_ATTRIB | IN_CLOSE_WRITE | \
IN_CLOSE_NOWRITE | IN_OPEN | IN_MOVED_FROM | IN_MOVED_TO | IN_CREATE | \
IN_DELETE | IN_DELETE_SELF | IN_MOVE_SELF)
struct inotify_event {
int wd;
uint32_t mask;
uint32_t cookie;
uint32_t len;
char name[0];
};
extern int inotify_add_watch(int, const char *, uint32_t);
extern int inotify_init(void);
extern int inotify_rm_watch(int, uint32_t); |
struct winsize {
unsigned short ws_row;
unsigned short ws_col;
unsigned short ws_xpixel;
unsigned short ws_ypixel;
};
extern int ioctl(int, unsigned long int, ...); |
#define IPC_PRIVATE ((key_t)0) #define IPC_RMID 0 #define IPC_CREAT 00001000 #define IPC_EXCL 00002000 #define IPC_NOWAIT 00004000 #define IPC_SET 1 #define IPC_STAT 2 extern key_t ftok(const char *, int); |
#define MAP_FAILED ((void*)-1) #define POSIX_MADV_NORMAL 0 #define PROT_NONE 0x0 #define MAP_SHARED 0x01 #define MAP_PRIVATE 0x02 #define PROT_READ 0x1 #define MAP_FIXED 0x10 #define PROT_WRITE 0x2 #define MAP_ANONYMOUS 0x20 #define PROT_EXEC 0x4 #define MREMAP_MAYMOVE 1 #define MS_ASYNC 1 #define POSIX_MADV_RANDOM 1 #define MREMAP_FIXED 2 #define MS_INVALIDATE 2 #define POSIX_MADV_SEQUENTIAL 2 #define POSIX_MADV_WILLNEED 3 #define MS_SYNC 4 #define POSIX_MADV_DONTNEED 4 #define MAP_ANON MAP_ANONYMOUS extern void *mremap(void *, size_t, size_t, int, ...); extern int posix_madvise(void *, size_t, int); extern int msync(void *, size_t, int); extern int mlock(const void *, size_t); extern int mlockall(int); extern void *mmap(void *, size_t, int, int, int, off_t); extern int mprotect(void *, size_t, int); extern int munlock(const void *, size_t); extern int munlockall(void); extern int munmap(void *, size_t); extern void *mmap64(void *, size_t, int, int, int, off64_t); extern int shm_open(const char *, int, mode_t); extern int shm_unlink(const char *); |
#define MSG_NOERROR 010000 extern int msgctl(int, int, struct msqid_ds *); extern int msgget(key_t, int); extern ssize_t msgrcv(int, void *, size_t, long int, int); extern int msgsnd(int, const void *, size_t, int); |
#define POLLIN 0x0001 /* There is data to read */
#define POLLPRI 0x0002 /* There is urgent data to read */
#define POLLOUT 0x0004 /* Writing now will not block */
#define POLLERR 0x0008 /* Error condition */
#define POLLHUP 0x0010 /* Hung up */
#define POLLNVAL 0x0020 /* Invalid request: fd not open */
#define POLLRDNORM 0x0040 /* Normal data may be read */
#define POLLRDBAND 0x0080 /* Priority data may be read */
#define POLLWRNORM 0x0100 /* Writing now will not block */
#define POLLWRBAND 0x0200 /* Priority data may be written */
struct pollfd {
int fd;
short events;
short revents;
};
typedef unsigned long int nfds_t; |
#define RUSAGE_CHILDREN (-1)
#define RLIM_INFINITY (~0UL)
#define RLIM_SAVED_CUR -1
#define RLIM_SAVED_MAX -1
#define RLIMIT_CPU 0
#define RUSAGE_SELF 0
#define RLIMIT_FSIZE 1
#define RLIMIT_LOCKS 10
#define RLIM_NLIMITS 11
#define RLIMIT_DATA 2
#define RLIMIT_STACK 3
#define RLIMIT_CORE 4
#define RLIMIT_RSS 5
#define RLIMIT_NPROC 6
#define RLIMIT_NOFILE 7
#define RLIMIT_MEMLOCK 8
#define RLIMIT_AS 9
typedef unsigned long int rlim_t;
typedef unsigned long long int rlim64_t;
typedef int __rlimit_resource_t;
struct rlimit {
rlim_t rlim_cur;
rlim_t rlim_max;
};
struct rlimit64 {
rlim64_t rlim_cur;
rlim64_t rlim_max;
};
struct rusage {
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 int ru_msgrcv;
long int ru_nsignals;
long int ru_nvcsw;
long int ru_nivcsw;
};
enum __priority_which {
PRIO_PROCESS = 0,
PRIO_PGRP = 1,
PRIO_USER = 2
};
#define PRIO_PGRP PRIO_PGRP
#define PRIO_PROCESS PRIO_PROCESS
#define PRIO_USER PRIO_USER
typedef enum __priority_which __priority_which_t;
extern int getpriority(__priority_which_t, id_t);
extern int getrlimit64(id_t, struct rlimit64 *);
extern int setpriority(__priority_which_t, id_t, int);
extern int setrlimit(__rlimit_resource_t, const struct rlimit *);
extern int setrlimit64(__rlimit_resource_t, const struct rlimit64 *);
extern int getrlimit(__rlimit_resource_t, struct rlimit *);
extern int getrusage(int, struct rusage *); |
#define NFDBITS (8 * sizeof (long)) extern int pselect(int, fd_set *, fd_set *, fd_set *, const struct timespec *, const sigset_t *); |
#define SEM_UNDO 0x1000
#define GETPID 11
#define GETVAL 12
#define GETALL 13
#define GETNCNT 14
#define GETZCNT 15
#define SETVAL 16
#define SETALL 17
struct sembuf {
short sem_num;
short sem_op;
short sem_flg;
};
extern int semctl(int, int, int, ...);
extern int semget(key_t, int, int);
extern int semop(int, struct sembuf *, size_t); |
extern ssize_t sendfile(int, int, off_t *, size_t); extern ssize_t sendfile64(int, int, off64_t *, size_t); |
#define SHM_RDONLY 010000 #define SHM_W 0200 #define SHM_RND 020000 #define SHM_R 0400 #define SHM_REMAP 040000 #define SHM_LOCK 11 #define SHM_UNLOCK 12 extern int __getpagesize(void); extern void *shmat(int, const void *, int); extern int shmctl(int, int, struct shmid_ds *); extern int shmdt(const void *); extern int shmget(key_t, size_t, int); |
#define CMSG_LEN(len) (CMSG_ALIGN(sizeof(struct cmsghdr))+(len))
#define SCM_RIGHTS 0x01
#define SOL_SOCKET 1
#define SOMAXCONN 128
#define SOL_RAW 255
#define CMSG_ALIGN(len) \
(((len)+sizeof(size_t)-1)&(size_t)~(sizeof(size_t)-1))
#define CMSG_DATA(cmsg) \
((unsigned char *) (cmsg) + CMSG_ALIGN(sizeof(struct cmsghdr)))
#define CMSG_SPACE(len) \
(CMSG_ALIGN(sizeof(struct cmsghdr))+CMSG_ALIGN(len))
#define CMSG_FIRSTHDR(msg) \
((msg)->msg_controllen >= sizeof(struct cmsghdr) ? \
(struct cmsghdr *)(msg)->msg_control : \
(struct cmsghdr *)NULL)
#define CMSG_NXTHDR(mhdr,cmsg) \
(((cmsg) == NULL) ? CMSG_FIRSTHDR(mhdr) : \
(((u_char *)(cmsg) + CMSG_ALIGN((cmsg)->cmsg_len) \
+ CMSG_ALIGN(sizeof(struct cmsghdr)) > \
(u_char *)((mhdr)->msg_control) + (mhdr)->msg_controllen) ? \
(struct cmsghdr *)NULL : \
(struct cmsghdr *)((u_char *)(cmsg) + CMSG_ALIGN((cmsg)->cmsg_len))))
struct linger {
int l_onoff;
int l_linger;
};
struct cmsghdr {
size_t cmsg_len;
int cmsg_level;
int cmsg_type;
};
struct iovec {
void *iov_base;
size_t iov_len;
};
typedef unsigned short sa_family_t;
typedef unsigned int socklen_t;
struct sockaddr {
sa_family_t sa_family;
char sa_data[14];
};
struct sockaddr_storage {
sa_family_t ss_family;
__ss_aligntype __ss_align;
char __ss_padding[(128 - (2 * sizeof(__ss_aligntype)))];
};
struct msghdr {
void *msg_name;
int msg_namelen;
struct iovec *msg_iov;
size_t msg_iovlen;
void *msg_control;
size_t msg_controllen;
unsigned int msg_flags;
};
#define AF_UNSPEC 0
#define AF_UNIX 1
#define AF_INET6 10
#define AF_INET 2
#define PF_INET AF_INET
#define PF_INET6 AF_INET6
#define PF_UNIX AF_UNIX
#define PF_UNSPEC AF_UNSPEC
#define SOCK_STREAM 1
#define SOCK_PACKET 10
#define SOCK_DGRAM 2
#define SOCK_RAW 3
#define SOCK_RDM 4
#define SOCK_SEQPACKET 5
#define SO_DEBUG 1
#define SO_OOBINLINE 10
#define SO_NO_CHECK 11
#define SO_PRIORITY 12
#define SO_LINGER 13
#define SO_BSDCOMPAT 14
#define SO_REUSEADDR 2
#define SO_TYPE 3
#define SO_ACCEPTCONN 30
#define SO_ERROR 4
#define SO_DONTROUTE 5
#define SO_BROADCAST 6
#define SO_SNDBUF 7
#define SO_RCVBUF 8
#define SO_KEEPALIVE 9
#define SIOCGIFNAME 0x8910
#define SIOCGIFCONF 0x8912
#define SIOCGIFFLAGS 0x8913
#define SIOCGIFADDR 0x8915
#define SIOCGIFDSTADDR 0x8917
#define SIOCGIFBRDADDR 0x8919
#define SIOCGIFNETMASK 0x891b
#define SIOCGIFMTU 0x8921
#define SIOCGIFHWADDR 0x8927
#define SHUT_RD 0
#define SHUT_WR 1
#define SHUT_RDWR 2
#define MSG_WAITALL 0x100
#define MSG_TRUNC 0x20
#define MSG_NOSIGNAL 0x4000
#define MSG_EOR 0x80
#define MSG_OOB 1
#define MSG_PEEK 2
#define MSG_DONTROUTE 4
#define MSG_CTRUNC 8
extern int bind(int, const struct sockaddr *, socklen_t);
extern int getnameinfo(const struct sockaddr *, socklen_t, char *,
socklen_t, char *, socklen_t, unsigned int);
extern int getsockname(int, struct sockaddr *, socklen_t *);
extern int listen(int, int);
extern int setsockopt(int, int, int, const void *, socklen_t);
extern int accept(int, struct sockaddr *, socklen_t *);
extern int connect(int, const struct sockaddr *, socklen_t);
extern ssize_t recv(int, void *, size_t, int);
extern ssize_t recvfrom(int, void *, size_t, int, struct sockaddr *,
socklen_t *);
extern ssize_t recvmsg(int, struct msghdr *, int);
extern ssize_t send(int, const void *, size_t, int);
extern ssize_t sendmsg(int, const struct msghdr *, int);
extern ssize_t sendto(int, const void *, size_t, int,
const struct sockaddr *, socklen_t);
extern int getpeername(int, struct sockaddr *, socklen_t *);
extern int getsockopt(int, int, int, void *, socklen_t *);
extern int shutdown(int, int);
extern int socket(int, int, int);
extern int socketpair(int, int, int, int[2]);
extern int sockatmark(int);
extern ssize_t __recv_chk(int, void *, size_t, size_t, int);
extern ssize_t __recvfrom_chk(int, void *, size_t, size_t, int,
struct sockaddr *, socklen_t *); |
#define S_ISBLK(m) (((m)&S_IFMT)==S_IFBLK) #define S_ISCHR(m) (((m)&S_IFMT)==S_IFCHR) #define S_ISDIR(m) (((m)&S_IFMT)==S_IFDIR) #define S_ISFIFO(m) (((m)&S_IFMT)==S_IFIFO) #define S_ISLNK(m) (((m)&S_IFMT)==S_IFLNK) #define S_ISREG(m) (((m)&S_IFMT)==S_IFREG) #define S_ISSOCK(m) (((m)&S_IFMT)==S_IFSOCK) #define S_TYPEISMQ(buf) ((buf)->st_mode - (buf)->st_mode) #define S_TYPEISSEM(buf) ((buf)->st_mode - (buf)->st_mode) #define S_TYPEISSHM(buf) ((buf)->st_mode - (buf)->st_mode) #define S_IRWXU (S_IREAD|S_IWRITE|S_IEXEC) #define S_IROTH (S_IRGRP>>3) #define S_IRGRP (S_IRUSR>>3) #define S_IRWXO (S_IRWXG>>3) #define S_IRWXG (S_IRWXU>>3) #define S_IWOTH (S_IWGRP>>3) #define S_IWGRP (S_IWUSR>>3) #define S_IXOTH (S_IXGRP>>3) #define S_IXGRP (S_IXUSR>>3) #define S_ISVTX 01000 #define S_IXUSR 0x0040 #define S_IWUSR 0x0080 #define S_IRUSR 0x0100 #define S_ISGID 0x0400 #define S_ISUID 0x0800 #define S_IFIFO 0x1000 #define S_IFCHR 0x2000 #define S_IFDIR 0x4000 #define S_IFBLK 0x6000 #define S_IFREG 0x8000 #define S_IFLNK 0xa000 #define S_IFSOCK 0xc000 #define S_IFMT 0xf000 #define st_atime st_atim.tv_sec #define st_ctime st_ctim.tv_sec #define st_mtime st_mtim.tv_sec #define S_IREAD S_IRUSR #define S_IWRITE S_IWUSR #define S_IEXEC S_IXUSR extern int __fxstat(int, int, struct stat *); extern int __fxstat64(int, int, struct stat64 *); extern int __lxstat(int, const char *, struct stat *); extern int __lxstat64(int, const char *, struct stat64 *); extern int __xmknod(int, const char *, mode_t, dev_t *); extern int __xstat(int, const char *, struct stat *); extern int __xstat64(int, const char *, struct stat64 *); extern int mkfifo(const char *, mode_t); extern int chmod(const char *, mode_t); extern int fchmod(int, mode_t); extern mode_t umask(mode_t); extern int mkfifoat(int, const char *, mode_t); extern int mkdirat(int, const char *, mode_t); extern int fchmodat(int, const char *, mode_t, int); extern int __fxstatat(int, int, const char *, struct stat *, int); extern int __fxstatat64(int, int, const char *, struct stat64 *, int); extern int __xmknodat(int, int, const char *, mode_t, dev_t *); |
#define NFS_SUPER_MAGIC 0x6969 extern int fstatfs64(int, struct statfs64 *); extern int statfs64(const char *, struct statfs64 *); extern int fstatfs(int, struct statfs *); extern int statfs(const char *, struct statfs *); |
extern int fstatvfs(int, struct statvfs *); extern int fstatvfs64(int, struct statvfs64 *); extern int statvfs(const char *, struct statvfs *); extern int statvfs64(const char *, struct statvfs64 *); |
#define ITIMER_REAL 0
#define ITIMER_VIRTUAL 1
#define ITIMER_PROF 2
struct timezone {
int tz_minuteswest;
int tz_dsttime;
};
typedef int __itimer_which_t;
struct timespec {
time_t tv_sec;
long int tv_nsec;
};
struct timeval {
time_t tv_sec;
suseconds_t tv_usec;
};
struct itimerval {
struct timeval it_interval;
struct timeval it_value;
};
extern int getitimer(__itimer_which_t, struct itimerval *);
extern int setitimer(__itimer_which_t, const struct itimerval *,
struct itimerval *);
extern int adjtime(const struct timeval *, struct timeval *);
extern int gettimeofday(struct timeval *, struct timezone *);
extern int utimes(const char *, const struct timeval *); |
struct timeb {
time_t time;
unsigned short millitm;
short timezone;
short dstflag;
};
extern int ftime(struct timeb *); |
struct tms {
clock_t tms_utime;
clock_t tms_stime;
clock_t tms_cutime;
clock_t tms_cstime;
};
extern clock_t times(struct tms *); |
#ifndef FALSE
#define FALSE 0
#endif
#ifndef TRUE
#define TRUE 1
#endif
#define FD_SETSIZE 1024
#define FD_ZERO(fdsetp) bzero(fdsetp, sizeof(*(fdsetp)))
#define FD_ISSET(d,set) \
((set)->fds_bits[((d)/(8*sizeof(long)))]&(1<<((d)%(8*sizeof(long)))))
#define FD_CLR(d,set) \
((set)->fds_bits[((d)/(8*sizeof(long)))]&=~(1<<((d)%(8*sizeof(long)))))
#define FD_SET(d,set) \
((set)->fds_bits[((d)/(8*sizeof(long)))]|=(1<<((d)%(8*sizeof(long)))))
typedef unsigned char u_int8_t;
typedef unsigned short u_int16_t;
typedef unsigned int u_int32_t;
typedef unsigned long long int u_int64_t;
typedef unsigned int uid_t;
typedef int pid_t;
typedef long int off_t;
typedef int key_t;
typedef long int suseconds_t;
typedef unsigned int u_int;
typedef struct {
int __val[2];
} fsid_t;
typedef unsigned int useconds_t;
typedef long int blksize_t;
typedef long int fd_mask;
typedef void *timer_t;
typedef int clockid_t;
typedef unsigned int id_t;
typedef unsigned long long int ino64_t;
typedef long long int loff_t;
typedef long int blkcnt_t;
typedef unsigned long int fsblkcnt_t;
typedef unsigned long int fsfilcnt_t;
typedef long long int blkcnt64_t;
typedef unsigned long long int fsblkcnt64_t;
typedef unsigned long long int fsfilcnt64_t;
typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned long int u_long;
typedef unsigned long int ino_t;
typedef unsigned int gid_t;
typedef unsigned long long int dev_t;
typedef unsigned int mode_t;
typedef unsigned long int nlink_t;
typedef char *caddr_t;
typedef struct {
unsigned long int fds_bits[__FDSET_LONGS];
} fd_set;
typedef long int clock_t;
typedef long int time_t; |
extern ssize_t readv(int, const struct iovec *, int); extern ssize_t writev(int, const struct iovec *, int); |
#define UNIX_PATH_MAX 108
struct sockaddr_un {
sa_family_t sun_family;
char sun_path[UNIX_PATH_MAX];
}; |
#define SYS_NMLN 65
struct utsname {
char sysname[65];
char nodename[65];
char release[65];
char version[65];
char machine[65];
char domainname[65];
};
extern int uname(struct utsname *); |
#define WIFSIGNALED(status) (!WIFSTOPPED(status) && !WIFEXITED(status))
#define WIFSTOPPED(status) (((status) & 0xff) == 0x7f)
#define WEXITSTATUS(status) (((status) & 0xff00) >> 8)
#define WTERMSIG(status) ((status) & 0x7f)
#define WCOREDUMP(status) ((status) & 0x80)
#define WIFEXITED(status) (WTERMSIG(status) == 0)
#define WNOHANG 0x00000001
#define WUNTRACED 0x00000002
#define WCOREFLAG 0x80
#define WSTOPSIG(status) WEXITSTATUS(status)
typedef enum {
P_ALL,
P_PID,
P_PGID
} idtype_t;
extern int waitid(idtype_t, id_t, siginfo_t *, int);
extern pid_t wait(int *);
extern pid_t waitpid(pid_t, int *, int);
extern pid_t wait4(pid_t, int *, int, struct rusage *); |
#define LOG_MAKEPRI(fac, pri) (((fac) << 3) | (pri)) #define LOG_PRI(p) ((p) & LOG_PRIMASK) /* extract priority */ #define LOG_EMERG 0 /* system is unusable */ #define LOG_PRIMASK 0x07 /* mask to extract priority part */ #define LOG_ALERT 1 /* action must be taken immediately */ #define LOG_CRIT 2 /* critical conditions */ #define LOG_ERR 3 /* error conditions */ #define LOG_WARNING 4 /* warning conditions */ #define LOG_NOTICE 5 /* normal but significant condition */ #define LOG_INFO 6 /* informational */ #define LOG_DEBUG 7 /* debug-level messages */ #define LOG_FAC(p) (((p) & LOG_FACMASK) >> 3) /* facility of pri */ #define LOG_KERN (0<<3) /* kernel messages */ #define LOG_AUTHPRIV (10<<3) /* security/authorization messages (private) */ #define LOG_FTP (11<<3) /* ftp daemon */ #define LOG_USER (1<<3) /* random user-level messages */ #define LOG_MAIL (2<<3) /* mail system */ #define LOG_DAEMON (3<<3) /* system daemons */ #define LOG_AUTH (4<<3) /* security/authorization messages */ #define LOG_SYSLOG (5<<3) /* messages generated internally by syslogd */ #define LOG_LPR (6<<3) /* line printer subsystem */ #define LOG_NEWS (7<<3) /* network news subsystem */ #define LOG_UUCP (8<<3) /* UUCP subsystem */ #define LOG_CRON (9<<3) /* clock daemon */ #define LOG_FACMASK 0x03f8 /* mask to extract facility part */ #define LOG_LOCAL0 (16<<3) /* reserved for local use */ #define LOG_LOCAL1 (17<<3) /* reserved for local use */ #define LOG_LOCAL2 (18<<3) /* reserved for local use */ #define LOG_LOCAL3 (19<<3) /* reserved for local use */ #define LOG_LOCAL4 (20<<3) /* reserved for local use */ #define LOG_LOCAL5 (21<<3) /* reserved for local use */ #define LOG_LOCAL6 (22<<3) /* reserved for local use */ #define LOG_LOCAL7 (23<<3) /* reserved for local use */ #define LOG_UPTO(pri) ((1 << ((pri)+1)) - 1) /* all priorities through pri */ #define LOG_MASK(pri) (1 << (pri)) /* mask for one priority */ #define LOG_PID 0x01 /* log the pid with each message */ #define LOG_CONS 0x02 /* log on the console if errors in sending */ #define LOG_ODELAY 0x04 /* delay open until first syslog() (default) */ #define LOG_NDELAY 0x08 /* don't delay open */ #define LOG_NOWAIT 0x10 /* don't wait for console forks: DEPRECATED */ #define LOG_PERROR 0x20 /* log to stderr as well */ extern void closelog(void); extern void openlog(const char *, int, int); extern int setlogmask(int); extern void syslog(int, const char *, ...); extern void vsyslog(int, const char *, va_list); extern void __syslog_chk(int, int, const char *, ...); extern void __vsyslog_chk(int, int, const char *, va_list); |
#define REGTYPE '0' #define LNKTYPE '1' #define SYMTYPE '2' #define CHRTYPE '3' #define BLKTYPE '4' #define DIRTYPE '5' #define FIFOTYPE '6' #define CONTTYPE '7' #define AREGTYPE '\0' #define TVERSION "00" #define TOEXEC 00001 #define TOWRITE 00002 #define TOREAD 00004 #define TGEXEC 00010 #define TGWRITE 00020 #define TGREAD 00040 #define TUEXEC 00100 #define TUWRITE 00200 #define TUREAD 00400 #define TSVTX 01000 #define TSGID 02000 #define TSUID 04000 #define TVERSLEN 2 #define TMAGLEN 6 #define TMAGIC "ustar" |
#define TCIFLUSH 0
#define TCOOFF 0
#define TCSANOW 0
#define BS0 0000000
#define CR0 0000000
#define FF0 0000000
#define NL0 0000000
#define TAB0 0000000
#define VT0 0000000
#define OPOST 0000001
#define OCRNL 0000010
#define ONOCR 0000020
#define ONLRET 0000040
#define OFILL 0000100
#define OFDEL 0000200
#define NL1 0000400
#define TCOFLUSH 1
#define TCOON 1
#define TCSADRAIN 1
#define TCIOFF 2
#define TCIOFLUSH 2
#define TCSAFLUSH 2
#define TCION 3
typedef unsigned int speed_t;
typedef unsigned char cc_t;
typedef unsigned int tcflag_t;
#define NCCS 32
struct termios {
tcflag_t c_iflag;
tcflag_t c_oflag;
tcflag_t c_cflag;
tcflag_t c_lflag;
cc_t c_line;
cc_t c_cc[NCCS];
speed_t c_ispeed;
speed_t c_ospeed;
};
#define VINTR 0
#define VQUIT 1
#define VLNEXT 15
#define VERASE 2
#define VKILL 3
#define VEOF 4
#define IGNBRK 0000001
#define BRKINT 0000002
#define IGNPAR 0000004
#define PARMRK 0000010
#define INPCK 0000020
#define ISTRIP 0000040
#define INLCR 0000100
#define IGNCR 0000200
#define ICRNL 0000400
#define IXANY 0004000
#define IMAXBEL 0020000
#define CS5 0000000
#define ECHO 0000010
#define B0 0000000
#define B50 0000001
#define B75 0000002
#define B110 0000003
#define B134 0000004
#define B150 0000005
#define B200 0000006
#define B300 0000007
#define B600 0000010
#define B1200 0000011
#define B1800 0000012
#define B2400 0000013
#define B4800 0000014
#define B9600 0000015
#define B19200 0000016
#define B38400 0000017
extern speed_t cfgetispeed(const struct termios *);
extern speed_t cfgetospeed(const struct termios *);
extern void cfmakeraw(struct termios *);
extern int cfsetispeed(struct termios *, speed_t);
extern int cfsetospeed(struct termios *, speed_t);
extern int cfsetspeed(struct termios *, speed_t);
extern int tcflow(int, int);
extern int tcflush(int, int);
extern pid_t tcgetsid(int);
extern int tcsendbreak(int, int);
extern int tcsetattr(int, int, const struct termios *);
extern int tcdrain(int);
extern int tcgetattr(int, struct termios *); |
#define CLK_TCK ((clock_t)sysconf(2))
#define CLOCK_REALTIME 0
#define TIMER_ABSTIME 1
#define CLOCKS_PER_SEC 1000000l
struct tm {
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
long int tm_gmtoff;
char *tm_zone;
};
struct itimerspec {
struct timespec it_interval;
struct timespec it_value;
};
extern int __daylight;
extern long int __timezone;
extern char *__tzname[];
extern char *asctime(const struct tm *);
extern clock_t clock(void);
extern char *ctime(const time_t *);
extern char *ctime_r(const time_t *, char *);
extern double difftime(time_t, time_t);
extern struct tm *getdate(const char *);
extern int getdate_err;
extern struct tm *gmtime(const time_t *);
extern struct tm *localtime(const time_t *);
extern time_t mktime(struct tm *);
extern int stime(const time_t *);
extern size_t strftime(char *, size_t, const char *, const struct tm *);
extern char *strptime(const char *, const char *, struct tm *);
extern time_t time(time_t *);
extern int nanosleep(const struct timespec *, struct timespec *);
extern int daylight;
extern long int timezone;
extern char *tzname[];
extern void tzset(void);
extern char *asctime_r(const struct tm *, char *);
extern struct tm *gmtime_r(const time_t *, struct tm *);
extern struct tm *localtime_r(const time_t *, struct tm *);
extern int clock_getcpuclockid(pid_t, clockid_t *);
extern int clock_getres(clockid_t, struct timespec *);
extern int clock_gettime(clockid_t, struct timespec *);
extern int clock_nanosleep(clockid_t, int, const struct timespec *,
struct timespec *);
extern int clock_settime(clockid_t, const struct timespec *);
extern int timer_create(clockid_t, struct sigevent *, timer_t *);
extern int timer_delete(timer_t);
extern int timer_getoverrun(timer_t);
extern int timer_gettime(timer_t, struct itimerspec *);
extern int timer_settime(timer_t, int, const struct itimerspec *,
struct itimerspec *); |
extern int getcontext(ucontext_t *); extern void makecontext(ucontext_t *, void (*)(void) , int, ...); extern int setcontext(const struct ucontext *); extern int swapcontext(ucontext_t *, const struct ucontext *); |
#define SEEK_SET 0 #define STDIN_FILENO 0 #define SEEK_CUR 1 #define STDOUT_FILENO 1 #define SEEK_END 2 #define STDERR_FILENO 2 typedef long long int off64_t; #define F_OK 0 #define X_OK 1 #define W_OK 2 #define R_OK 4 #define _POSIX_VDISABLE '\0' #define _POSIX_CHOWN_RESTRICTED 1 #define _POSIX_JOB_CONTROL 1 #define _POSIX_NO_TRUNC 1 #define _POSIX_SHELL 1 #define _POSIX_FSYNC 200112 #define _POSIX_MAPPED_FILES 200112 #define _POSIX_MEMLOCK 200112 #define _POSIX_MEMLOCK_RANGE 200112 #define _POSIX_MEMORY_PROTECTION 200112 #define _POSIX_SEMAPHORES 200112 #define _POSIX_SHARED_MEMORY_OBJECTS 200112 #define _POSIX_TIMERS 200112 #define _POSIX2_C_BIND 200112L #define _POSIX2_VERSION 200112L #define _POSIX_THREADS 200112L #define _POSIX_VERSION 200112L #define _PC_LINK_MAX 0 #define _PC_MAX_CANON 1 #define _PC_ASYNC_IO 10 #define _PC_PRIO_IO 11 #define _PC_FILESIZEBITS 13 #define _PC_REC_INCR_XFER_SIZE 14 #define _PC_REC_MIN_XFER_SIZE 16 #define _PC_REC_XFER_ALIGN 17 #define _PC_ALLOC_SIZE_MIN 18 #define _PC_MAX_INPUT 2 #define _PC_2_SYMLINKS 20 #define _PC_NAME_MAX 3 #define _PC_PATH_MAX 4 #define _PC_PIPE_BUF 5 #define _PC_CHOWN_RESTRICTED 6 #define _PC_NO_TRUNC 7 #define _PC_VDISABLE 8 #define _PC_SYNC_IO 9 #define _SC_ARG_MAX 0 #define _SC_CHILD_MAX 1 #define _SC_PRIORITY_SCHEDULING 10 #define _SC_XOPEN_XPG4 100 #define _SC_CHAR_BIT 101 #define _SC_CHAR_MAX 102 #define _SC_CHAR_MIN 103 #define _SC_INT_MAX 104 #define _SC_INT_MIN 105 #define _SC_LONG_BIT 106 #define _SC_WORD_BIT 107 #define _SC_MB_LEN_MAX 108 #define _SC_NZERO 109 #define _SC_TIMERS 11 #define _SC_SSIZE_MAX 110 #define _SC_SCHAR_MAX 111 #define _SC_SCHAR_MIN 112 #define _SC_SHRT_MAX 113 #define _SC_SHRT_MIN 114 #define _SC_UCHAR_MAX 115 #define _SC_UINT_MAX 116 #define _SC_ULONG_MAX 117 #define _SC_USHRT_MAX 118 #define _SC_NL_ARGMAX 119 #define _SC_ASYNCHRONOUS_IO 12 #define _SC_NL_LANGMAX 120 #define _SC_NL_MSGMAX 121 #define _SC_NL_NMAX 122 #define _SC_NL_SETMAX 123 #define _SC_NL_TEXTMAX 124 #define _SC_XBS5_ILP32_OFF32 125 #define _SC_XBS5_ILP32_OFFBIG 126 #define _SC_XBS5_LP64_OFF64 127 #define _SC_XBS5_LPBIG_OFFBIG 128 #define _SC_XOPEN_LEGACY 129 #define _SC_PRIORITIZED_IO 13 #define _SC_XOPEN_REALTIME 130 #define _SC_XOPEN_REALTIME_THREADS 131 #define _SC_ADVISORY_INFO 132 #define _SC_BARRIERS 133 #define _SC_BASE 134 #define _SC_C_LANG_SUPPORT 135 #define _SC_C_LANG_SUPPORT_R 136 #define _SC_CLOCK_SELECTION 137 #define _SC_CPUTIME 138 #define _SC_THREAD_CPUTIME 139 #define _SC_SYNCHRONIZED_IO 14 #define _SC_DEVICE_IO 140 #define _SC_DEVICE_SPECIFIC 141 #define _SC_DEVICE_SPECIFIC_R 142 #define _SC_FD_MGMT 143 #define _SC_FIFO 144 #define _SC_PIPE 145 #define _SC_FILE_ATTRIBUTES 146 #define _SC_FILE_LOCKING 147 #define _SC_FILE_SYSTEM 148 #define _SC_MONOTONIC_CLOCK 149 #define _SC_FSYNC 15 #define _SC_MULTI_PROCESS 150 #define _SC_SINGLE_PROCESS 151 #define _SC_NETWORKING 152 #define _SC_READER_WRITER_LOCKS 153 #define _SC_SPIN_LOCKS 154 #define _SC_REGEXP 155 #define _SC_REGEX_VERSION 156 #define _SC_SHELL 157 #define _SC_SIGNALS 158 #define _SC_SPAWN 159 #define _SC_MAPPED_FILES 16 #define _SC_SPORADIC_SERVER 160 #define _SC_THREAD_SPORADIC_SERVER 161 #define _SC_SYSTEM_DATABASE 162 #define _SC_SYSTEM_DATABASE_R 163 #define _SC_TIMEOUTS 164 #define _SC_TYPED_MEMORY_OBJECTS 165 #define _SC_USER_GROUPS 166 #define _SC_USER_GROUPS_R 167 #define _SC_2_PBS 168 #define _SC_2_PBS_ACCOUNTING 169 #define _SC_MEMLOCK 17 #define _SC_2_PBS_LOCATE 170 #define _SC_2_PBS_MESSAGE 171 #define _SC_2_PBS_TRACK 172 #define _SC_SYMLOOP_MAX 173 #define _SC_STREAMS 174 #define _SC_2_PBS_CHECKPOINT 175 #define _SC_V6_ILP32_OFF32 176 #define _SC_V6_ILP32_OFFBIG 177 #define _SC_V6_LP64_OFF64 178 #define _SC_V6_LPBIG_OFFBIG 179 #define _SC_MEMLOCK_RANGE 18 #define _SC_HOST_NAME_MAX 180 #define _SC_TRACE 181 #define _SC_TRACE_EVENT_FILTER 182 #define _SC_TRACE_INHERIT 183 #define _SC_TRACE_LOG 184 #define _SC_LEVEL1_ICACHE_SIZE 185 #define _SC_LEVEL1_ICACHE_ASSOC 186 #define _SC_LEVEL1_ICACHE_LINESIZE 187 #define _SC_LEVEL1_DCACHE_SIZE 188 #define _SC_LEVEL1_DCACHE_ASSOC 189 #define _SC_MEMORY_PROTECTION 19 #define _SC_LEVEL1_DCACHE_LINESIZE 190 #define _SC_LEVEL2_CACHE_SIZE 191 #define _SC_LEVEL2_CACHE_ASSOC 192 #define _SC_LEVEL2_CACHE_LINESIZE 193 #define _SC_LEVEL3_CACHE_SIZE 194 #define _SC_LEVEL3_CACHE_ASSOC 195 #define _SC_LEVEL3_CACHE_LINESIZE 196 #define _SC_LEVEL4_CACHE_SIZE 197 #define _SC_LEVEL4_CACHE_ASSOC 198 #define _SC_LEVEL4_CACHE_LINESIZE 199 #define _SC_CLK_TCK 2 #define _SC_MESSAGE_PASSING 20 #define _SC_SEMAPHORES 21 #define _SC_SHARED_MEMORY_OBJECTS 22 #define _SC_AIO_LISTIO_MAX 23 #define _SC_IPV6 235 #define _SC_RAW_SOCKETS 236 #define _SC_AIO_MAX 24 #define _SC_AIO_PRIO_DELTA_MAX 25 #define _SC_DELAYTIMER_MAX 26 #define _SC_MQ_OPEN_MAX 27 #define _SC_MQ_PRIO_MAX 28 #define _SC_VERSION 29 #define _SC_NGROUPS_MAX 3 #define _SC_PAGESIZE 30 #define _SC_PAGE_SIZE 30 #define _SC_RTSIG_MAX 31 #define _SC_SEM_NSEMS_MAX 32 #define _SC_SEM_VALUE_MAX 33 #define _SC_SIGQUEUE_MAX 34 #define _SC_TIMER_MAX 35 #define _SC_BC_BASE_MAX 36 #define _SC_BC_DIM_MAX 37 #define _SC_BC_SCALE_MAX 38 #define _SC_BC_STRING_MAX 39 #define _SC_OPEN_MAX 4 #define _SC_COLL_WEIGHTS_MAX 40 #define _SC_EQUIV_CLASS_MAX 41 #define _SC_EXPR_NEST_MAX 42 #define _SC_LINE_MAX 43 #define _SC_RE_DUP_MAX 44 #define _SC_CHARCLASS_NAME_MAX 45 #define _SC_2_VERSION 46 #define _SC_2_C_BIND 47 #define _SC_2_C_DEV 48 #define _SC_2_FORT_DEV 49 #define _SC_STREAM_MAX 5 #define _SC_2_FORT_RUN 50 #define _SC_2_SW_DEV 51 #define _SC_2_LOCALEDEF 52 #define _SC_PII 53 #define _SC_PII_XTI 54 #define _SC_PII_SOCKET 55 #define _SC_PII_INTERNET 56 #define _SC_PII_OSI 57 #define _SC_POLL 58 #define _SC_SELECT 59 #define _SC_TZNAME_MAX 6 #define _SC_IOV_MAX 60 #define _SC_UIO_MAXIOV 60 #define _SC_PII_INTERNET_STREAM 61 #define _SC_PII_INTERNET_DGRAM 62 #define _SC_PII_OSI_COTS 63 #define _SC_PII_OSI_CLTS 64 #define _SC_PII_OSI_M 65 #define _SC_T_IOV_MAX 66 #define _SC_THREADS 67 #define _SC_THREAD_SAFE_FUNCTIONS 68 #define _SC_GETGR_R_SIZE_MAX 69 #define _SC_JOB_CONTROL 7 #define _SC_GETPW_R_SIZE_MAX 70 #define _SC_LOGIN_NAME_MAX 71 #define _SC_TTY_NAME_MAX 72 #define _SC_THREAD_DESTRUCTOR_ITERATIONS 73 #define _SC_THREAD_KEYS_MAX 74 #define _SC_THREAD_STACK_MIN 75 #define _SC_THREAD_THREADS_MAX 76 #define _SC_THREAD_ATTR_STACKADDR 77 #define _SC_THREAD_ATTR_STACKSIZE 78 #define _SC_THREAD_PRIORITY_SCHEDULING 79 #define _SC_SAVED_IDS 8 #define _SC_THREAD_PRIO_INHERIT 80 #define _SC_THREAD_PRIO_PROTECT 81 #define _SC_THREAD_PROCESS_SHARED 82 #define _SC_NPROCESSORS_CONF 83 #define _SC_NPROCESSORS_ONLN 84 #define _SC_PHYS_PAGES 85 #define _SC_AVPHYS_PAGES 86 #define _SC_ATEXIT_MAX 87 #define _SC_PASS_MAX 88 #define _SC_XOPEN_VERSION 89 #define _SC_REALTIME_SIGNALS 9 #define _SC_XOPEN_XCU_VERSION 90 #define _SC_XOPEN_UNIX 91 #define _SC_XOPEN_CRYPT 92 #define _SC_XOPEN_ENH_I18N 93 #define _SC_XOPEN_SHM 94 #define _SC_2_CHAR_TERM 95 #define _SC_2_C_VERSION 96 #define _SC_2_UPE 97 #define _SC_XOPEN_XPG2 98 #define _SC_XOPEN_XPG3 99 #define _CS_PATH 0 #define _POSIX_REGEXP 1 #define _CS_XBS5_ILP32_OFF32_CFLAGS 1100 #define _CS_XBS5_ILP32_OFF32_LDFLAGS 1101 #define _CS_XBS5_ILP32_OFF32_LIBS 1102 #define _CS_XBS5_ILP32_OFF32_LINTFLAGS 1103 #define _CS_XBS5_ILP32_OFFBIG_CFLAGS 1104 #define _CS_XBS5_ILP32_OFFBIG_LDFLAGS 1105 #define _CS_XBS5_ILP32_OFFBIG_LIBS 1106 #define _CS_XBS5_ILP32_OFFBIG_LINTFLAGS 1107 #define _CS_XBS5_LP64_OFF64_CFLAGS 1108 #define _CS_XBS5_LP64_OFF64_LDFLAGS 1109 #define _CS_XBS5_LP64_OFF64_LIBS 1110 #define _CS_XBS5_LP64_OFF64_LINTFLAGS 1111 #define _CS_XBS5_LPBIG_OFFBIG_CFLAGS 1112 #define _CS_XBS5_LPBIG_OFFBIG_LDFLAGS 1113 #define _CS_XBS5_LPBIG_OFFBIG_LIBS 1114 #define _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS 1115 #define _XOPEN_XPG4 1 #define _XOPEN_VERSION 500 #define F_ULOCK 0 #define F_LOCK 1 #define F_TLOCK 2 #define F_TEST 3 extern int getdtablesize(void); extern char **__environ; extern pid_t __getpgid(pid_t); extern void _exit(int); extern int acct(const char *); extern unsigned int alarm(unsigned int); extern int chown(const char *, uid_t, gid_t); extern int chroot(const char *); extern size_t confstr(int, char *, size_t); extern char *ctermid(char *); extern char *cuserid(char *); extern int daemon(int, int); extern int execl(const char *, const char *, ...); extern int execle(const char *, const char *, ...); extern int execlp(const char *, const char *, ...); extern int execv(const char *, char *const[]); extern int execvp(const char *, char *const[]); extern int fdatasync(int); extern int ftruncate64(int, off64_t); extern int getdomainname(char *, size_t); extern long int gethostid(void); extern char *getlogin(void); extern int getlogin_r(char *, size_t); extern int getopt(int, char *const[], const char *); extern pid_t getpgrp(void); extern pid_t getsid(pid_t); extern char *getwd(char *); extern int lockf(int, int, off_t); extern int lockf64(int, int, off64_t); extern int mkstemp(char *); extern int nice(int); extern char *optarg; extern int opterr; extern int optind; extern int optopt; extern int rename(const char *, const char *); extern int setegid(gid_t); extern int seteuid(uid_t); extern int sethostname(const char *, size_t); extern int setpgrp(void); extern void swab(const void *, void *, ssize_t); extern void sync(void); extern pid_t tcgetpgrp(int); extern int tcsetpgrp(int, pid_t); extern int truncate(const char *, off_t); extern int truncate64(const char *, off64_t); extern char *ttyname(int); extern unsigned int ualarm(useconds_t, useconds_t); extern int usleep(useconds_t); extern int close(int); extern int fsync(int); extern off_t lseek(int, off_t, int); extern int pause(void); extern ssize_t read(int, void *, size_t); extern ssize_t write(int, const void *, size_t); extern char *crypt(const char *, const char *); extern void encrypt(char *, int); extern void setkey(const char *); extern int access(const char *, int); extern int brk(void *); extern int chdir(const char *); extern int dup(int); extern int dup2(int, int); extern int execve(const char *, char *const[], char *const[]); extern int fchdir(int); extern int fchown(int, uid_t, gid_t); extern pid_t fork(void); extern gid_t getegid(void); extern uid_t geteuid(void); extern gid_t getgid(void); extern int getgroups(int, gid_t[]); extern int gethostname(char *, size_t); extern pid_t getpgid(pid_t); extern pid_t getpid(void); extern uid_t getuid(void); extern int lchown(const char *, uid_t, gid_t); extern int link(const char *, const char *); extern int mkdir(const char *, mode_t); extern long int pathconf(const char *, int); extern int pipe(int[2]); extern ssize_t readlink(const char *, char *, size_t); extern int rmdir(const char *); extern void *sbrk(intptr_t); extern int select(int, fd_set *, fd_set *, fd_set *, struct timeval *); extern int setgid(gid_t); extern int setpgid(pid_t, pid_t); extern int setregid(gid_t, gid_t); extern int setreuid(uid_t, uid_t); extern pid_t setsid(void); extern int setuid(uid_t); extern unsigned int sleep(unsigned int); extern int symlink(const char *, const char *); extern long int sysconf(int); extern int unlink(const char *); extern pid_t vfork(void); extern ssize_t pread(int, void *, size_t, off_t); extern ssize_t pwrite(int, const void *, size_t, off_t); extern char **_environ; extern long int fpathconf(int, int); extern int ftruncate(int, off_t); extern char *getcwd(char *, size_t); extern int getpagesize(void); extern pid_t getppid(void); extern int isatty(int); extern loff_t lseek64(int, loff_t, int); extern ssize_t pread64(int, void *, size_t, off64_t); extern ssize_t pwrite64(int, const void *, size_t, off64_t); extern int ttyname_r(int, char *, size_t); extern size_t __confstr_chk(int, char *, size_t, size_t); extern char *__getcwd_chk(char *, size_t, size_t); extern int __getgroups_chk(int, gid_t *, size_t); extern int __gethostname_chk(char *, size_t, size_t); extern int __getlogin_r_chk(char *, size_t, size_t); extern ssize_t __pread64_chk(int, void *, size_t, off64_t, size_t); extern ssize_t __pread_chk(int, void *, size_t, off_t, size_t); extern ssize_t __read_chk(int, void *, size_t, size_t); extern ssize_t __readlink_chk(const char *, char *, size_t, size_t); extern int __ttyname_r_chk(int, char *, size_t, size_t); extern ssize_t readlinkat(int, const char *, char *, size_t); extern int linkat(int, const char *, int, const char *, int); extern int unlinkat(int, const char *, int); extern int fchownat(int, const char *, uid_t, gid_t, int); extern int symlinkat(const char *, int, const char *); extern int faccessat(int, const char *, int, int); extern int fexecve(int, char *const[], char *const[]); |
struct utimbuf {
time_t actime;
time_t modtime;
};
extern int utime(const char *, const struct utimbuf *); |
#define UT_HOSTSIZE 256
#define UT_LINESIZE 32
#define UT_NAMESIZE 32
#define ut_addr ut_addr_v6[0]
#define ut_time ut_tv.tv_sec
#define ut_name ut_user /* Backwards compatability */
struct exit_status {
short e_termination;
short e_exit;
};
#define EMPTY 0 /* No valid user accounting information. */
#define RUN_LVL 1 /* The system's runlevel. */
#define BOOT_TIME 2 /* Time of system boot. */
#define NEW_TIME 3 /* Time after system clock changed. */
#define OLD_TIME 4 /* Time when system clock changed. */
#define INIT_PROCESS 5 /* Process spawned by the init process. */
#define LOGIN_PROCESS 6 /* Session leader of a logged in user. */
#define USER_PROCESS 7 /* Normal process. */
#define DEAD_PROCESS 8 /* Terminated process. */
#define ACCOUNTING 9
extern void endutent(void);
extern struct utmp *getutent(void);
extern void setutent(void);
extern int getutent_r(struct utmp *, struct utmp **);
extern int utmpname(const char *);
extern int login_tty(int);
extern void login(const struct utmp *);
extern int logout(const char *);
extern void logwtmp(const char *, const char *, const char *); |
extern void endutxent(void); extern struct utmpx *getutxent(void); extern struct utmpx *getutxid(const struct utmpx *); extern struct utmpx *getutxline(const struct utmpx *); extern struct utmpx *pututxline(const struct utmpx *); extern void setutxent(void); |
#define WEOF (0xffffffffu) #define WCHAR_MAX 0x7FFFFFFF #define WCHAR_MIN 0x80000000 extern wchar_t *fgetws_unlocked(wchar_t *, int, FILE *); extern wint_t fputwc_unlocked(wchar_t, FILE *); extern int fputws_unlocked(const wchar_t *, FILE *); extern wint_t getwchar_unlocked(void); extern wint_t putwc_unlocked(wchar_t, FILE *); extern wint_t putwchar_unlocked(wchar_t); extern double __wcstod_internal(const wchar_t *, wchar_t * *, int); extern float __wcstof_internal(const wchar_t *, wchar_t * *, int); extern long int __wcstol_internal(const wchar_t *, wchar_t * *, int, int); extern long double __wcstold_internal(const wchar_t *, wchar_t * *, int); extern unsigned long int __wcstoul_internal(const wchar_t *, wchar_t * *, int, int); extern wchar_t *wcscat(wchar_t *, const wchar_t *); extern wchar_t *wcschr(const wchar_t *, wchar_t); extern int wcscmp(const wchar_t *, const wchar_t *); extern int wcscoll(const wchar_t *, const wchar_t *); extern wchar_t *wcscpy(wchar_t *, const wchar_t *); extern size_t wcscspn(const wchar_t *, const wchar_t *); extern wchar_t *wcsdup(const wchar_t *); extern wchar_t *wcsncat(wchar_t *, const wchar_t *, size_t); extern int wcsncmp(const wchar_t *, const wchar_t *, size_t); extern wchar_t *wcsncpy(wchar_t *, const wchar_t *, size_t); extern wchar_t *wcspbrk(const wchar_t *, const wchar_t *); extern wchar_t *wcsrchr(const wchar_t *, wchar_t); extern size_t wcsspn(const wchar_t *, const wchar_t *); extern wchar_t *wcsstr(const wchar_t *, const wchar_t *); extern wchar_t *wcstok(wchar_t *, const wchar_t *, wchar_t * *); extern int wcswidth(const wchar_t *, size_t); extern size_t wcsxfrm(wchar_t *, const wchar_t *, size_t); extern int wctob(wint_t); extern int wcwidth(wchar_t); extern wchar_t *wmemchr(const wchar_t *, wchar_t, size_t); extern int wmemcmp(const wchar_t *, const wchar_t *, size_t); extern wchar_t *wmemcpy(wchar_t *, const wchar_t *, size_t); extern wchar_t *wmemmove(wchar_t *, const wchar_t *, size_t); extern wchar_t *wmemset(wchar_t *, wchar_t, size_t); extern size_t mbrlen(const char *, size_t, mbstate_t *); extern size_t mbrtowc(wchar_t *, const char *, size_t, mbstate_t *); extern int mbsinit(const mbstate_t *); extern size_t mbsnrtowcs(wchar_t *, const char **, size_t, size_t, mbstate_t *); extern size_t mbsrtowcs(wchar_t *, const char **, size_t, mbstate_t *); extern wchar_t *wcpcpy(wchar_t *, const wchar_t *); extern wchar_t *wcpncpy(wchar_t *, const wchar_t *, size_t); extern size_t wcrtomb(char *, wchar_t, mbstate_t *); extern size_t wcslen(const wchar_t *); extern size_t wcsnrtombs(char *, const wchar_t * *, size_t, size_t, mbstate_t *); extern size_t wcsrtombs(char *, const wchar_t * *, size_t, mbstate_t *); extern double wcstod(const wchar_t *, wchar_t * *); extern float wcstof(const wchar_t *, wchar_t * *); extern long int wcstol(const wchar_t *, wchar_t * *, int); extern long double wcstold(const wchar_t *, wchar_t * *); extern long long int wcstoq(const wchar_t *, wchar_t * *, int); extern unsigned long int wcstoul(const wchar_t *, wchar_t * *, int); extern unsigned long long int wcstouq(const wchar_t *, wchar_t * *, int); extern wchar_t *wcswcs(const wchar_t *, const wchar_t *); extern int wcscasecmp(const wchar_t *, const wchar_t *); extern int wcsncasecmp(const wchar_t *, const wchar_t *, size_t); extern size_t wcsnlen(const wchar_t *, size_t); extern long long int wcstoll(const wchar_t *, wchar_t * *, int); extern unsigned long long int wcstoull(const wchar_t *, wchar_t * *, int); extern wint_t btowc(int); extern wint_t fgetwc(FILE *); extern wint_t fgetwc_unlocked(FILE *); extern wchar_t *fgetws(wchar_t *, int, FILE *); extern wint_t fputwc(wchar_t, FILE *); extern int fputws(const wchar_t *, FILE *); extern int fwide(FILE *, int); extern int fwprintf(FILE *, const wchar_t *, ...); extern int fwscanf(FILE *, const wchar_t *, ...); extern wint_t getwc(FILE *); extern wint_t getwchar(void); extern wint_t putwc(wchar_t, FILE *); extern wint_t putwchar(wchar_t); extern int swprintf(wchar_t *, size_t, const wchar_t *, ...); extern int swscanf(const wchar_t *, const wchar_t *, ...); extern wint_t ungetwc(wint_t, FILE *); extern int vfwprintf(FILE *, const wchar_t *, va_list); extern int vfwscanf(FILE *, const wchar_t *, va_list); extern int vswprintf(wchar_t *, size_t, const wchar_t *, va_list); extern int vswscanf(const wchar_t *, const wchar_t *, va_list); extern int vwprintf(const wchar_t *, va_list); extern int vwscanf(const wchar_t *, va_list); extern size_t wcsftime(wchar_t *, size_t, const wchar_t *, const struct tm *); extern int wprintf(const wchar_t *, ...); extern int wscanf(const wchar_t *, ...); extern wchar_t *__fgetws_chk(wchar_t *, size_t, int, FILE *); extern wchar_t *__fgetws_unlocked_chk(wchar_t *, size_t, int, FILE *); extern int __fwprintf_chk(FILE *, int, const wchar_t *, ...); extern size_t __mbsnrtowcs_chk(wchar_t *, const char **, size_t, size_t, mbstate_t *, size_t); extern size_t __mbsrtowcs_chk(wchar_t *, const char **, size_t, mbstate_t *, size_t); extern int __swprintf_chk(wchar_t *, size_t, int, size_t, const wchar_t *, ...); extern int __vfwprintf_chk(FILE *, int, const wchar_t *, va_list); extern int __vswprintf_chk(wchar_t *, size_t, int, size_t, const wchar_t *, va_list); extern int __vwprintf_chk(int, const wchar_t *, va_list); extern wchar_t *__wcpcpy_chk(wchar_t *, const wchar_t *, size_t); extern wchar_t *__wcpncpy_chk(wchar_t *, const wchar_t *, size_t, size_t); extern size_t __wcrtomb_chk(char *, wchar_t, mbstate_t *, size_t); extern wchar_t *__wcscat_chk(wchar_t *, const wchar_t *, size_t); extern wchar_t *__wcscpy_chk(wchar_t *, const wchar_t *, size_t); extern wchar_t *__wcsncat_chk(wchar_t *, const wchar_t *, size_t, size_t); extern wchar_t *__wcsncpy_chk(wchar_t *, const wchar_t *, size_t, size_t); extern size_t __wcsnrtombs_chk(char *, const wchar_t * *, size_t, size_t, mbstate_t *, size_t); extern size_t __wcsrtombs_chk(char *, const wchar_t * *, size_t, mbstate_t *, size_t); extern wchar_t *__wmemcpy_chk(wchar_t *, const wchar_t *, size_t, size_t); extern wchar_t *__wmemmove_chk(wchar_t *, const wchar_t *, size_t, size_t); extern wchar_t *__wmempcpy_chk(wchar_t *, const wchar_t *, size_t, size_t); extern wchar_t *__wmemset_chk(wchar_t *, wchar_t, size_t, size_t); extern int __wprintf_chk(int, const wchar_t *, ...); extern FILE *open_wmemstream(wchar_t * *, size_t *); |
typedef unsigned long int wctype_t;
typedef unsigned int wint_t;
typedef const int32_t *wctrans_t;
typedef struct {
int count;
wint_t value;
} __mbstate_t;
typedef __mbstate_t mbstate_t;
extern int iswblank(wint_t);
extern wint_t towlower(wint_t);
extern wint_t towupper(wint_t);
extern wctrans_t wctrans(const char *);
extern int iswalnum(wint_t);
extern int iswalpha(wint_t);
extern int iswcntrl(wint_t);
extern int iswctype(wint_t, wctype_t);
extern int iswdigit(wint_t);
extern int iswgraph(wint_t);
extern int iswlower(wint_t);
extern int iswprint(wint_t);
extern int iswpunct(wint_t);
extern int iswspace(wint_t);
extern int iswupper(wint_t);
extern int iswxdigit(wint_t);
extern wctype_t wctype(const char *);
extern wint_t towctrans(wint_t, wctrans_t); |
enum {
WRDE_DOOFFS = 1,
WRDE_APPEND = 2,
WRDE_NOCMD = 4,
WRDE_REUSE = 8,
WRDE_SHOWERR = 16,
WRDE_UNDEF = 32
};
typedef struct {
size_t we_wordc;
char **we_wordv;
size_t we_offs;
} wordexp_t;
enum {
WRDE_NOSYS = -1,
WRDE_NOSPACE = 1,
WRDE_BADCHAR = 2,
WRDE_BADVAL = 3,
WRDE_CMDSUB = 4,
WRDE_SYNTAX = 5
};
extern int wordexp(const char *, wordexp_t *, int);
extern void wordfree(wordexp_t *); |
The interfaces defined on the following pages are included in libc and are defined by this specification. Unless otherwise noted, these interfaces shall be included in the source standard.
Other interfaces listed in Section 13.3 shall behave as described in the referenced base document.
_IO_feof() tests the end-of-file indicator for the stream pointed to by __fp, returning a non-zero value if it is set.
_IO_feof() is not in the source standard; it is only in the binary standard.
_IO_getc() reads the next character from
__fp and returns it as an unsigned char cast
to an int, or EOF on end-of-file or error.
_IO_getc() is not in the source standard; it is only in the binary standard.
_IO_putc() writes the character __c, cast to an unsigned char, to __fp.
_IO_putc() is not in the source standard; it is only in the binary standard.
_IO_puts() writes the string __s
and a trailing newline to stdout.
_IO_puts() is not in the source standard; it is only in the binary standard.
The __assert_fail() function is used to implement the assert() interface of ISO POSIX (2003). The __assert_fail() function shall print the given file filename, line line number, function function name and a message on the standard error stream in an unspecified format, and abort program execution via the abort() function. For example:
a.c:10: foobar: Assertion a == b failed.
If function is NULL, __assert_fail() shall omit information about the function.
assertion, file, and line shall be non-NULL.
The __assert_fail() function is not in the source standard; it is only in the binary standard. The assert() interface is not in the binary standard; it is only in the source standard. The assert() may be implemented as a macro.
The interface __chk_fail() shall abort the function that called it with a message that a buffer overflow has been detected. The program that called the function shall then exit.
The interface __chk_fail() does not check for a buffer overflow itself. It merely reports one when invoked.
The interface __confstr_chk() shall function in the same way as the interface confstr(), except that __confstr_chk() shall check for buffer overflow before computing a result. If an overflow is anticipated, the function shall abort and the program calling it shall exit.
The parameter buflen specifies the size of the buffer buf. If len exceeds buflen, the function shall abort, and the program calling it shall exit.
The __confstr_chk() function is not in the source standard; it is only in the binary standard.
The __ctype_b_loc()
function shall return a pointer into an array of
characters in the current locale that contains characteristics for each
character in the current character set. The array shall contain a total of
384
characters, and can be indexed with any signed or unsigned char (i.e. with an
index value between -128 and
255). If the application is multithreaded, the
array shall be local to the current thread.
This interface is not in the source standard; it is only in the binary standard.
The __ctype_b_loc() function shall return a pointer to the array of characters to be used for the ctype() family of functions (see <ctype.h>).
__ctype_get_mb_cur_max() returns the maximum length of a multibyte character in the current locale.
__ctype_get_mb_cur_max() is not in the source standard; it is only in the binary standard.
The __ctype_tolower_loc()
function shall return a pointer into an array of
characters in the current locale that contains lower case equivalents for each
character in the current character set. The array shall contain a total of
384
characters, and can be indexed with any signed or unsigned char (i.e. with an
index value between -128 and
255). If the application is multithreaded, the
array shall be local to the current thread.
This interface is not in the source standard; it is only in the binary standard.
The __ctype_tolower_loc() function shall return a pointer to the array of characters to be used for the ctype() family of functions (see <ctype.h>).
The __ctype_toupper_loc()
function shall return a pointer into an array of
characters in the current locale that contains upper case equivalents for each
character in the current character set. The array shall contain a total of
384
characters, and can be indexed with any signed or unsigned char (i.e. with an
index value between -128 and
255). If the application is multithreaded, the
array shall be local to the current thread.
This interface is not in the source standard; it is only in the binary standard.
The __ctype_toupper_loc() function shall return a pointer to the array of characters to be used for the ctype() family of functions (see <ctype.h>).
As described in the Itanium™ C++ ABI, __cxa_atexit() registers a destructor function to be called by exit() or when a shared library is unloaded. When a shared library is unloaded, any destructor function associated with that shared library, identified by dso_handle, shall be called with the single argument arg, and then that function shall be removed, or marked as complete, from the list of functions to run at exit(). On a call to exit(), any remaining functions registered shall be called with the single argument arg. Destructor functions shall always be called in the reverse order to their registration (i.e. the most recently registered function shall be called first),
The __cxa_atexit() function is used to implement atexit(), as described in ISO POSIX (2003). Calling atexit(func) from the statically linked part of an application shall be equivalent to __cxa_atexit(func, NULL, NULL).
__cxa_atexit() is not in the source standard; it is only in the binary standard.
Note: atexit() is not in the binary standard; it is only in the source standard.
As described in the Itanium® C++ ABI, the C runtime library shall maintain a list of termination function entries containing the following information:
A pointer to a termination function.
An operand to be passed to the function.
A handle identifying the home shared library of the entry.
The list is populated by entries of two kinds:
Destructors of global (or local static) C++ objects that require destruction on exit.
Functions registered by the user with atexit().
In the former case an entry consists of a pointer to the destructor, a pointer to the corresponding object and a handle for the home shared library of the object. In the latter case the pointer to the function is the pointer passed to atexit(), while the other pointers are NULL.
When __cxa_finalize(d) is called, it shall walk the termination function list, calling each in turn if d matches the handle of the termination function entry. If d is NULL, it shall call all the termination funtions. Multiple calls to __cxa_finalize shall not result in calling termination function entries multiple times; the implementation may either remove entries or mark them finished. The termination functions shall always be called in the reverse order of their registration (i.e. the most recently registered function shall be called first).
An application shall not call __cxa_finalize() directly. The implementation shall arrange for__cxa_finalize() to be called during early shared library unload (e.g. dlclose()) with a handle to the shared library. When the main program calls exit, the implementation shall cause any remaining __cxa_atexit-registered functions to be called, either by calling __cxa_finalize(NULL), or by walking the registration list itself.
__cxa_finalize() is not in the source standard; it is only in the binary standard.
The external variable __daylight
shall implement the daylight savings time flag daylight
as specified in ISO POSIX (2003).
__daylight has the same specification as
daylight.
The external variable __environ
shall implement the environment variable environ
as specified in ISO POSIX (2003).
__environ has the same specification as
environ.
The __errno_location() function shall return
the address of the errno variable for the current
thread.
__errno_location() is not in the source standard; it is only in the binary standard.
The interface __fgets_chk() shall function in the same way as the interface fgets(), except that __fgets_chk() shall check for buffer overflow before computing a result. If an overflow is anticipated, the function shall abort and the program calling it shall exit.
The parameter strsize specifies the size of the object pointed to by stream.
The __fgets_chk() function is not in the source standard; it is only in the binary standard.
The interface __fgets_unlocked_chk() shall function in the same way as the interface fgets_unlocked(), except that __fgets_unlocked_chk() shall check for buffer overflow before computing a result. If an overflow is anticipated, the function shall abort and the program calling it shall exit.
The parameter strsize specifies the size of the object pointed to by stream.
The __fgets_unlocked_chk() function is not in the source standard; it is only in the binary standard.
The interface __fgetws_chk() shall function in the same way as the interface fgetws(), except that __fgetws_chk() shall check for buffer overflow before computing a result. If an overflow is anticipated, the function shall abort and the program calling it shall exit.
The parameter strsize specifies the size of the object pointed to by stream.
The __fgetws_chk() function is not in the source standard; it is only in the binary standard.
The interface __fgetws_unlocked_chk() shall function in the same way as the interface fgetws_unlocked(), except that __fgetws_unlocked_chk() shall check for stack overflow before computing a result. If an overflow is anticipated, the function shall abort and the program calling it shall exit.
The parameter strsize specifies the size of the object pointed to by stream.
The __fgetws_unlocked_chk() function is not in the source standard; it is only in the binary standard.
__fpending() returns the amount of output in bytes pending on a stream.
__fpending() is not in the source standard; it is only in the binary standard.
The interface __fprintf_chk() shall function in the same way as the interface fprintf(), except that __fprintf_chk() shall check for stack overflow before computing a result, depending on the value of the flag parameter. If an overflow is anticipated, the function shall abort and the program calling it shall exit.
In general, the higher the value of flag, the more security measures this interface shall take in the form of checking the stack, parameter values, and so on.
The __fprintf_chk() function is not in the source standard; it is only in the binary standard.