diff options
| author | Dan Albert <danalbert@google.com> | 2017-02-23 21:36:48 +0000 |
|---|---|---|
| committer | Gerrit Code Review <noreply-gerritcodereview@google.com> | 2017-02-23 21:36:48 +0000 |
| commit | c07303259bafade95b83db1657969a978ebbc4f2 (patch) | |
| tree | 95f53c7d98a1bba90b1c05de9d760afcc58a95cd | |
| parent | 05c2d38dbcb5889e00fb31a73b0cc26f77a8e76a (diff) | |
| parent | fda647dd860c00cc3691eea10182e129099c9d0a (diff) | |
| download | ndk-c07303259bafade95b83db1657969a978ebbc4f2.tar.gz | |
Merge "Revert "Remove the prebuilt bionic headers.""
188 files changed, 20826 insertions, 2 deletions
diff --git a/Android.bp b/Android.bp index 5984f84e0..430836d62 100644 --- a/Android.bp +++ b/Android.bp @@ -4,81 +4,401 @@ cc_defaults { name: "ndk_9_defaults", sdk_version: "9", + arch: { + arm: { + export_include_dirs: ["current/platforms/android-9/arch-arm/usr/include"], + }, + arm64: { + export_include_dirs: ["current/platforms/android-9/arch-arm64/usr/include"], + }, + mips: { + export_include_dirs: ["current/platforms/android-9/arch-mips/usr/include"], + }, + mips64: { + export_include_dirs: ["current/platforms/android-9/arch-mips64/usr/include"], + }, + x86: { + export_include_dirs: ["current/platforms/android-9/arch-x86/usr/include"], + }, + x86_64: { + export_include_dirs: ["current/platforms/android-9/arch-x86_64/usr/include"], + }, + }, } cc_defaults { name: "ndk_10_defaults", sdk_version: "10", + arch: { + arm: { + export_include_dirs: ["current/platforms/android-10/arch-arm/usr/include"], + }, + arm64: { + export_include_dirs: ["current/platforms/android-10/arch-arm64/usr/include"], + }, + mips: { + export_include_dirs: ["current/platforms/android-10/arch-mips/usr/include"], + }, + mips64: { + export_include_dirs: ["current/platforms/android-10/arch-mips64/usr/include"], + }, + x86: { + export_include_dirs: ["current/platforms/android-10/arch-x86/usr/include"], + }, + x86_64: { + export_include_dirs: ["current/platforms/android-10/arch-x86_64/usr/include"], + }, + }, } cc_defaults { name: "ndk_11_defaults", sdk_version: "11", + arch: { + arm: { + export_include_dirs: ["current/platforms/android-11/arch-arm/usr/include"], + }, + arm64: { + export_include_dirs: ["current/platforms/android-11/arch-arm64/usr/include"], + }, + mips: { + export_include_dirs: ["current/platforms/android-11/arch-mips/usr/include"], + }, + mips64: { + export_include_dirs: ["current/platforms/android-11/arch-mips64/usr/include"], + }, + x86: { + export_include_dirs: ["current/platforms/android-11/arch-x86/usr/include"], + }, + x86_64: { + export_include_dirs: ["current/platforms/android-11/arch-x86_64/usr/include"], + }, + }, } cc_defaults { name: "ndk_12_defaults", sdk_version: "12", + arch: { + arm: { + export_include_dirs: ["current/platforms/android-12/arch-arm/usr/include"], + }, + arm64: { + export_include_dirs: ["current/platforms/android-12/arch-arm64/usr/include"], + }, + mips: { + export_include_dirs: ["current/platforms/android-12/arch-mips/usr/include"], + }, + mips64: { + export_include_dirs: ["current/platforms/android-12/arch-mips64/usr/include"], + }, + x86: { + export_include_dirs: ["current/platforms/android-12/arch-x86/usr/include"], + }, + x86_64: { + export_include_dirs: ["current/platforms/android-12/arch-x86_64/usr/include"], + }, + }, } cc_defaults { name: "ndk_13_defaults", sdk_version: "13", + arch: { + arm: { + export_include_dirs: ["current/platforms/android-13/arch-arm/usr/include"], + }, + arm64: { + export_include_dirs: ["current/platforms/android-13/arch-arm64/usr/include"], + }, + mips: { + export_include_dirs: ["current/platforms/android-13/arch-mips/usr/include"], + }, + mips64: { + export_include_dirs: ["current/platforms/android-13/arch-mips64/usr/include"], + }, + x86: { + export_include_dirs: ["current/platforms/android-13/arch-x86/usr/include"], + }, + x86_64: { + export_include_dirs: ["current/platforms/android-13/arch-x86_64/usr/include"], + }, + }, } cc_defaults { name: "ndk_14_defaults", sdk_version: "14", + arch: { + arm: { + export_include_dirs: ["current/platforms/android-14/arch-arm/usr/include"], + }, + arm64: { + export_include_dirs: ["current/platforms/android-14/arch-arm64/usr/include"], + }, + mips: { + export_include_dirs: ["current/platforms/android-14/arch-mips/usr/include"], + }, + mips64: { + export_include_dirs: ["current/platforms/android-14/arch-mips64/usr/include"], + }, + x86: { + export_include_dirs: ["current/platforms/android-14/arch-x86/usr/include"], + }, + x86_64: { + export_include_dirs: ["current/platforms/android-14/arch-x86_64/usr/include"], + }, + }, } cc_defaults { name: "ndk_15_defaults", sdk_version: "15", + arch: { + arm: { + export_include_dirs: ["current/platforms/android-15/arch-arm/usr/include"], + }, + arm64: { + export_include_dirs: ["current/platforms/android-15/arch-arm64/usr/include"], + }, + mips: { + export_include_dirs: ["current/platforms/android-15/arch-mips/usr/include"], + }, + mips64: { + export_include_dirs: ["current/platforms/android-15/arch-mips64/usr/include"], + }, + x86: { + export_include_dirs: ["current/platforms/android-15/arch-x86/usr/include"], + }, + x86_64: { + export_include_dirs: ["current/platforms/android-15/arch-x86_64/usr/include"], + }, + }, } cc_defaults { name: "ndk_16_defaults", sdk_version: "16", + arch: { + arm: { + export_include_dirs: ["current/platforms/android-16/arch-arm/usr/include"], + }, + arm64: { + export_include_dirs: ["current/platforms/android-16/arch-arm64/usr/include"], + }, + mips: { + export_include_dirs: ["current/platforms/android-16/arch-mips/usr/include"], + }, + mips64: { + export_include_dirs: ["current/platforms/android-16/arch-mips64/usr/include"], + }, + x86: { + export_include_dirs: ["current/platforms/android-16/arch-x86/usr/include"], + }, + x86_64: { + export_include_dirs: ["current/platforms/android-16/arch-x86_64/usr/include"], + }, + }, } cc_defaults { name: "ndk_17_defaults", sdk_version: "17", + arch: { + arm: { + export_include_dirs: ["current/platforms/android-17/arch-arm/usr/include"], + }, + arm64: { + export_include_dirs: ["current/platforms/android-17/arch-arm64/usr/include"], + }, + mips: { + export_include_dirs: ["current/platforms/android-17/arch-mips/usr/include"], + }, + mips64: { + export_include_dirs: ["current/platforms/android-17/arch-mips64/usr/include"], + }, + x86: { + export_include_dirs: ["current/platforms/android-17/arch-x86/usr/include"], + }, + x86_64: { + export_include_dirs: ["current/platforms/android-17/arch-x86_64/usr/include"], + }, + }, } cc_defaults { name: "ndk_18_defaults", sdk_version: "18", + arch: { + arm: { + export_include_dirs: ["current/platforms/android-18/arch-arm/usr/include"], + }, + arm64: { + export_include_dirs: ["current/platforms/android-18/arch-arm64/usr/include"], + }, + mips: { + export_include_dirs: ["current/platforms/android-18/arch-mips/usr/include"], + }, + mips64: { + export_include_dirs: ["current/platforms/android-18/arch-mips64/usr/include"], + }, + x86: { + export_include_dirs: ["current/platforms/android-18/arch-x86/usr/include"], + }, + x86_64: { + export_include_dirs: ["current/platforms/android-18/arch-x86_64/usr/include"], + }, + }, } cc_defaults { name: "ndk_19_defaults", sdk_version: "19", + arch: { + arm: { + export_include_dirs: ["current/platforms/android-19/arch-arm/usr/include"], + }, + arm64: { + export_include_dirs: ["current/platforms/android-19/arch-arm64/usr/include"], + }, + mips: { + export_include_dirs: ["current/platforms/android-19/arch-mips/usr/include"], + }, + mips64: { + export_include_dirs: ["current/platforms/android-19/arch-mips64/usr/include"], + }, + x86: { + export_include_dirs: ["current/platforms/android-19/arch-x86/usr/include"], + }, + x86_64: { + export_include_dirs: ["current/platforms/android-19/arch-x86_64/usr/include"], + }, + }, } cc_defaults { name: "ndk_20_defaults", sdk_version: "20", + arch: { + arm: { + export_include_dirs: ["current/platforms/android-20/arch-arm/usr/include"], + }, + arm64: { + export_include_dirs: ["current/platforms/android-20/arch-arm64/usr/include"], + }, + mips: { + export_include_dirs: ["current/platforms/android-20/arch-mips/usr/include"], + }, + mips64: { + export_include_dirs: ["current/platforms/android-20/arch-mips64/usr/include"], + }, + x86: { + export_include_dirs: ["current/platforms/android-20/arch-x86/usr/include"], + }, + x86_64: { + export_include_dirs: ["current/platforms/android-20/arch-x86_64/usr/include"], + }, + }, } cc_defaults { name: "ndk_21_defaults", sdk_version: "21", + arch: { + arm: { + export_include_dirs: ["current/platforms/android-21/arch-arm/usr/include"], + }, + arm64: { + export_include_dirs: ["current/platforms/android-21/arch-arm64/usr/include"], + }, + mips: { + export_include_dirs: ["current/platforms/android-21/arch-mips/usr/include"], + }, + mips64: { + export_include_dirs: ["current/platforms/android-21/arch-mips64/usr/include"], + }, + x86: { + export_include_dirs: ["current/platforms/android-21/arch-x86/usr/include"], + }, + x86_64: { + export_include_dirs: ["current/platforms/android-21/arch-x86_64/usr/include"], + }, + }, } cc_defaults { name: "ndk_22_defaults", sdk_version: "22", + arch: { + arm: { + export_include_dirs: ["current/platforms/android-22/arch-arm/usr/include"], + }, + arm64: { + export_include_dirs: ["current/platforms/android-22/arch-arm64/usr/include"], + }, + mips: { + export_include_dirs: ["current/platforms/android-22/arch-mips/usr/include"], + }, + mips64: { + export_include_dirs: ["current/platforms/android-22/arch-mips64/usr/include"], + }, + x86: { + export_include_dirs: ["current/platforms/android-22/arch-x86/usr/include"], + }, + x86_64: { + export_include_dirs: ["current/platforms/android-22/arch-x86_64/usr/include"], + }, + }, } cc_defaults { name: "ndk_23_defaults", sdk_version: "23", + arch: { + arm: { + export_include_dirs: ["current/platforms/android-23/arch-arm/usr/include"], + }, + arm64: { + export_include_dirs: ["current/platforms/android-23/arch-arm64/usr/include"], + }, + mips: { + export_include_dirs: ["current/platforms/android-23/arch-mips/usr/include"], + }, + mips64: { + export_include_dirs: ["current/platforms/android-23/arch-mips64/usr/include"], + }, + x86: { + export_include_dirs: ["current/platforms/android-23/arch-x86/usr/include"], + }, + x86_64: { + export_include_dirs: ["current/platforms/android-23/arch-x86_64/usr/include"], + }, + }, } cc_defaults { name: "ndk_24_defaults", sdk_version: "24", + arch: { + arm: { + export_include_dirs: ["current/platforms/android-24/arch-arm/usr/include"], + }, + arm64: { + export_include_dirs: ["current/platforms/android-24/arch-arm64/usr/include"], + }, + mips: { + export_include_dirs: ["current/platforms/android-24/arch-mips/usr/include"], + }, + mips64: { + export_include_dirs: ["current/platforms/android-24/arch-mips64/usr/include"], + }, + x86: { + export_include_dirs: ["current/platforms/android-24/arch-x86/usr/include"], + }, + x86_64: { + export_include_dirs: ["current/platforms/android-24/arch-x86_64/usr/include"], + }, + }, } ndk_prebuilt_object { @@ -406,4 +726,4 @@ ndk_prebuilt_object { sdk_version: "24", } -build = ["stl.bp"] +build = ["bionic.bp", "stl.bp"] diff --git a/bionic.bp b/bionic.bp new file mode 100644 index 000000000..c14f12af8 --- /dev/null +++ b/bionic.bp @@ -0,0 +1,8 @@ +// Update with bionic/tools/update_headers.sh. +ndk_headers { + name: "libc_unified_headers", + from: "headers", + to: "", + srcs: ["headers/**/*.h"], + license: "NOTICE", +} diff --git a/gen-blueprints.py b/gen-blueprints.py index 8b16a2f04..192f4aebe 100755 --- a/gen-blueprints.py +++ b/gen-blueprints.py @@ -119,7 +119,7 @@ def main(): f.write('\n') f.write('\n\n'.join(blueprints)) f.write('\n\n') - f.write('build = ["stl.bp"]\n') + f.write('build = ["bionic.bp", "stl.bp"]\n') if __name__ == '__main__': diff --git a/headers/alloca.h b/headers/alloca.h new file mode 100644 index 000000000..0508d3158 --- /dev/null +++ b/headers/alloca.h @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _ALLOCA_H +#define _ALLOCA_H + +#include <sys/cdefs.h> + +#define alloca(size) __builtin_alloca(size) + +#endif /* _ALLOCA_H */ + diff --git a/headers/android/api-level.h b/headers/android/api-level.h new file mode 100644 index 000000000..c83c18d7f --- /dev/null +++ b/headers/android/api-level.h @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef ANDROID_API_LEVEL_H +#define ANDROID_API_LEVEL_H + +#include <sys/cdefs.h> + +/* + * Magic version number for a current development build, which has + * not yet turned into an official release. + */ +#ifndef __ANDROID_API_FUTURE__ +#define __ANDROID_API_FUTURE__ 10000 +#endif + +#ifndef __ANDROID_API__ +#define __ANDROID_API__ __ANDROID_API_FUTURE__ +#endif + +#define __ANDROID_API_G__ 9 +#define __ANDROID_API_I__ 14 +#define __ANDROID_API_J__ 16 +#define __ANDROID_API_J_MR1__ 17 +#define __ANDROID_API_J_MR2__ 18 +#define __ANDROID_API_K__ 19 +#define __ANDROID_API_L__ 21 +#define __ANDROID_API_L_MR1__ 22 +#define __ANDROID_API_M__ 23 +#define __ANDROID_API_N__ 24 +#define __ANDROID_API_N_MR1__ 25 +#define __ANDROID_API_O__ 26 + +#endif /* ANDROID_API_LEVEL_H */ diff --git a/headers/android/dlext.h b/headers/android/dlext.h new file mode 100644 index 000000000..e5c0c6b27 --- /dev/null +++ b/headers/android/dlext.h @@ -0,0 +1,141 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __ANDROID_DLEXT_H__ +#define __ANDROID_DLEXT_H__ + +#include <stdbool.h> +#include <stddef.h> +#include <stdint.h> +#include <sys/cdefs.h> +#include <sys/types.h> /* for off64_t */ + +__BEGIN_DECLS + +/* bitfield definitions for android_dlextinfo.flags */ +enum { + /* When set, the reserved_addr and reserved_size fields must point to an + * already-reserved region of address space which will be used to load the + * library if it fits. If the reserved region is not large enough, the load + * will fail. + */ + ANDROID_DLEXT_RESERVED_ADDRESS = 0x1, + + /* As DLEXT_RESERVED_ADDRESS, but if the reserved region is not large enough, + * the linker will choose an available address instead. + */ + ANDROID_DLEXT_RESERVED_ADDRESS_HINT = 0x2, + + /* When set, write the GNU RELRO section of the mapped library to relro_fd + * after relocation has been performed, to allow it to be reused by another + * process loading the same library at the same address. This implies + * ANDROID_DLEXT_USE_RELRO. + */ + ANDROID_DLEXT_WRITE_RELRO = 0x4, + + /* When set, compare the GNU RELRO section of the mapped library to relro_fd + * after relocation has been performed, and replace any relocated pages that + * are identical with a version mapped from the file. + */ + ANDROID_DLEXT_USE_RELRO = 0x8, + + /* Instruct dlopen to use library_fd instead of opening file by name. + * The filename parameter is still used to identify the library. + */ + ANDROID_DLEXT_USE_LIBRARY_FD = 0x10, + + /* If opening a library using library_fd read it starting at library_fd_offset. + * This flag is only valid when ANDROID_DLEXT_USE_LIBRARY_FD is set. + */ + ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET = 0x20, + + /* When set, do not check if the library has already been loaded by file stat(2)s. + * + * This flag allows forced loading of the library in the case when for some + * reason multiple ELF files share the same filename (because the already-loaded + * library has been removed and overwritten, for example). + * + * Note that if the library has the same dt_soname as an old one and some other + * library has the soname in DT_NEEDED list, the first one will be used to resolve any + * dependencies. + */ + ANDROID_DLEXT_FORCE_LOAD = 0x40, + + /* When set, if the minimum p_vaddr of the ELF file's PT_LOAD segments is non-zero, + * the dynamic linker will load it at that address. + * + * This flag is for ART internal use only. + */ + ANDROID_DLEXT_FORCE_FIXED_VADDR = 0x80, + + /* Instructs dlopen to load the library at the address specified by reserved_addr. + * + * The difference between ANDROID_DLEXT_LOAD_AT_FIXED_ADDRESS and ANDROID_DLEXT_RESERVED_ADDRESS + * is that for ANDROID_DLEXT_LOAD_AT_FIXED_ADDRESS the linker reserves memory at reserved_addr + * whereas for ANDROID_DLEXT_RESERVED_ADDRESS the linker relies on the caller to reserve the memory. + * + * This flag can be used with ANDROID_DLEXT_FORCE_FIXED_VADDR; when ANDROID_DLEXT_FORCE_FIXED_VADDR + * is set and load_bias is not 0 (load_bias is min(p_vaddr) of PT_LOAD segments) this flag is ignored. + * This is implemented this way because the linker has to pick one address over the other and this + * way is more convenient for art. Note that ANDROID_DLEXT_FORCE_FIXED_VADDR does not generate + * an error when min(p_vaddr) is 0. + * + * Cannot be used with ANDROID_DLEXT_RESERVED_ADDRESS or ANDROID_DLEXT_RESERVED_ADDRESS_HINT. + * + * This flag is for ART internal use only. + */ + ANDROID_DLEXT_LOAD_AT_FIXED_ADDRESS = 0x100, + + /* This flag used to load library in a different namespace. The namespace is + * specified in library_namespace. + */ + ANDROID_DLEXT_USE_NAMESPACE = 0x200, + + /* Mask of valid bits */ + ANDROID_DLEXT_VALID_FLAG_BITS = ANDROID_DLEXT_RESERVED_ADDRESS | + ANDROID_DLEXT_RESERVED_ADDRESS_HINT | + ANDROID_DLEXT_WRITE_RELRO | + ANDROID_DLEXT_USE_RELRO | + ANDROID_DLEXT_USE_LIBRARY_FD | + ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET | + ANDROID_DLEXT_FORCE_LOAD | + ANDROID_DLEXT_FORCE_FIXED_VADDR | + ANDROID_DLEXT_LOAD_AT_FIXED_ADDRESS | + ANDROID_DLEXT_USE_NAMESPACE, +}; + +struct android_namespace_t; + +typedef struct { + uint64_t flags; + void* reserved_addr; + size_t reserved_size; + int relro_fd; + int library_fd; + off64_t library_fd_offset; + struct android_namespace_t* library_namespace; +} android_dlextinfo; + + +#if __ANDROID_API__ >= 21 +void* android_dlopen_ext(const char* filename, int flag, const android_dlextinfo* extinfo) + __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +__END_DECLS + +#endif /* __ANDROID_DLEXT_H__ */ diff --git a/headers/android/legacy_errno_inlines.h b/headers/android/legacy_errno_inlines.h new file mode 100644 index 000000000..8f08074f1 --- /dev/null +++ b/headers/android/legacy_errno_inlines.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2015 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _ANDROID_LEGACY_ERRNO_INLINES_H +#define _ANDROID_LEGACY_ERRNO_INLINES_H + +#include <errno.h> +#include <sys/cdefs.h> + +#if __ANDROID_API__ < __ANDROID_API_L__ + +__BEGIN_DECLS + +static __inline int __attribute__((deprecated)) __set_errno(int n) { + errno = n; + return -1; +} + +__END_DECLS + +#endif +#endif /* _ANDROID_LEGACY_ERRNO_INLINES_H */ diff --git a/headers/android/legacy_fenv_inlines_arm.h b/headers/android/legacy_fenv_inlines_arm.h new file mode 100644 index 000000000..58c49c2cf --- /dev/null +++ b/headers/android/legacy_fenv_inlines_arm.h @@ -0,0 +1,154 @@ +/*- + * Copyright (c) 2004 David Schultz <das@FreeBSD.ORG> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD: src/lib/msun/arm/fenv.c,v 1.1 2004/06/06 10:03:59 das Exp $ + */ + +#ifndef ANDROID_LEGACY_FENV_INLINES_ARM_H +#define ANDROID_LEGACY_FENV_INLINES_ARM_H + +#include <fenv.h> + +#if __ANDROID_API__ < __ANDROID_API_L__ && defined(__arm__) + +__BEGIN_DECLS + +#define FPSCR_ENABLE_SHIFT 8 +#define FPSCR_ENABLE_MASK (FE_ALL_EXCEPT << FPSCR_ENABLE_SHIFT) + +#define FPSCR_RMODE_SHIFT 22 + +static __inline int fegetenv(fenv_t* __envp) { + fenv_t _fpscr; + __asm__ __volatile__("vmrs %0,fpscr" : "=r" (_fpscr)); + *__envp = _fpscr; + return 0; +} + +static __inline int fesetenv(const fenv_t* __envp) { + fenv_t _fpscr = *__envp; + __asm__ __volatile__("vmsr fpscr,%0" : :"ri" (_fpscr)); + return 0; +} + +static __inline int feclearexcept(int __excepts) { + fexcept_t __fpscr; + fegetenv(&__fpscr); + __fpscr &= ~__excepts; + fesetenv(&__fpscr); + return 0; +} + +static __inline int fegetexceptflag(fexcept_t* __flagp, int __excepts) { + fexcept_t __fpscr; + fegetenv(&__fpscr); + *__flagp = __fpscr & __excepts; + return 0; +} + +static __inline int fesetexceptflag(const fexcept_t* __flagp, int __excepts) { + fexcept_t __fpscr; + fegetenv(&__fpscr); + __fpscr &= ~__excepts; + __fpscr |= *__flagp & __excepts; + fesetenv(&__fpscr); + return 0; +} + +static __inline int feraiseexcept(int __excepts) { + fexcept_t __ex = __excepts; + fesetexceptflag(&__ex, __excepts); + return 0; +} + +static __inline int fetestexcept(int __excepts) { + fexcept_t __fpscr; + fegetenv(&__fpscr); + return (__fpscr & __excepts); +} + +static __inline int fegetround(void) { + fenv_t _fpscr; + fegetenv(&_fpscr); + return ((_fpscr >> FPSCR_RMODE_SHIFT) & 0x3); +} + +static __inline int fesetround(int __round) { + fenv_t _fpscr; + fegetenv(&_fpscr); + _fpscr &= ~(0x3 << FPSCR_RMODE_SHIFT); + _fpscr |= (__round << FPSCR_RMODE_SHIFT); + fesetenv(&_fpscr); + return 0; +} + +static __inline int feholdexcept(fenv_t* __envp) { + fenv_t __env; + fegetenv(&__env); + *__envp = __env; + __env &= ~(FE_ALL_EXCEPT | FPSCR_ENABLE_MASK); + fesetenv(&__env); + return 0; +} + +static __inline int feupdateenv(const fenv_t* __envp) { + fexcept_t __fpscr; + fegetenv(&__fpscr); + fesetenv(__envp); + feraiseexcept(__fpscr & FE_ALL_EXCEPT); + return 0; +} + +static __inline int feenableexcept(int __mask) { + fenv_t __old_fpscr, __new_fpscr; + fegetenv(&__old_fpscr); + __new_fpscr = __old_fpscr | (__mask & FE_ALL_EXCEPT) << FPSCR_ENABLE_SHIFT; + fesetenv(&__new_fpscr); + return ((__old_fpscr >> FPSCR_ENABLE_SHIFT) & FE_ALL_EXCEPT); +} + +static __inline int fedisableexcept(int __mask) { + fenv_t __old_fpscr, __new_fpscr; + fegetenv(&__old_fpscr); + __new_fpscr = __old_fpscr & ~((__mask & FE_ALL_EXCEPT) << FPSCR_ENABLE_SHIFT); + fesetenv(&__new_fpscr); + return ((__old_fpscr >> FPSCR_ENABLE_SHIFT) & FE_ALL_EXCEPT); +} + +static __inline int fegetexcept(void) { + fenv_t __fpscr; + fegetenv(&__fpscr); + return ((__fpscr & FPSCR_ENABLE_MASK) >> FPSCR_ENABLE_SHIFT); +} + +#undef FPSCR_ENABLE_SHIFT +#undef FPSCR_ENABLE_MASK +#undef FPSCR_RMODE_SHIFT + +__END_DECLS + +#endif /* __ANDROID_API__ < __ANDROID_API_L__ && defined(__arm__) */ + +#endif /* ANDROID_LEGACY_FENV_INLINES_ARM_H */ diff --git a/headers/android/legacy_fenv_inlines_mips.h b/headers/android/legacy_fenv_inlines_mips.h new file mode 100644 index 000000000..10b93c070 --- /dev/null +++ b/headers/android/legacy_fenv_inlines_mips.h @@ -0,0 +1,168 @@ +/*- + * Copyright (c) 2004 David Schultz <das@FreeBSD.ORG> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD: src/lib/msun/mips/fenv.c,v 1.1 2008/04/26 12:20:29 imp Exp $ + */ + +#ifndef ANDROID_LEGACY_FENV_INLINES_MIPS_H +#define ANDROID_LEGACY_FENV_INLINES_MIPS_H + +#include <fenv.h> + +#if __ANDROID_API__ < __ANDROID_API_L__ && (defined(__mips__) && !defined(__LP64__)) + +__BEGIN_DECLS + +#define FCSR_CAUSE_SHIFT 10 +#define FCSR_ENABLE_SHIFT 5 +#define FCSR_ENABLE_MASK (FE_ALL_EXCEPT << FCSR_ENABLE_SHIFT) + +#define FCSR_RMASK 0x3 + +static __inline int fegetenv(fenv_t* __envp) { + fenv_t _fcsr = 0; +#ifdef __mips_hard_float + __asm__ __volatile__("cfc1 %0,$31" : "=r" (_fcsr)); +#endif + *__envp = _fcsr; + return 0; +} + +static __inline int fesetenv(const fenv_t* __envp) { + fenv_t _fcsr = *__envp; +#ifdef __mips_hard_float + __asm__ __volatile__("ctc1 %0,$31" : : "r" (_fcsr)); +#endif + return 0; +} + +static __inline int feclearexcept(int __excepts) { + fexcept_t __fcsr; + fegetenv(&__fcsr); + __excepts &= FE_ALL_EXCEPT; + __fcsr &= ~(__excepts | (__excepts << FCSR_CAUSE_SHIFT)); + fesetenv(&__fcsr); + return 0; +} + +static __inline int fegetexceptflag(fexcept_t* __flagp, int __excepts) { + fexcept_t __fcsr; + fegetenv(&__fcsr); + *__flagp = __fcsr & __excepts & FE_ALL_EXCEPT; + return 0; +} + +static __inline int fesetexceptflag(const fexcept_t* __flagp, int __excepts) { + fexcept_t __fcsr; + fegetenv(&__fcsr); + /* Ensure that flags are all legal */ + __excepts &= FE_ALL_EXCEPT; + __fcsr &= ~__excepts; + __fcsr |= *__flagp & __excepts; + fesetenv(&__fcsr); + return 0; +} + +static __inline int feraiseexcept(int __excepts) { + fexcept_t __fcsr; + fegetenv(&__fcsr); + /* Ensure that flags are all legal */ + __excepts &= FE_ALL_EXCEPT; + /* Cause bit needs to be set as well for generating the exception*/ + __fcsr |= __excepts | (__excepts << FCSR_CAUSE_SHIFT); + fesetenv(&__fcsr); + return 0; +} + +static __inline int fetestexcept(int __excepts) { + fexcept_t __FCSR; + fegetenv(&__FCSR); + return (__FCSR & __excepts & FE_ALL_EXCEPT); +} + +static __inline int fegetround(void) { + fenv_t _fcsr; + fegetenv(&_fcsr); + return (_fcsr & FCSR_RMASK); +} + +static __inline int fesetround(int __round) { + fenv_t _fcsr; + fegetenv(&_fcsr); + _fcsr &= ~FCSR_RMASK; + _fcsr |= (__round & FCSR_RMASK); + fesetenv(&_fcsr); + return 0; +} + +static __inline int feholdexcept(fenv_t* __envp) { + fenv_t __env; + fegetenv(&__env); + *__envp = __env; + __env &= ~(FE_ALL_EXCEPT | FCSR_ENABLE_MASK); + fesetenv(&__env); + return 0; +} + +static __inline int feupdateenv(const fenv_t* __envp) { + fexcept_t __fcsr; + fegetenv(&__fcsr); + fesetenv(__envp); + feraiseexcept(__fcsr & FE_ALL_EXCEPT); + return 0; +} + +static __inline int feenableexcept(int __mask) { + fenv_t __old_fcsr, __new_fcsr; + fegetenv(&__old_fcsr); + __new_fcsr = __old_fcsr | (__mask & FE_ALL_EXCEPT) << FCSR_ENABLE_SHIFT; + fesetenv(&__new_fcsr); + return ((__old_fcsr >> FCSR_ENABLE_SHIFT) & FE_ALL_EXCEPT); +} + +static __inline int fedisableexcept(int __mask) { + fenv_t __old_fcsr, __new_fcsr; + fegetenv(&__old_fcsr); + __new_fcsr = __old_fcsr & ~((__mask & FE_ALL_EXCEPT) << FCSR_ENABLE_SHIFT); + fesetenv(&__new_fcsr); + return ((__old_fcsr >> FCSR_ENABLE_SHIFT) & FE_ALL_EXCEPT); +} + +static __inline int fegetexcept(void) { + fenv_t __fcsr; + fegetenv(&__fcsr); + return ((__fcsr & FCSR_ENABLE_MASK) >> FCSR_ENABLE_SHIFT); +} + +#undef FCSR_CAUSE_SHIFT +#undef FCSR_ENABLE_SHIFT +#undef FCSR_ENABLE_MASK +#undef FCSR_RMASK + +__END_DECLS + +#endif /* __ANDROID_API__ < __ANDROID_API_L__ && (defined(__mips__) && !defined(__LP64__)) */ + +#endif /* ANDROID_LEGACY_FENV_INLINES_MIPS_H */ diff --git a/headers/android/legacy_signal_inlines.h b/headers/android/legacy_signal_inlines.h new file mode 100644 index 000000000..afdaca840 --- /dev/null +++ b/headers/android/legacy_signal_inlines.h @@ -0,0 +1,105 @@ +/* + * Copyright (C) 2015 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _ANDROID_LEGACY_SIGNAL_INLINES_H_ +#define _ANDROID_LEGACY_SIGNAL_INLINES_H_ + +#include <errno.h> +#include <signal.h> +#include <string.h> +#include <sys/cdefs.h> + + +__BEGIN_DECLS + +sighandler_t bsd_signal(int signum, sighandler_t handler) __REMOVED_IN(21); + +#if __ANDROID_API__ < __ANDROID_API_L__ + +static __inline int sigismember(const sigset_t *set, int signum) { + /* Signal numbers start at 1, but bit positions start at 0. */ + int bit = signum - 1; + const unsigned long *local_set = (const unsigned long *)set; + if (set == NULL || bit < 0 || bit >= (int)(8 * sizeof(sigset_t))) { + errno = EINVAL; + return -1; + } + return (int)((local_set[bit / LONG_BIT] >> (bit % LONG_BIT)) & 1); +} + +static __inline int sigaddset(sigset_t *set, int signum) { + /* Signal numbers start at 1, but bit positions start at 0. */ + int bit = signum - 1; + unsigned long *local_set = (unsigned long *)set; + if (set == NULL || bit < 0 || bit >= (int)(8 * sizeof(sigset_t))) { + errno = EINVAL; + return -1; + } + local_set[bit / LONG_BIT] |= 1UL << (bit % LONG_BIT); + return 0; +} + +static __inline int sigdelset(sigset_t *set, int signum) { + /* Signal numbers start at 1, but bit positions start at 0. */ + int bit = signum - 1; + unsigned long *local_set = (unsigned long *)set; + if (set == NULL || bit < 0 || bit >= (int)(8 * sizeof(sigset_t))) { + errno = EINVAL; + return -1; + } + local_set[bit / LONG_BIT] &= ~(1UL << (bit % LONG_BIT)); + return 0; +} + +static __inline int sigemptyset(sigset_t *set) { + if (set == NULL) { + errno = EINVAL; + return -1; + } + memset(set, 0, sizeof(sigset_t)); + return 0; +} + +static __inline int sigfillset(sigset_t *set) { + if (set == NULL) { + errno = EINVAL; + return -1; + } + memset(set, ~0, sizeof(sigset_t)); + return 0; +} + +static __inline sighandler_t signal(int s, sighandler_t f) { + return bsd_signal(s, f); +} + +#endif /* __ANDROID_API__ < __ANDROID_API_L__ */ + +__END_DECLS + +#endif /* _ANDROID_LEGACY_SIGNAL_INLINES_H_ */ diff --git a/headers/android/legacy_stdlib_inlines.h b/headers/android/legacy_stdlib_inlines.h new file mode 100644 index 000000000..e211de5ae --- /dev/null +++ b/headers/android/legacy_stdlib_inlines.h @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2015 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _ANDROID_LEGACY_STDLIB_INLINES_H_ +#define _ANDROID_LEGACY_STDLIB_INLINES_H_ + +#include <stdlib.h> +#include <sys/cdefs.h> + +#if __ANDROID_API__ < __ANDROID_API_L__ + +__BEGIN_DECLS + +static __inline float strtof(const char *nptr, char **endptr) { + return (float)strtod(nptr, endptr); +} + +static __inline double atof(const char *nptr) { return (strtod(nptr, NULL)); } + +static __inline int abs(int __n) { return (__n < 0) ? -__n : __n; } + +static __inline long labs(long __n) { return (__n < 0L) ? -__n : __n; } + +static __inline long long llabs(long long __n) { + return (__n < 0LL) ? -__n : __n; +} + +static __inline int rand(void) { return (int)lrand48(); } + +static __inline void srand(unsigned int __s) { srand48(__s); } + +static __inline long random(void) { return lrand48(); } + +static __inline void srandom(unsigned int __s) { srand48(__s); } + +static __inline int grantpt(int __fd __attribute((unused))) { + return 0; /* devpts does this all for us! */ +} + +__END_DECLS + +#endif +#endif /* _ANDROID_LEGACY_STDLIB_INLINES_H_ */ diff --git a/headers/android/legacy_sys_stat_inlines.h b/headers/android/legacy_sys_stat_inlines.h new file mode 100644 index 000000000..23a9f0738 --- /dev/null +++ b/headers/android/legacy_sys_stat_inlines.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2015 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _ANDROID_LEGACY_SYS_STAT_INLINES_H_ +#define _ANDROID_LEGACY_SYS_STAT_INLINES_H_ + +#include <sys/cdefs.h> +#include <sys/stat.h> + +#if __ANDROID_API__ < __ANDROID_API_L__ + +__BEGIN_DECLS + +static __inline int mkfifo(const char *__p, mode_t __m) { + return mknod(__p, (__m & ~S_IFMT) | S_IFIFO, (dev_t)0); +} + +__END_DECLS + +#endif +#endif /* _ANDROID_LEGACY_SYS_STAT_INLINES_H_ */ diff --git a/headers/android/legacy_sys_wait_inlines.h b/headers/android/legacy_sys_wait_inlines.h new file mode 100644 index 000000000..1124f8e29 --- /dev/null +++ b/headers/android/legacy_sys_wait_inlines.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _ANDROID_LEGACY_SYS_WAIT_INLINES_H_ +#define _ANDROID_LEGACY_SYS_WAIT_INLINES_H_ + +#include <sys/cdefs.h> +#include <sys/syscall.h> +#include <sys/wait.h> +#include <unistd.h> + +#if __ANDROID_API__ < __ANDROID_API_J_MR2__ + +__BEGIN_DECLS + +static __inline pid_t wait4(pid_t pid, int* status, int options, struct rusage* rusage) { + return __BIONIC_CAST(static_cast, pid_t, syscall(__NR_wait4, pid, status, options, rusage)); +} + +__END_DECLS + +#endif /* __ANDROID_API__ < __ANDROID_API_J_MR2__ */ + +#endif /* _ANDROID_LEGACY_SYS_WAIT_INLINES_H_ */ diff --git a/headers/android/legacy_termios_inlines.h b/headers/android/legacy_termios_inlines.h new file mode 100644 index 000000000..4424bdb0b --- /dev/null +++ b/headers/android/legacy_termios_inlines.h @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2015 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _ANDROID_LEGACY_TERMIOS_INLINES_H_ +#define _ANDROID_LEGACY_TERMIOS_INLINES_H_ + +#include <sys/cdefs.h> +#include <sys/ioctl.h> +#include <sys/types.h> + +#include <linux/termios.h> + +#if __ANDROID_API__ < __ANDROID_API_L__ + +__BEGIN_DECLS + +static __inline int tcgetattr(int fd, struct termios *s) { + return ioctl(fd, TCGETS, s); +} + +static __inline int tcsetattr(int fd, int __opt, const struct termios *s) { + return ioctl(fd, __opt, (void *)s); +} + +static __inline int tcflow(int fd, int action) { + return ioctl(fd, TCXONC, (void *)(intptr_t)action); +} + +static __inline int tcflush(int fd, int __queue) { + return ioctl(fd, TCFLSH, (void *)(intptr_t)__queue); +} + +static __inline pid_t tcgetsid(int fd) { + pid_t _pid; + return ioctl(fd, TIOCGSID, &_pid) ? (pid_t)-1 : _pid; +} + +static __inline int tcsendbreak(int fd, int __duration) { + return ioctl(fd, TCSBRKP, (void *)(uintptr_t)__duration); +} + +static __inline speed_t cfgetospeed(const struct termios *s) { + return (speed_t)(s->c_cflag & CBAUD); +} + +static __inline int cfsetospeed(struct termios *s, speed_t speed) { + s->c_cflag = (s->c_cflag & ~CBAUD) | (speed & CBAUD); + return 0; +} + +static __inline speed_t cfgetispeed(const struct termios *s) { + return (speed_t)(s->c_cflag & CBAUD); +} + +static __inline int cfsetispeed(struct termios *s, speed_t speed) { + s->c_cflag = (s->c_cflag & ~CBAUD) | (speed & CBAUD); + return 0; +} + +static __inline void cfmakeraw(struct termios *s) { + s->c_iflag &= + ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON); + s->c_oflag &= ~OPOST; + s->c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN); + s->c_cflag &= ~(CSIZE | PARENB); + s->c_cflag |= CS8; +} + +__END_DECLS + +#endif +#endif /* _ANDROID_LEGACY_TERMIOS_INLINES_H_ */ diff --git a/headers/android/set_abort_message.h b/headers/android/set_abort_message.h new file mode 100644 index 000000000..9a68a7201 --- /dev/null +++ b/headers/android/set_abort_message.h @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SET_ABORT_MESSAGE_H +#define _SET_ABORT_MESSAGE_H + +#include <sys/cdefs.h> + +__BEGIN_DECLS + + +#if __ANDROID_API__ >= 21 +void android_set_abort_message(const char* msg) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +__END_DECLS + +#endif diff --git a/headers/android/versioning.h b/headers/android/versioning.h new file mode 100644 index 000000000..4e1a1854c --- /dev/null +++ b/headers/android/versioning.h @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ANDROID_VERSIONING_H +#define ANDROID_VERSIONING_H + +#define __INTRODUCED_IN(api_level) __attribute__((annotate("introduced_in=" #api_level))) +#define __INTRODUCED_IN_FUTURE __attribute__((annotate("introduced_in_future"))) +#define __DEPRECATED_IN(api_level) __attribute__((annotate("deprecated_in=" #api_level))) +#define __REMOVED_IN(api_level) __attribute__((annotate("obsoleted_in=" #api_level))) +#define __INTRODUCED_IN_32(api_level) __attribute__((annotate("introduced_in_32=" #api_level))) +#define __INTRODUCED_IN_64(api_level) __attribute__((annotate("introduced_in_64=" #api_level))) +#define __INTRODUCED_IN_ARM(api_level) __attribute__((annotate("introduced_in_arm=" #api_level))) +#define __INTRODUCED_IN_X86(api_level) __attribute__((annotate("introduced_in_x86=" #api_level))) +#define __INTRODUCED_IN_MIPS(api_level) __attribute__((annotate("introduced_in_mips=" #api_level))) + +#define __VERSIONER_NO_GUARD __attribute__((annotate("versioner_no_guard"))) + +#endif /* ANDROID_VERSIONING_H */ diff --git a/headers/ar.h b/headers/ar.h new file mode 100644 index 000000000..413f76720 --- /dev/null +++ b/headers/ar.h @@ -0,0 +1,68 @@ +/* $OpenBSD: ar.h,v 1.3 2003/06/02 19:34:12 millert Exp $ */ +/* $NetBSD: ar.h,v 1.4 1994/10/26 00:55:43 cgd Exp $ */ + +/*- + * Copyright (c) 1991, 1993 + * The Regents of the University of California. All rights reserved. + * (c) UNIX System Laboratories, Inc. + * All or some portions of this file are derived from material licensed + * to the University of California by American Telephone and Telegraph + * Co. or Unix System Laboratories, Inc. and are reproduced herein with + * the permission of UNIX System Laboratories, Inc. + * + * This code is derived from software contributed to Berkeley by + * Hugh Smith at The University of Guelph. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)ar.h 8.2 (Berkeley) 1/21/94 + */ + +#ifndef _AR_H_ +#define _AR_H_ + +#include <sys/cdefs.h> + +/* Pre-4BSD archives had these magic numbers in them. */ +#define OARMAG1 0177555 +#define OARMAG2 0177545 + +#define ARMAG "!<arch>\n" /* ar "magic number" */ +#define SARMAG 8 /* strlen(ARMAG); */ + +#define AR_EFMT1 "#1/" /* extended format #1 */ + +struct ar_hdr { + char ar_name[16]; /* name */ + char ar_date[12]; /* modification time */ + char ar_uid[6]; /* user id */ + char ar_gid[6]; /* group id */ + char ar_mode[8]; /* octal file permissions */ + char ar_size[10]; /* size in bytes */ +#define ARFMAG "`\n" + char ar_fmag[2]; /* consistency check */ +}; + +#endif /* !_AR_H_ */ diff --git a/headers/arpa/inet.h b/headers/arpa/inet.h new file mode 100644 index 000000000..b60396544 --- /dev/null +++ b/headers/arpa/inet.h @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _ARPA_INET_H_ +#define _ARPA_INET_H_ + +#include <netinet/in.h> +#include <stdint.h> +#include <sys/cdefs.h> +#include <sys/types.h> + +__BEGIN_DECLS + +in_addr_t inet_addr(const char*); +int inet_aton(const char*, struct in_addr*); + +#if __ANDROID_API__ >= 21 +in_addr_t inet_lnaof(struct in_addr) __INTRODUCED_IN(21); +struct in_addr inet_makeaddr(in_addr_t, in_addr_t) __INTRODUCED_IN(21); +in_addr_t inet_netof(struct in_addr) __INTRODUCED_IN(21); +in_addr_t inet_network(const char*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +char* inet_ntoa(struct in_addr); +const char* inet_ntop(int, const void*, char*, socklen_t); +unsigned int inet_nsap_addr(const char*, unsigned char*, int); +char* inet_nsap_ntoa(int, const unsigned char*, char*); +int inet_pton(int, const char*, void*); + +__END_DECLS + +#endif /* _ARPA_INET_H_ */ diff --git a/headers/arpa/nameser.h b/headers/arpa/nameser.h new file mode 100644 index 000000000..7b92fc314 --- /dev/null +++ b/headers/arpa/nameser.h @@ -0,0 +1,634 @@ +/* $NetBSD: nameser.h,v 1.25 2009/04/12 17:07:34 christos Exp $ */ + +/* + * Portions Copyright (C) 2004, 2005, 2008, 2009 Internet Systems Consortium, Inc. ("ISC") + * Portions Copyright (C) 1996-2003 Internet Software Consortium. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, + * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM + * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE + * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +/* + * Copyright (c) 1983, 1989, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * Id: nameser.h,v 1.16 2009/03/03 01:52:48 each Exp + */ + +#ifndef _ARPA_NAMESER_H_ +#define _ARPA_NAMESER_H_ + +#define BIND_4_COMPAT + +#include <sys/types.h> +#include <sys/cdefs.h> + +/* + * Revision information. This is the release date in YYYYMMDD format. + * It can change every day so the right thing to do with it is use it + * in preprocessor commands such as "#if (__NAMESER > 19931104)". Do not + * compare for equality; rather, use it to determine whether your libbind.a + * contains a new enough lib/nameser/ to support the feature you need. + */ + +#define __NAMESER 20090302 /*%< New interface version stamp. */ + +/* + * Define constants based on RFC0883, RFC1034, RFC 1035 + */ +#define NS_PACKETSZ 512 /* default UDP packet size */ +#define NS_MAXDNAME 1025 /* maximum domain name (presentation format)*/ +#define NS_MAXMSG 65535 /* maximum message size */ +#define NS_MAXCDNAME 255 /* maximum compressed domain name */ +#define NS_MAXLABEL 63 /* maximum length of domain label */ +#define NS_MAXLABELS 128 /* theoretical max #/labels per domain name */ +#define NS_MAXNNAME 256 /* maximum uncompressed (binary) domain name*/ +#define NS_MAXPADDR (sizeof "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff") +#define NS_HFIXEDSZ 12 /* #/bytes of fixed data in header */ +#define NS_QFIXEDSZ 4 /* #/bytes of fixed data in query */ +#define NS_RRFIXEDSZ 10 /* #/bytes of fixed data in r record */ +#define NS_INT32SZ 4 /* #/bytes of data in a uint32_t */ +#define NS_INT16SZ 2 /* #/bytes of data in a uint16_t */ +#define NS_INT8SZ 1 /* #/bytes of data in a uint8_t */ +#define NS_INADDRSZ 4 /* IPv4 T_A */ +#define NS_IN6ADDRSZ 16 /* IPv6 T_AAAA */ +#define NS_CMPRSFLGS 0xc0 /* Flag bits indicating name compression. */ +#define NS_DEFAULTPORT 53 /* For both TCP and UDP. */ + +/* + * These can be expanded with synonyms, just keep ns_parse.c:ns_parserecord() + * in synch with it. + */ +typedef enum __ns_sect { + ns_s_qd = 0, /* Query: Question. */ + ns_s_zn = 0, /* Update: Zone. */ + ns_s_an = 1, /* Query: Answer. */ + ns_s_pr = 1, /* Update: Prerequisites. */ + ns_s_ns = 2, /* Query: Name servers. */ + ns_s_ud = 2, /* Update: Update. */ + ns_s_ar = 3, /* Query|Update: Additional records. */ + ns_s_max = 4 +} ns_sect; + +/* + * Network name (compressed or not) type. Equivilent to a pointer when used + * in a function prototype. Can be const'd. + */ +typedef u_char ns_nname[NS_MAXNNAME]; +typedef const u_char *ns_nname_ct; +typedef u_char *ns_nname_t; + +struct ns_namemap { ns_nname_ct base; int len; }; +typedef struct ns_namemap *ns_namemap_t; +typedef const struct ns_namemap *ns_namemap_ct; + +/* + * This is a message handle. It is caller allocated and has no dynamic data. + * This structure is intended to be opaque to all but ns_parse.c, thus the + * leading _'s on the member names. Use the accessor functions, not the _'s. + */ +typedef struct __ns_msg { + const u_char *_msg, *_eom; + uint16_t _id, _flags, _counts[ns_s_max]; + const u_char *_sections[ns_s_max]; + ns_sect _sect; + int _rrnum; + const u_char *_msg_ptr; +} ns_msg; +/* + * This is a newmsg handle, used when constructing new messages with + * ns_newmsg_init, et al. + */ +struct ns_newmsg { + ns_msg msg; + const u_char *dnptrs[25]; + const u_char **lastdnptr; +}; +typedef struct ns_newmsg ns_newmsg; + +/* Accessor macros - this is part of the public interface. */ + +#define ns_msg_id(handle) ((handle)._id + 0) +#define ns_msg_base(handle) ((handle)._msg + 0) +#define ns_msg_end(handle) ((handle)._eom + 0) +#define ns_msg_size(handle) ((size_t)((handle)._eom - (handle)._msg)) +#define ns_msg_count(handle, section) ((handle)._counts[section] + 0) + +/* + * This is a parsed record. It is caller allocated and has no dynamic data. + */ +typedef struct __ns_rr { + char name[NS_MAXDNAME]; + uint16_t type; + uint16_t rr_class; + uint32_t ttl; + uint16_t rdlength; + const u_char * rdata; +} ns_rr; + +/* + * Same thing, but using uncompressed network binary names, and real C types. + */ +typedef struct __ns_rr2 { + ns_nname nname; + size_t nnamel; + int type; + int rr_class; + u_int ttl; + int rdlength; + const u_char * rdata; +} ns_rr2; +/* Accessor macros - this is part of the public interface. */ +#define ns_rr_name(rr) (((rr).name[0] != '\0') ? (rr).name : ".") +#define ns_rr_nname(rr) ((const ns_nname_t)(rr).nname) +#define ns_rr_nnamel(rr) ((rr).nnamel + 0) +#define ns_rr_type(rr) ((ns_type)((rr).type + 0)) +#define ns_rr_class(rr) ((ns_class)((rr).rr_class + 0)) +#define ns_rr_ttl(rr) ((u_long)(rr).ttl + 0) +#define ns_rr_rdlen(rr) ((size_t)(rr).rdlength + 0) +#define ns_rr_rdata(rr) ((rr).rdata + 0) + +/* + * These don't have to be in the same order as in the packet flags word, + * and they can even overlap in some cases, but they will need to be kept + * in synch with ns_parse.c:ns_flagdata[]. + */ +typedef enum __ns_flag { + ns_f_qr, /* Question/Response. */ + ns_f_opcode, /* Operation code. */ + ns_f_aa, /* Authoritative Answer. */ + ns_f_tc, /* Truncation occurred. */ + ns_f_rd, /* Recursion Desired. */ + ns_f_ra, /* Recursion Available. */ + ns_f_z, /* MBZ. */ + ns_f_ad, /* Authentic Data (DNSSEC). */ + ns_f_cd, /* Checking Disabled (DNSSEC). */ + ns_f_rcode, /* Response code. */ + ns_f_max +} ns_flag; + +/* + * Currently defined opcodes. + */ +typedef enum __ns_opcode { + ns_o_query = 0, /* Standard query. */ + ns_o_iquery = 1, /* Inverse query (deprecated/unsupported). */ + ns_o_status = 2, /* Name server status query (unsupported). */ + /* Opcode 3 is undefined/reserved. */ + ns_o_notify = 4, /* Zone change notification. */ + ns_o_update = 5, /* Zone update message. */ + ns_o_max = 6 +} ns_opcode; + +/* + * Currently defined response codes. + */ +typedef enum __ns_rcode { + ns_r_noerror = 0, /* No error occurred. */ + ns_r_formerr = 1, /* Format error. */ + ns_r_servfail = 2, /* Server failure. */ + ns_r_nxdomain = 3, /* Name error. */ + ns_r_notimpl = 4, /* Unimplemented. */ + ns_r_refused = 5, /* Operation refused. */ + /* these are for BIND_UPDATE */ + ns_r_yxdomain = 6, /* Name exists */ + ns_r_yxrrset = 7, /* RRset exists */ + ns_r_nxrrset = 8, /* RRset does not exist */ + ns_r_notauth = 9, /* Not authoritative for zone */ + ns_r_notzone = 10, /* Zone of record different from zone section */ + ns_r_max = 11, + /* The following are EDNS extended rcodes */ + ns_r_badvers = 16, + /* The following are TSIG errors */ + ns_r_badsig = 16, + ns_r_badkey = 17, + ns_r_badtime = 18 +} ns_rcode; + +/* BIND_UPDATE */ +typedef enum __ns_update_operation { + ns_uop_delete = 0, + ns_uop_add = 1, + ns_uop_max = 2 +} ns_update_operation; + +/* + * This structure is used for TSIG authenticated messages + */ +struct ns_tsig_key { + char name[NS_MAXDNAME], alg[NS_MAXDNAME]; + unsigned char *data; + int len; +}; +typedef struct ns_tsig_key ns_tsig_key; + +/* + * This structure is used for TSIG authenticated TCP messages + */ +struct ns_tcp_tsig_state { + int counter; + struct dst_key *key; + void *ctx; + unsigned char sig[NS_PACKETSZ]; + int siglen; +}; +typedef struct ns_tcp_tsig_state ns_tcp_tsig_state; + +#define NS_TSIG_FUDGE 300 +#define NS_TSIG_TCP_COUNT 100 +#define NS_TSIG_ALG_HMAC_MD5 "HMAC-MD5.SIG-ALG.REG.INT" + +#define NS_TSIG_ERROR_NO_TSIG -10 +#define NS_TSIG_ERROR_NO_SPACE -11 +#define NS_TSIG_ERROR_FORMERR -12 + +/* + * Currently defined type values for resources and queries. + */ +typedef enum __ns_type { + ns_t_invalid = 0, /* Cookie. */ + ns_t_a = 1, /* Host address. */ + ns_t_ns = 2, /* Authoritative server. */ + ns_t_md = 3, /* Mail destination. */ + ns_t_mf = 4, /* Mail forwarder. */ + ns_t_cname = 5, /* Canonical name. */ + ns_t_soa = 6, /* Start of authority zone. */ + ns_t_mb = 7, /* Mailbox domain name. */ + ns_t_mg = 8, /* Mail group member. */ + ns_t_mr = 9, /* Mail rename name. */ + ns_t_null = 10, /* Null resource record. */ + ns_t_wks = 11, /* Well known service. */ + ns_t_ptr = 12, /* Domain name pointer. */ + ns_t_hinfo = 13, /* Host information. */ + ns_t_minfo = 14, /* Mailbox information. */ + ns_t_mx = 15, /* Mail routing information. */ + ns_t_txt = 16, /* Text strings. */ + ns_t_rp = 17, /* Responsible person. */ + ns_t_afsdb = 18, /* AFS cell database. */ + ns_t_x25 = 19, /* X_25 calling address. */ + ns_t_isdn = 20, /* ISDN calling address. */ + ns_t_rt = 21, /* Router. */ + ns_t_nsap = 22, /* NSAP address. */ + ns_t_nsap_ptr = 23, /* Reverse NSAP lookup (deprecated). */ + ns_t_sig = 24, /* Security signature. */ + ns_t_key = 25, /* Security key. */ + ns_t_px = 26, /* X.400 mail mapping. */ + ns_t_gpos = 27, /* Geographical position (withdrawn). */ + ns_t_aaaa = 28, /* IPv6 Address. */ + ns_t_loc = 29, /* Location Information. */ + ns_t_nxt = 30, /* Next domain (security). */ + ns_t_eid = 31, /* Endpoint identifier. */ + ns_t_nimloc = 32, /* Nimrod Locator. */ + ns_t_srv = 33, /* Server Selection. */ + ns_t_atma = 34, /* ATM Address */ + ns_t_naptr = 35, /* Naming Authority PoinTeR */ + ns_t_kx = 36, /* Key Exchange */ + ns_t_cert = 37, /* Certification record */ + ns_t_a6 = 38, /* IPv6 address (experimental) */ + ns_t_dname = 39, /* Non-terminal DNAME */ + ns_t_sink = 40, /* Kitchen sink (experimentatl) */ + ns_t_opt = 41, /* EDNS0 option (meta-RR) */ + ns_t_apl = 42, /* Address prefix list (RFC 3123) */ + ns_t_ds = 43, /* Delegation Signer */ + ns_t_sshfp = 44, /* SSH Fingerprint */ + ns_t_ipseckey = 45, /* IPSEC Key */ + ns_t_rrsig = 46, /* RRset Signature */ + ns_t_nsec = 47, /* Negative security */ + ns_t_dnskey = 48, /* DNS Key */ + ns_t_dhcid = 49, /* Dynamic host configuratin identifier */ + ns_t_nsec3 = 50, /* Negative security type 3 */ + ns_t_nsec3param = 51, /* Negative security type 3 parameters */ + ns_t_hip = 55, /* Host Identity Protocol */ + ns_t_spf = 99, /* Sender Policy Framework */ + ns_t_tkey = 249, /* Transaction key */ + ns_t_tsig = 250, /* Transaction signature. */ + ns_t_ixfr = 251, /* Incremental zone transfer. */ + ns_t_axfr = 252, /* Transfer zone of authority. */ + ns_t_mailb = 253, /* Transfer mailbox records. */ + ns_t_maila = 254, /* Transfer mail agent records. */ + ns_t_any = 255, /* Wildcard match. */ + ns_t_zxfr = 256, /* BIND-specific, nonstandard. */ + ns_t_dlv = 32769, /* DNSSEC look-aside validatation. */ + ns_t_max = 65536 +} ns_type; + +/* Exclusively a QTYPE? (not also an RTYPE) */ +#define ns_t_qt_p(t) (ns_t_xfr_p(t) || (t) == ns_t_any || \ + (t) == ns_t_mailb || (t) == ns_t_maila) +/* Some kind of meta-RR? (not a QTYPE, but also not an RTYPE) */ +#define ns_t_mrr_p(t) ((t) == ns_t_tsig || (t) == ns_t_opt) +/* Exclusively an RTYPE? (not also a QTYPE or a meta-RR) */ +#define ns_t_rr_p(t) (!ns_t_qt_p(t) && !ns_t_mrr_p(t)) +#define ns_t_udp_p(t) ((t) != ns_t_axfr && (t) != ns_t_zxfr) +#define ns_t_xfr_p(t) ((t) == ns_t_axfr || (t) == ns_t_ixfr || \ + (t) == ns_t_zxfr) + +/* + * Values for class field + */ +typedef enum __ns_class { + ns_c_invalid = 0, /* Cookie. */ + ns_c_in = 1, /* Internet. */ + ns_c_2 = 2, /* unallocated/unsupported. */ + ns_c_chaos = 3, /* MIT Chaos-net. */ + ns_c_hs = 4, /* MIT Hesiod. */ + /* Query class values which do not appear in resource records */ + ns_c_none = 254, /* for prereq. sections in update requests */ + ns_c_any = 255, /* Wildcard match. */ + ns_c_max = 65536 +} ns_class; + +/* DNSSEC constants. */ + +typedef enum __ns_key_types { + ns_kt_rsa = 1, /* key type RSA/MD5 */ + ns_kt_dh = 2, /* Diffie Hellman */ + ns_kt_dsa = 3, /* Digital Signature Standard (MANDATORY) */ + ns_kt_private = 254 /* Private key type starts with OID */ +} ns_key_types; + +typedef enum __ns_cert_types { + cert_t_pkix = 1, /* PKIX (X.509v3) */ + cert_t_spki = 2, /* SPKI */ + cert_t_pgp = 3, /* PGP */ + cert_t_url = 253, /* URL private type */ + cert_t_oid = 254 /* OID private type */ +} ns_cert_types; + +/* Flags field of the KEY RR rdata. */ +#define NS_KEY_TYPEMASK 0xC000 /* Mask for "type" bits */ +#define NS_KEY_TYPE_AUTH_CONF 0x0000 /* Key usable for both */ +#define NS_KEY_TYPE_CONF_ONLY 0x8000 /* Key usable for confidentiality */ +#define NS_KEY_TYPE_AUTH_ONLY 0x4000 /* Key usable for authentication */ +#define NS_KEY_TYPE_NO_KEY 0xC000 /* No key usable for either; no key */ +/* The type bits can also be interpreted independently, as single bits: */ +#define NS_KEY_NO_AUTH 0x8000 /* Key unusable for authentication */ +#define NS_KEY_NO_CONF 0x4000 /* Key unusable for confidentiality */ +#define NS_KEY_RESERVED2 0x2000 /* Security is *mandatory* if bit=0 */ +#define NS_KEY_EXTENDED_FLAGS 0x1000 /* reserved - must be zero */ +#define NS_KEY_RESERVED4 0x0800 /* reserved - must be zero */ +#define NS_KEY_RESERVED5 0x0400 /* reserved - must be zero */ +#define NS_KEY_NAME_TYPE 0x0300 /* these bits determine the type */ +#define NS_KEY_NAME_USER 0x0000 /* key is assoc. with user */ +#define NS_KEY_NAME_ENTITY 0x0200 /* key is assoc. with entity eg host */ +#define NS_KEY_NAME_ZONE 0x0100 /* key is zone key */ +#define NS_KEY_NAME_RESERVED 0x0300 /* reserved meaning */ +#define NS_KEY_RESERVED8 0x0080 /* reserved - must be zero */ +#define NS_KEY_RESERVED9 0x0040 /* reserved - must be zero */ +#define NS_KEY_RESERVED10 0x0020 /* reserved - must be zero */ +#define NS_KEY_RESERVED11 0x0010 /* reserved - must be zero */ +#define NS_KEY_SIGNATORYMASK 0x000F /* key can sign RR's of same name */ +#define NS_KEY_RESERVED_BITMASK ( NS_KEY_RESERVED2 | \ + NS_KEY_RESERVED4 | \ + NS_KEY_RESERVED5 | \ + NS_KEY_RESERVED8 | \ + NS_KEY_RESERVED9 | \ + NS_KEY_RESERVED10 | \ + NS_KEY_RESERVED11 ) +#define NS_KEY_RESERVED_BITMASK2 0xFFFF /* no bits defined here */ + +/* The Algorithm field of the KEY and SIG RR's is an integer, {1..254} */ +#define NS_ALG_MD5RSA 1 /* MD5 with RSA */ +#define NS_ALG_DH 2 /* Diffie Hellman KEY */ +#define NS_ALG_DSA 3 /* DSA KEY */ +#define NS_ALG_DSS NS_ALG_DSA +#define NS_ALG_EXPIRE_ONLY 253 /* No alg, no security */ +#define NS_ALG_PRIVATE_OID 254 /* Key begins with OID giving alg */ + +/* Protocol values */ +/* value 0 is reserved */ +#define NS_KEY_PROT_TLS 1 +#define NS_KEY_PROT_EMAIL 2 +#define NS_KEY_PROT_DNSSEC 3 +#define NS_KEY_PROT_IPSEC 4 +#define NS_KEY_PROT_ANY 255 + +/* Signatures */ +#define NS_MD5RSA_MIN_BITS 512 /* Size of a mod or exp in bits */ +#define NS_MD5RSA_MAX_BITS 4096 + /* Total of binary mod and exp */ +#define NS_MD5RSA_MAX_BYTES ((NS_MD5RSA_MAX_BITS+7/8)*2+3) + /* Max length of text sig block */ +#define NS_MD5RSA_MAX_BASE64 (((NS_MD5RSA_MAX_BYTES+2)/3)*4) +#define NS_MD5RSA_MIN_SIZE ((NS_MD5RSA_MIN_BITS+7)/8) +#define NS_MD5RSA_MAX_SIZE ((NS_MD5RSA_MAX_BITS+7)/8) + +#define NS_DSA_SIG_SIZE 41 +#define NS_DSA_MIN_SIZE 213 +#define NS_DSA_MAX_BYTES 405 + +/* Offsets into SIG record rdata to find various values */ +#define NS_SIG_TYPE 0 /* Type flags */ +#define NS_SIG_ALG 2 /* Algorithm */ +#define NS_SIG_LABELS 3 /* How many labels in name */ +#define NS_SIG_OTTL 4 /* Original TTL */ +#define NS_SIG_EXPIR 8 /* Expiration time */ +#define NS_SIG_SIGNED 12 /* Signature time */ +#define NS_SIG_FOOT 16 /* Key footprint */ +#define NS_SIG_SIGNER 18 /* Domain name of who signed it */ + +/* How RR types are represented as bit-flags in NXT records */ +#define NS_NXT_BITS 8 +#define NS_NXT_BIT_SET( n,p) (p[(n)/NS_NXT_BITS] |= (0x80>>((n)%NS_NXT_BITS))) +#define NS_NXT_BIT_CLEAR(n,p) (p[(n)/NS_NXT_BITS] &= ~(0x80>>((n)%NS_NXT_BITS))) +#define NS_NXT_BIT_ISSET(n,p) (p[(n)/NS_NXT_BITS] & (0x80>>((n)%NS_NXT_BITS))) +#define NS_NXT_MAX 127 + +/* + * EDNS0 extended flags and option codes, host order. + */ +#define NS_OPT_DNSSEC_OK 0x8000U +#define NS_OPT_NSID 3 + +/* + * Inline versions of get/put short/long. Pointer is advanced. + */ +#define NS_GET16(s, cp) do { \ + const u_char *t_cp = (const u_char *)(cp); \ + (s) = ((uint16_t)t_cp[0] << 8) \ + | ((uint16_t)t_cp[1]) \ + ; \ + (cp) += NS_INT16SZ; \ +} while (/*CONSTCOND*/0) + +#define NS_GET32(l, cp) do { \ + const u_char *t_cp = (const u_char *)(cp); \ + (l) = ((uint32_t)t_cp[0] << 24) \ + | ((uint32_t)t_cp[1] << 16) \ + | ((uint32_t)t_cp[2] << 8) \ + | ((uint32_t)t_cp[3]) \ + ; \ + (cp) += NS_INT32SZ; \ +} while (/*CONSTCOND*/0) + +#define NS_PUT16(s, cp) do { \ + uint32_t t_s = (uint32_t)(s); \ + u_char *t_cp = (u_char *)(cp); \ + *t_cp++ = t_s >> 8; \ + *t_cp = t_s; \ + (cp) += NS_INT16SZ; \ +} while (/*CONSTCOND*/0) + +#define NS_PUT32(l, cp) do { \ + uint32_t t_l = (uint32_t)(l); \ + u_char *t_cp = (u_char *)(cp); \ + *t_cp++ = t_l >> 24; \ + *t_cp++ = t_l >> 16; \ + *t_cp++ = t_l >> 8; \ + *t_cp = t_l; \ + (cp) += NS_INT32SZ; \ +} while (/*CONSTCOND*/0) + +__BEGIN_DECLS + +#if !defined(__LP64__) +/* Annoyingly, LP32 shipped with __ names. */ +#define ns_msg_getflag __ns_msg_getflag +#define ns_get16 __ns_get16 +#define ns_get32 __ns_get32 +#define ns_put16 __ns_put16 +#define ns_put32 __ns_put32 +#define ns_initparse __ns_initparse +#define ns_skiprr __ns_skiprr +#define ns_parserr __ns_parserr +#define ns_parserr2 __ns_parserr2 +#define ns_sprintrr __ns_sprintrr +#define ns_sprintrrf __ns_sprintrrf +#define ns_format_ttl __ns_format_ttl +#define ns_parse_ttl __ns_parse_ttl +#define ns_datetosecs __ns_datetosecs +#define ns_name_ntol __ns_name_ntol +#define ns_name_ntop __ns_name_ntop +#define ns_name_pton __ns_name_pton +#define ns_name_pton2 __ns_name_pton2 +#define ns_name_unpack __ns_name_unpack +#define ns_name_unpack2 __ns_name_unpack2 +#define ns_name_pack __ns_name_pack +#define ns_name_compress __ns_name_compress +#define ns_name_uncompress __ns_name_uncompress +#define ns_name_skip __ns_name_skip +#define ns_name_rollback __ns_name_rollback +#define ns_name_length __ns_name_length +#define ns_name_eq __ns_name_eq +#define ns_name_owned __ns_name_owned +#define ns_name_map __ns_name_map +#define ns_name_labels __ns_name_labels +#define ns_sign __ns_sign +#define ns_sign2 __ns_sign2 +#define ns_sign_tcp __ns_sign_tcp +#define ns_sign_tcp2 __ns_sign_tcp2 +#define ns_sign_tcp_init __ns_sign_tcp_init +#define ns_find_tsig __ns_find_tsig +#define ns_verify __ns_verify +#define ns_verify_tcp __ns_verify_tcp +#define ns_verify_tcp_init __ns_verify_tcp_init +#define ns_samedomain __ns_samedomain +#define ns_subdomain __ns_subdomain +#define ns_makecanon __ns_makecanon +#define ns_samename __ns_samename + +int ns_msg_getflag(ns_msg, int); +uint16_t ns_get16(const u_char*); +uint32_t ns_get32(const u_char*); +void ns_put16(uint16_t, u_char*); +void ns_put32(uint32_t, u_char*); +int ns_initparse(const u_char*, int, ns_msg*); +int ns_skiprr(const u_char*, const u_char*, ns_sect, int); +int ns_parserr(ns_msg*, ns_sect, int, ns_rr*); +int ns_sprintrr(const ns_msg*, const ns_rr*, const char*, const char*, char*, size_t); +int ns_sprintrrf(const u_char*, size_t, const char*, ns_class, ns_type, u_long, const u_char*, + size_t, const char*, const char*, char*, size_t); +int ns_format_ttl(u_long, char*, size_t); +int ns_name_ntol(const u_char*, u_char*, size_t); +int ns_name_ntop(const u_char*, char*, size_t); +int ns_name_pton(const char*, u_char*, size_t); +int ns_name_unpack(const u_char*, const u_char*, const u_char*, u_char*, size_t); +int ns_name_pack(const u_char*, u_char*, int, const u_char**, const u_char**); +int ns_name_uncompress(const u_char*, const u_char*, const u_char*, char*, size_t); +int ns_name_compress(const char*, u_char*, size_t, const u_char**, const u_char**); +int ns_name_skip(const u_char**, const u_char*); +void ns_name_rollback(const u_char*, const u_char**, const u_char**); + +int ns_makecanon(const char*, char*, size_t); +int ns_samename(const char*, const char*); + +#else +/* The names of these symbols were accidentally prefixed with __ in L. */ +/* The duplication here is intentional to avoid declaring different symbols with the same + * declaration. */ + +#if (!defined(__LP64__)) || (defined(__LP64__) && __ANDROID_API__ >= 23) +int ns_msg_getflag(ns_msg, int) __INTRODUCED_IN_64(23); +uint16_t ns_get16(const u_char*) __INTRODUCED_IN_64(23); +uint32_t ns_get32(const u_char*) __INTRODUCED_IN_64(23); +void ns_put16(uint16_t, u_char*) __INTRODUCED_IN_64(23); +void ns_put32(uint32_t, u_char*) __INTRODUCED_IN_64(23); +int ns_initparse(const u_char*, int, ns_msg*) __INTRODUCED_IN_64(23); +int ns_skiprr(const u_char*, const u_char*, ns_sect, int) __INTRODUCED_IN_64(23); +int ns_parserr(ns_msg*, ns_sect, int, ns_rr*) __INTRODUCED_IN_64(23); +int ns_sprintrr(const ns_msg*, const ns_rr*, const char*, const char*, char*, size_t) + __INTRODUCED_IN_64(23); +int ns_sprintrrf(const u_char*, size_t, const char*, ns_class, ns_type, u_long, const u_char*, + size_t, const char*, const char*, char*, size_t) __INTRODUCED_IN_64(23); +int ns_format_ttl(u_long, char*, size_t) __INTRODUCED_IN_64(23); +int ns_name_ntol(const u_char*, u_char*, size_t) __INTRODUCED_IN_64(23); +int ns_name_ntop(const u_char*, char*, size_t) __INTRODUCED_IN_64(23); +int ns_name_pton(const char*, u_char*, size_t) __INTRODUCED_IN_64(23); +int ns_name_unpack(const u_char*, const u_char*, const u_char*, u_char*, size_t) + __INTRODUCED_IN_64(23); +int ns_name_pack(const u_char*, u_char*, int, const u_char**, const u_char**) __INTRODUCED_IN_64(23); +int ns_name_uncompress(const u_char*, const u_char*, const u_char*, char*, size_t) + __INTRODUCED_IN_64(23); +int ns_name_compress(const char*, u_char*, size_t, const u_char**, const u_char**) + __INTRODUCED_IN_64(23); +int ns_name_skip(const u_char**, const u_char*) __INTRODUCED_IN_64(23); +void ns_name_rollback(const u_char*, const u_char**, const u_char**) __INTRODUCED_IN_64(23); + +int ns_makecanon(const char*, char*, size_t) __INTRODUCED_IN_64(23); +int ns_samename(const char*, const char*) __INTRODUCED_IN_64(23); +#endif /* (!defined(__LP64__)) || (defined(__LP64__) && __ANDROID_API__ >= 23) */ + +#endif /* !defined(__LP64__) */ + +__END_DECLS + +#ifdef BIND_4_COMPAT +#include <arpa/nameser_compat.h> +#endif + +#endif /* !_ARPA_NAMESER_H_ */ diff --git a/headers/arpa/nameser_compat.h b/headers/arpa/nameser_compat.h new file mode 100644 index 000000000..e4e933507 --- /dev/null +++ b/headers/arpa/nameser_compat.h @@ -0,0 +1,176 @@ +/* $NetBSD: nameser_compat.h,v 1.1.1.2 2004/11/07 01:28:27 christos Exp $ */ + +/* Copyright (c) 1983, 1989 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * from nameser.h 8.1 (Berkeley) 6/2/93 + * Id: nameser_compat.h,v 1.8 2006/05/19 02:33:40 marka Exp + */ + +#ifndef _ARPA_NAMESER_COMPAT_ +#define _ARPA_NAMESER_COMPAT_ + +#include <endian.h> +#include <sys/cdefs.h> + +#define __BIND 19950621 /* (DEAD) interface version stamp. */ + +/* + * Structure for query header. The order of the fields is machine- and + * compiler-dependent, depending on the byte/bit order and the layout + * of bit fields. We use bit fields only in int variables, as this + * is all ANSI requires. This requires a somewhat confusing rearrangement. + */ + +typedef struct { + unsigned id :16; /* query identification number */ + /* fields in third byte */ + unsigned rd :1; /* recursion desired */ + unsigned tc :1; /* truncated message */ + unsigned aa :1; /* authoritive answer */ + unsigned opcode :4; /* purpose of message */ + unsigned qr :1; /* response flag */ + /* fields in fourth byte */ + unsigned rcode :4; /* response code */ + unsigned cd: 1; /* checking disabled by resolver */ + unsigned ad: 1; /* authentic data from named */ + unsigned unused :1; /* unused bits (MBZ as of 4.9.3a3) */ + unsigned ra :1; /* recursion available */ + /* remaining bytes */ + unsigned qdcount :16; /* number of question entries */ + unsigned ancount :16; /* number of answer entries */ + unsigned nscount :16; /* number of authority entries */ + unsigned arcount :16; /* number of resource entries */ +} HEADER; + +#define PACKETSZ NS_PACKETSZ +#define MAXDNAME NS_MAXDNAME +#define MAXCDNAME NS_MAXCDNAME +#define MAXLABEL NS_MAXLABEL +#define HFIXEDSZ NS_HFIXEDSZ +#define QFIXEDSZ NS_QFIXEDSZ +#define RRFIXEDSZ NS_RRFIXEDSZ +#define INT32SZ NS_INT32SZ +#define INT16SZ NS_INT16SZ +#define INT8SZ NS_INT8SZ +#define INADDRSZ NS_INADDRSZ +#define IN6ADDRSZ NS_IN6ADDRSZ +#define INDIR_MASK NS_CMPRSFLGS +#define NAMESERVER_PORT NS_DEFAULTPORT + +#define S_ZONE ns_s_zn +#define S_PREREQ ns_s_pr +#define S_UPDATE ns_s_ud +#define S_ADDT ns_s_ar + +#define QUERY ns_o_query +#define IQUERY ns_o_iquery +#define STATUS ns_o_status +#define NS_NOTIFY_OP ns_o_notify +#define NS_UPDATE_OP ns_o_update + +#define NOERROR ns_r_noerror +#define FORMERR ns_r_formerr +#define SERVFAIL ns_r_servfail +#define NXDOMAIN ns_r_nxdomain +#define NOTIMP ns_r_notimpl +#define REFUSED ns_r_refused +#define YXDOMAIN ns_r_yxdomain +#define YXRRSET ns_r_yxrrset +#define NXRRSET ns_r_nxrrset +#define NOTAUTH ns_r_notauth +#define NOTZONE ns_r_notzone +/*#define BADSIG ns_r_badsig*/ +/*#define BADKEY ns_r_badkey*/ +/*#define BADTIME ns_r_badtime*/ + + +#define DELETE ns_uop_delete +#define ADD ns_uop_add + +#define T_A ns_t_a +#define T_NS ns_t_ns +#define T_MD ns_t_md +#define T_MF ns_t_mf +#define T_CNAME ns_t_cname +#define T_SOA ns_t_soa +#define T_MB ns_t_mb +#define T_MG ns_t_mg +#define T_MR ns_t_mr +#define T_NULL ns_t_null +#define T_WKS ns_t_wks +#define T_PTR ns_t_ptr +#define T_HINFO ns_t_hinfo +#define T_MINFO ns_t_minfo +#define T_MX ns_t_mx +#define T_TXT ns_t_txt +#define T_RP ns_t_rp +#define T_AFSDB ns_t_afsdb +#define T_X25 ns_t_x25 +#define T_ISDN ns_t_isdn +#define T_RT ns_t_rt +#define T_NSAP ns_t_nsap +#define T_NSAP_PTR ns_t_nsap_ptr +#define T_SIG ns_t_sig +#define T_KEY ns_t_key +#define T_PX ns_t_px +#define T_GPOS ns_t_gpos +#define T_AAAA ns_t_aaaa +#define T_LOC ns_t_loc +#define T_NXT ns_t_nxt +#define T_EID ns_t_eid +#define T_NIMLOC ns_t_nimloc +#define T_SRV ns_t_srv +#define T_ATMA ns_t_atma +#define T_NAPTR ns_t_naptr +#define T_A6 ns_t_a6 +#define T_TSIG ns_t_tsig +#define T_IXFR ns_t_ixfr +#define T_AXFR ns_t_axfr +#define T_MAILB ns_t_mailb +#define T_MAILA ns_t_maila +#define T_ANY ns_t_any + +#define C_IN ns_c_in +#define C_CHAOS ns_c_chaos +#define C_HS ns_c_hs +/* BIND_UPDATE */ +#define C_NONE ns_c_none +#define C_ANY ns_c_any + +#define GETSHORT NS_GET16 +#define GETLONG NS_GET32 +#define PUTSHORT NS_PUT16 +#define PUTLONG NS_PUT32 + +#endif /* _ARPA_NAMESER_COMPAT_ */ diff --git a/headers/arpa/telnet.h b/headers/arpa/telnet.h new file mode 100644 index 000000000..594dc7a70 --- /dev/null +++ b/headers/arpa/telnet.h @@ -0,0 +1,309 @@ +/* + * Copyright (c) 1983, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)telnet.h 8.2 (Berkeley) 12/15/93 + */ + +#ifndef _ARPA_TELNET_H +#define _ARPA_TELNET_H 1 + +#include <sys/cdefs.h> + +/* + * Definitions for the TELNET protocol. + */ +#define IAC 255 /* interpret as command: */ +#define DONT 254 /* you are not to use option */ +#define DO 253 /* please, you use option */ +#define WONT 252 /* I won't use option */ +#define WILL 251 /* I will use option */ +#define SB 250 /* interpret as subnegotiation */ +#define GA 249 /* you may reverse the line */ +#define EL 248 /* erase the current line */ +#define EC 247 /* erase the current character */ +#define AYT 246 /* are you there */ +#define AO 245 /* abort output--but let prog finish */ +#define IP 244 /* interrupt process--permanently */ +#define BREAK 243 /* break */ +#define DM 242 /* data mark--for connect. cleaning */ +#define NOP 241 /* nop */ +#define SE 240 /* end sub negotiation */ +#define EOR 239 /* end of record (transparent mode) */ +#define ABORT 238 /* Abort process */ +#define SUSP 237 /* Suspend process */ +#define xEOF 236 /* End of file: EOF is already used... */ + +#define SYNCH 242 /* for telfunc calls */ + +#ifdef TELCMDS +char *telcmds[] = { + "EOF", "SUSP", "ABORT", "EOR", + "SE", "NOP", "DMARK", "BRK", "IP", "AO", "AYT", "EC", + "EL", "GA", "SB", "WILL", "WONT", "DO", "DONT", "IAC", 0, +}; +#endif + +#define TELCMD_FIRST xEOF +#define TELCMD_LAST IAC +#define TELCMD_OK(x) ((unsigned int)(x) <= TELCMD_LAST && \ + (unsigned int)(x) >= TELCMD_FIRST) +#define TELCMD(x) telcmds[(x)-TELCMD_FIRST] + +/* telnet options */ +#define TELOPT_BINARY 0 /* 8-bit data path */ +#define TELOPT_ECHO 1 /* echo */ +#define TELOPT_RCP 2 /* prepare to reconnect */ +#define TELOPT_SGA 3 /* suppress go ahead */ +#define TELOPT_NAMS 4 /* approximate message size */ +#define TELOPT_STATUS 5 /* give status */ +#define TELOPT_TM 6 /* timing mark */ +#define TELOPT_RCTE 7 /* remote controlled transmission and echo */ +#define TELOPT_NAOL 8 /* negotiate about output line width */ +#define TELOPT_NAOP 9 /* negotiate about output page size */ +#define TELOPT_NAOCRD 10 /* negotiate about CR disposition */ +#define TELOPT_NAOHTS 11 /* negotiate about horizontal tabstops */ +#define TELOPT_NAOHTD 12 /* negotiate about horizontal tab disposition */ +#define TELOPT_NAOFFD 13 /* negotiate about formfeed disposition */ +#define TELOPT_NAOVTS 14 /* negotiate about vertical tab stops */ +#define TELOPT_NAOVTD 15 /* negotiate about vertical tab disposition */ +#define TELOPT_NAOLFD 16 /* negotiate about output LF disposition */ +#define TELOPT_XASCII 17 /* extended ascii character set */ +#define TELOPT_LOGOUT 18 /* force logout */ +#define TELOPT_BM 19 /* byte macro */ +#define TELOPT_DET 20 /* data entry terminal */ +#define TELOPT_SUPDUP 21 /* supdup protocol */ +#define TELOPT_SUPDUPOUTPUT 22 /* supdup output */ +#define TELOPT_SNDLOC 23 /* send location */ +#define TELOPT_TTYPE 24 /* terminal type */ +#define TELOPT_EOR 25 /* end or record */ +#define TELOPT_TUID 26 /* TACACS user identification */ +#define TELOPT_OUTMRK 27 /* output marking */ +#define TELOPT_TTYLOC 28 /* terminal location number */ +#define TELOPT_3270REGIME 29 /* 3270 regime */ +#define TELOPT_X3PAD 30 /* X.3 PAD */ +#define TELOPT_NAWS 31 /* window size */ +#define TELOPT_TSPEED 32 /* terminal speed */ +#define TELOPT_LFLOW 33 /* remote flow control */ +#define TELOPT_LINEMODE 34 /* Linemode option */ +#define TELOPT_XDISPLOC 35 /* X Display Location */ +#define TELOPT_OLD_ENVIRON 36 /* Old - Environment variables */ +#define TELOPT_AUTHENTICATION 37/* Authenticate */ +#define TELOPT_ENCRYPT 38 /* Encryption option */ +#define TELOPT_NEW_ENVIRON 39 /* New - Environment variables */ +#define TELOPT_EXOPL 255 /* extended-options-list */ + + +#define NTELOPTS (1+TELOPT_NEW_ENVIRON) +#ifdef TELOPTS +const char *telopts[NTELOPTS+1] = { + "BINARY", "ECHO", "RCP", "SUPPRESS GO AHEAD", "NAME", + "STATUS", "TIMING MARK", "RCTE", "NAOL", "NAOP", + "NAOCRD", "NAOHTS", "NAOHTD", "NAOFFD", "NAOVTS", + "NAOVTD", "NAOLFD", "EXTEND ASCII", "LOGOUT", "BYTE MACRO", + "DATA ENTRY TERMINAL", "SUPDUP", "SUPDUP OUTPUT", + "SEND LOCATION", "TERMINAL TYPE", "END OF RECORD", + "TACACS UID", "OUTPUT MARKING", "TTYLOC", + "3270 REGIME", "X.3 PAD", "NAWS", "TSPEED", "LFLOW", + "LINEMODE", "XDISPLOC", "OLD-ENVIRON", "AUTHENTICATION", + "ENCRYPT", "NEW-ENVIRON", + 0, +}; +#define TELOPT_FIRST TELOPT_BINARY +#define TELOPT_LAST TELOPT_NEW_ENVIRON +#define TELOPT_OK(x) ((unsigned int)(x) <= TELOPT_LAST) +#define TELOPT(x) telopts[(x)-TELOPT_FIRST] +#endif + +/* sub-option qualifiers */ +#define TELQUAL_IS 0 /* option is... */ +#define TELQUAL_SEND 1 /* send option */ +#define TELQUAL_INFO 2 /* ENVIRON: informational version of IS */ +#define TELQUAL_REPLY 2 /* AUTHENTICATION: client version of IS */ +#define TELQUAL_NAME 3 /* AUTHENTICATION: client version of IS */ + +#define LFLOW_OFF 0 /* Disable remote flow control */ +#define LFLOW_ON 1 /* Enable remote flow control */ +#define LFLOW_RESTART_ANY 2 /* Restart output on any char */ +#define LFLOW_RESTART_XON 3 /* Restart output only on XON */ + +/* + * LINEMODE suboptions + */ + +#define LM_MODE 1 +#define LM_FORWARDMASK 2 +#define LM_SLC 3 + +#define MODE_EDIT 0x01 +#define MODE_TRAPSIG 0x02 +#define MODE_ACK 0x04 +#define MODE_SOFT_TAB 0x08 +#define MODE_LIT_ECHO 0x10 + +#define MODE_MASK 0x1f + +/* Not part of protocol, but needed to simplify things... */ +#define MODE_FLOW 0x0100 +#define MODE_ECHO 0x0200 +#define MODE_INBIN 0x0400 +#define MODE_OUTBIN 0x0800 +#define MODE_FORCE 0x1000 + +#define SLC_SYNCH 1 +#define SLC_BRK 2 +#define SLC_IP 3 +#define SLC_AO 4 +#define SLC_AYT 5 +#define SLC_EOR 6 +#define SLC_ABORT 7 +#define SLC_EOF 8 +#define SLC_SUSP 9 +#define SLC_EC 10 +#define SLC_EL 11 +#define SLC_EW 12 +#define SLC_RP 13 +#define SLC_LNEXT 14 +#define SLC_XON 15 +#define SLC_XOFF 16 +#define SLC_FORW1 17 +#define SLC_FORW2 18 + +#define NSLC 18 + +/* + * For backwards compatibility, we define SLC_NAMES to be the + * list of names if SLC_NAMES is not defined. + */ +#define SLC_NAMELIST "0", "SYNCH", "BRK", "IP", "AO", "AYT", "EOR", \ + "ABORT", "EOF", "SUSP", "EC", "EL", "EW", "RP", \ + "LNEXT", "XON", "XOFF", "FORW1", "FORW2", 0, +#ifdef SLC_NAMES +const char *slc_names[] = { + SLC_NAMELIST +}; +#define SLC_NAMES SLC_NAMELIST +#endif + +#define SLC_NAME_OK(x) ((unsigned int)(x) <= NSLC) +#define SLC_NAME(x) slc_names[x] + +#define SLC_NOSUPPORT 0 +#define SLC_CANTCHANGE 1 +#define SLC_VARIABLE 2 +#define SLC_DEFAULT 3 +#define SLC_LEVELBITS 0x03 + +#define SLC_FUNC 0 +#define SLC_FLAGS 1 +#define SLC_VALUE 2 + +#define SLC_ACK 0x80 +#define SLC_FLUSHIN 0x40 +#define SLC_FLUSHOUT 0x20 + +#define OLD_ENV_VAR 1 +#define OLD_ENV_VALUE 0 +#define NEW_ENV_VAR 0 +#define NEW_ENV_VALUE 1 +#define ENV_ESC 2 +#define ENV_USERVAR 3 + +/* + * AUTHENTICATION suboptions + */ + +/* + * Who is authenticating who ... + */ +#define AUTH_WHO_CLIENT 0 /* Client authenticating server */ +#define AUTH_WHO_SERVER 1 /* Server authenticating client */ +#define AUTH_WHO_MASK 1 + +/* + * amount of authentication done + */ +#define AUTH_HOW_ONE_WAY 0 +#define AUTH_HOW_MUTUAL 2 +#define AUTH_HOW_MASK 2 + +#define AUTHTYPE_NULL 0 +#define AUTHTYPE_KERBEROS_V4 1 +#define AUTHTYPE_KERBEROS_V5 2 +#define AUTHTYPE_SPX 3 +#define AUTHTYPE_MINK 4 +#define AUTHTYPE_CNT 5 + +#define AUTHTYPE_TEST 99 + +#ifdef AUTH_NAMES +const char *authtype_names[] = { + "NULL", "KERBEROS_V4", "KERBEROS_V5", "SPX", "MINK", 0, +}; +#endif + +#define AUTHTYPE_NAME_OK(x) ((unsigned int)(x) < AUTHTYPE_CNT) +#define AUTHTYPE_NAME(x) authtype_names[x] + +/* + * ENCRYPTion suboptions + */ +#define ENCRYPT_IS 0 /* I pick encryption type ... */ +#define ENCRYPT_SUPPORT 1 /* I support encryption types ... */ +#define ENCRYPT_REPLY 2 /* Initial setup response */ +#define ENCRYPT_START 3 /* Am starting to send encrypted */ +#define ENCRYPT_END 4 /* Am ending encrypted */ +#define ENCRYPT_REQSTART 5 /* Request you start encrypting */ +#define ENCRYPT_REQEND 6 /* Request you send encrypting */ +#define ENCRYPT_ENC_KEYID 7 +#define ENCRYPT_DEC_KEYID 8 +#define ENCRYPT_CNT 9 + +#define ENCTYPE_ANY 0 +#define ENCTYPE_DES_CFB64 1 +#define ENCTYPE_DES_OFB64 2 +#define ENCTYPE_CNT 3 + +#ifdef ENCRYPT_NAMES +const char *encrypt_names[] = { + "IS", "SUPPORT", "REPLY", "START", "END", + "REQUEST-START", "REQUEST-END", "ENC-KEYID", "DEC-KEYID", + 0, +}; +const char *enctype_names[] = { + "ANY", "DES_CFB64", "DES_OFB64", 0, +}; +#endif + + +#define ENCRYPT_NAME_OK(x) ((unsigned int)(x) < ENCRYPT_CNT) +#define ENCRYPT_NAME(x) encrypt_names[x] + +#define ENCTYPE_NAME_OK(x) ((unsigned int)(x) < ENCTYPE_CNT) +#define ENCTYPE_NAME(x) enctype_names[x] + +#endif /* arpa/telnet.h */ diff --git a/headers/assert.h b/headers/assert.h new file mode 100644 index 000000000..8c456ef7c --- /dev/null +++ b/headers/assert.h @@ -0,0 +1,65 @@ +/*- + * Copyright (c) 1992, 1993 + * The Regents of the University of California. All rights reserved. + * (c) UNIX System Laboratories, Inc. + * All or some portions of this file are derived from material licensed + * to the University of California by American Telephone and Telegraph + * Co. or Unix System Laboratories, Inc. and are reproduced herein with + * the permission of UNIX System Laboratories, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * There's no include guard in this file because <assert.h> may usefully be + * included multiple times, with and without NDEBUG defined. + */ + +#include <sys/cdefs.h> + +#undef assert +#undef __assert_no_op + +#define __assert_no_op __BIONIC_CAST(static_cast, void, 0) + +#ifdef NDEBUG +# define assert(e) __assert_no_op +#else +# if defined(__cplusplus) || __STDC_VERSION__ >= 199901L +# define assert(e) ((e) ? __assert_no_op : __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, #e)) +# else +# define assert(e) ((e) ? __assert_no_op : __assert(__FILE__, __LINE__, #e)) +# endif +#endif + +#if !defined(__cplusplus) && __STDC_VERSION__ >= 201112L +# undef static_assert +# define static_assert _Static_assert +#endif + +__BEGIN_DECLS +void __assert(const char*, int, const char*) __noreturn; +void __assert2(const char*, int, const char*, const char*) __noreturn; +__END_DECLS diff --git a/headers/bits/fcntl.h b/headers/bits/fcntl.h new file mode 100644 index 000000000..604d35a3f --- /dev/null +++ b/headers/bits/fcntl.h @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _BITS_FCNTL_H_ +#define _BITS_FCNTL_H_ + +#include <sys/cdefs.h> + +__BEGIN_DECLS + +int fcntl(int, int, ...); + +__END_DECLS + +#endif diff --git a/headers/bits/getopt.h b/headers/bits/getopt.h new file mode 100644 index 000000000..7153d483c --- /dev/null +++ b/headers/bits/getopt.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _BITS_GETOPT_H_ +#define _BITS_GETOPT_H_ + +#include <sys/cdefs.h> + +__BEGIN_DECLS + +int getopt(int, char * const [], const char *); + +extern char *optarg; /* getopt(3) external variables */ +extern int optind, opterr, optopt; + +__END_DECLS + +#endif diff --git a/headers/bits/glibc-syscalls.h b/headers/bits/glibc-syscalls.h new file mode 100644 index 000000000..3191a23c4 --- /dev/null +++ b/headers/bits/glibc-syscalls.h @@ -0,0 +1,1243 @@ +/* Generated by gensyscalls.py. Do not edit. */ +#ifndef _BIONIC_BITS_GLIBC_SYSCALLS_H_ +#define _BIONIC_BITS_GLIBC_SYSCALLS_H_ +#if defined(__NR_accept) + #define SYS_accept __NR_accept +#endif +#if defined(__NR_accept4) + #define SYS_accept4 __NR_accept4 +#endif +#if defined(__NR_access) + #define SYS_access __NR_access +#endif +#if defined(__NR_acct) + #define SYS_acct __NR_acct +#endif +#if defined(__NR_add_key) + #define SYS_add_key __NR_add_key +#endif +#if defined(__NR_adjtimex) + #define SYS_adjtimex __NR_adjtimex +#endif +#if defined(__NR_afs_syscall) + #define SYS_afs_syscall __NR_afs_syscall +#endif +#if defined(__NR_alarm) + #define SYS_alarm __NR_alarm +#endif +#if defined(__NR_arch_prctl) + #define SYS_arch_prctl __NR_arch_prctl +#endif +#if defined(__NR_arch_specific_syscall) + #define SYS_arch_specific_syscall __NR_arch_specific_syscall +#endif +#if defined(__NR_arm_fadvise64_64) + #define SYS_arm_fadvise64_64 __NR_arm_fadvise64_64 +#endif +#if defined(__NR_arm_sync_file_range) + #define SYS_arm_sync_file_range __NR_arm_sync_file_range +#endif +#if defined(__NR_bdflush) + #define SYS_bdflush __NR_bdflush +#endif +#if defined(__NR_bind) + #define SYS_bind __NR_bind +#endif +#if defined(__NR_bpf) + #define SYS_bpf __NR_bpf +#endif +#if defined(__NR_break) + #define SYS_break __NR_break +#endif +#if defined(__NR_brk) + #define SYS_brk __NR_brk +#endif +#if defined(__NR_cachectl) + #define SYS_cachectl __NR_cachectl +#endif +#if defined(__NR_cacheflush) + #define SYS_cacheflush __NR_cacheflush +#endif +#if defined(__NR_capget) + #define SYS_capget __NR_capget +#endif +#if defined(__NR_capset) + #define SYS_capset __NR_capset +#endif +#if defined(__NR_chdir) + #define SYS_chdir __NR_chdir +#endif +#if defined(__NR_chmod) + #define SYS_chmod __NR_chmod +#endif +#if defined(__NR_chown) + #define SYS_chown __NR_chown +#endif +#if defined(__NR_chown32) + #define SYS_chown32 __NR_chown32 +#endif +#if defined(__NR_chroot) + #define SYS_chroot __NR_chroot +#endif +#if defined(__NR_clock_adjtime) + #define SYS_clock_adjtime __NR_clock_adjtime +#endif +#if defined(__NR_clock_getres) + #define SYS_clock_getres __NR_clock_getres +#endif +#if defined(__NR_clock_gettime) + #define SYS_clock_gettime __NR_clock_gettime +#endif +#if defined(__NR_clock_nanosleep) + #define SYS_clock_nanosleep __NR_clock_nanosleep +#endif +#if defined(__NR_clock_settime) + #define SYS_clock_settime __NR_clock_settime +#endif +#if defined(__NR_clone) + #define SYS_clone __NR_clone +#endif +#if defined(__NR_close) + #define SYS_close __NR_close +#endif +#if defined(__NR_connect) + #define SYS_connect __NR_connect +#endif +#if defined(__NR_copy_file_range) + #define SYS_copy_file_range __NR_copy_file_range +#endif +#if defined(__NR_creat) + #define SYS_creat __NR_creat +#endif +#if defined(__NR_create_module) + #define SYS_create_module __NR_create_module +#endif +#if defined(__NR_delete_module) + #define SYS_delete_module __NR_delete_module +#endif +#if defined(__NR_dup) + #define SYS_dup __NR_dup +#endif +#if defined(__NR_dup2) + #define SYS_dup2 __NR_dup2 +#endif +#if defined(__NR_dup3) + #define SYS_dup3 __NR_dup3 +#endif +#if defined(__NR_epoll_create) + #define SYS_epoll_create __NR_epoll_create +#endif +#if defined(__NR_epoll_create1) + #define SYS_epoll_create1 __NR_epoll_create1 +#endif +#if defined(__NR_epoll_ctl) + #define SYS_epoll_ctl __NR_epoll_ctl +#endif +#if defined(__NR_epoll_ctl_old) + #define SYS_epoll_ctl_old __NR_epoll_ctl_old +#endif +#if defined(__NR_epoll_pwait) + #define SYS_epoll_pwait __NR_epoll_pwait +#endif +#if defined(__NR_epoll_wait) + #define SYS_epoll_wait __NR_epoll_wait +#endif +#if defined(__NR_epoll_wait_old) + #define SYS_epoll_wait_old __NR_epoll_wait_old +#endif +#if defined(__NR_eventfd) + #define SYS_eventfd __NR_eventfd +#endif +#if defined(__NR_eventfd2) + #define SYS_eventfd2 __NR_eventfd2 +#endif +#if defined(__NR_execve) + #define SYS_execve __NR_execve +#endif +#if defined(__NR_execveat) + #define SYS_execveat __NR_execveat +#endif +#if defined(__NR_exit) + #define SYS_exit __NR_exit +#endif +#if defined(__NR_exit_group) + #define SYS_exit_group __NR_exit_group +#endif +#if defined(__NR_faccessat) + #define SYS_faccessat __NR_faccessat +#endif +#if defined(__NR_fadvise64) + #define SYS_fadvise64 __NR_fadvise64 +#endif +#if defined(__NR_fadvise64_64) + #define SYS_fadvise64_64 __NR_fadvise64_64 +#endif +#if defined(__NR_fallocate) + #define SYS_fallocate __NR_fallocate +#endif +#if defined(__NR_fanotify_init) + #define SYS_fanotify_init __NR_fanotify_init +#endif +#if defined(__NR_fanotify_mark) + #define SYS_fanotify_mark __NR_fanotify_mark +#endif +#if defined(__NR_fchdir) + #define SYS_fchdir __NR_fchdir +#endif +#if defined(__NR_fchmod) + #define SYS_fchmod __NR_fchmod +#endif +#if defined(__NR_fchmodat) + #define SYS_fchmodat __NR_fchmodat +#endif +#if defined(__NR_fchown) + #define SYS_fchown __NR_fchown +#endif +#if defined(__NR_fchown32) + #define SYS_fchown32 __NR_fchown32 +#endif +#if defined(__NR_fchownat) + #define SYS_fchownat __NR_fchownat +#endif +#if defined(__NR_fcntl) + #define SYS_fcntl __NR_fcntl +#endif +#if defined(__NR_fcntl64) + #define SYS_fcntl64 __NR_fcntl64 +#endif +#if defined(__NR_fdatasync) + #define SYS_fdatasync __NR_fdatasync +#endif +#if defined(__NR_fgetxattr) + #define SYS_fgetxattr __NR_fgetxattr +#endif +#if defined(__NR_finit_module) + #define SYS_finit_module __NR_finit_module +#endif +#if defined(__NR_flistxattr) + #define SYS_flistxattr __NR_flistxattr +#endif +#if defined(__NR_flock) + #define SYS_flock __NR_flock +#endif +#if defined(__NR_fork) + #define SYS_fork __NR_fork +#endif +#if defined(__NR_fremovexattr) + #define SYS_fremovexattr __NR_fremovexattr +#endif +#if defined(__NR_fsetxattr) + #define SYS_fsetxattr __NR_fsetxattr +#endif +#if defined(__NR_fstat) + #define SYS_fstat __NR_fstat +#endif +#if defined(__NR_fstat64) + #define SYS_fstat64 __NR_fstat64 +#endif +#if defined(__NR_fstatat64) + #define SYS_fstatat64 __NR_fstatat64 +#endif +#if defined(__NR_fstatfs) + #define SYS_fstatfs __NR_fstatfs +#endif +#if defined(__NR_fstatfs64) + #define SYS_fstatfs64 __NR_fstatfs64 +#endif +#if defined(__NR_fsync) + #define SYS_fsync __NR_fsync +#endif +#if defined(__NR_ftime) + #define SYS_ftime __NR_ftime +#endif +#if defined(__NR_ftruncate) + #define SYS_ftruncate __NR_ftruncate +#endif +#if defined(__NR_ftruncate64) + #define SYS_ftruncate64 __NR_ftruncate64 +#endif +#if defined(__NR_futex) + #define SYS_futex __NR_futex +#endif +#if defined(__NR_futimesat) + #define SYS_futimesat __NR_futimesat +#endif +#if defined(__NR_get_kernel_syms) + #define SYS_get_kernel_syms __NR_get_kernel_syms +#endif +#if defined(__NR_get_mempolicy) + #define SYS_get_mempolicy __NR_get_mempolicy +#endif +#if defined(__NR_get_robust_list) + #define SYS_get_robust_list __NR_get_robust_list +#endif +#if defined(__NR_get_thread_area) + #define SYS_get_thread_area __NR_get_thread_area +#endif +#if defined(__NR_getcpu) + #define SYS_getcpu __NR_getcpu +#endif +#if defined(__NR_getcwd) + #define SYS_getcwd __NR_getcwd +#endif +#if defined(__NR_getdents) + #define SYS_getdents __NR_getdents +#endif +#if defined(__NR_getdents64) + #define SYS_getdents64 __NR_getdents64 +#endif +#if defined(__NR_getegid) + #define SYS_getegid __NR_getegid +#endif +#if defined(__NR_getegid32) + #define SYS_getegid32 __NR_getegid32 +#endif +#if defined(__NR_geteuid) + #define SYS_geteuid __NR_geteuid +#endif +#if defined(__NR_geteuid32) + #define SYS_geteuid32 __NR_geteuid32 +#endif +#if defined(__NR_getgid) + #define SYS_getgid __NR_getgid +#endif +#if defined(__NR_getgid32) + #define SYS_getgid32 __NR_getgid32 +#endif +#if defined(__NR_getgroups) + #define SYS_getgroups __NR_getgroups +#endif +#if defined(__NR_getgroups32) + #define SYS_getgroups32 __NR_getgroups32 +#endif +#if defined(__NR_getitimer) + #define SYS_getitimer __NR_getitimer +#endif +#if defined(__NR_getpeername) + #define SYS_getpeername __NR_getpeername +#endif +#if defined(__NR_getpgid) + #define SYS_getpgid __NR_getpgid +#endif +#if defined(__NR_getpgrp) + #define SYS_getpgrp __NR_getpgrp +#endif +#if defined(__NR_getpid) + #define SYS_getpid __NR_getpid +#endif +#if defined(__NR_getpmsg) + #define SYS_getpmsg __NR_getpmsg +#endif +#if defined(__NR_getppid) + #define SYS_getppid __NR_getppid +#endif +#if defined(__NR_getpriority) + #define SYS_getpriority __NR_getpriority +#endif +#if defined(__NR_getrandom) + #define SYS_getrandom __NR_getrandom +#endif +#if defined(__NR_getresgid) + #define SYS_getresgid __NR_getresgid +#endif +#if defined(__NR_getresgid32) + #define SYS_getresgid32 __NR_getresgid32 +#endif +#if defined(__NR_getresuid) + #define SYS_getresuid __NR_getresuid +#endif +#if defined(__NR_getresuid32) + #define SYS_getresuid32 __NR_getresuid32 +#endif +#if defined(__NR_getrlimit) + #define SYS_getrlimit __NR_getrlimit +#endif +#if defined(__NR_getrusage) + #define SYS_getrusage __NR_getrusage +#endif +#if defined(__NR_getsid) + #define SYS_getsid __NR_getsid +#endif +#if defined(__NR_getsockname) + #define SYS_getsockname __NR_getsockname +#endif +#if defined(__NR_getsockopt) + #define SYS_getsockopt __NR_getsockopt +#endif +#if defined(__NR_gettid) + #define SYS_gettid __NR_gettid +#endif +#if defined(__NR_gettimeofday) + #define SYS_gettimeofday __NR_gettimeofday +#endif +#if defined(__NR_getuid) + #define SYS_getuid __NR_getuid +#endif +#if defined(__NR_getuid32) + #define SYS_getuid32 __NR_getuid32 +#endif +#if defined(__NR_getxattr) + #define SYS_getxattr __NR_getxattr +#endif +#if defined(__NR_gtty) + #define SYS_gtty __NR_gtty +#endif +#if defined(__NR_idle) + #define SYS_idle __NR_idle +#endif +#if defined(__NR_init_module) + #define SYS_init_module __NR_init_module +#endif +#if defined(__NR_inotify_add_watch) + #define SYS_inotify_add_watch __NR_inotify_add_watch +#endif +#if defined(__NR_inotify_init) + #define SYS_inotify_init __NR_inotify_init +#endif +#if defined(__NR_inotify_init1) + #define SYS_inotify_init1 __NR_inotify_init1 +#endif +#if defined(__NR_inotify_rm_watch) + #define SYS_inotify_rm_watch __NR_inotify_rm_watch +#endif +#if defined(__NR_io_cancel) + #define SYS_io_cancel __NR_io_cancel +#endif +#if defined(__NR_io_destroy) + #define SYS_io_destroy __NR_io_destroy +#endif +#if defined(__NR_io_getevents) + #define SYS_io_getevents __NR_io_getevents +#endif +#if defined(__NR_io_setup) + #define SYS_io_setup __NR_io_setup +#endif +#if defined(__NR_io_submit) + #define SYS_io_submit __NR_io_submit +#endif +#if defined(__NR_ioctl) + #define SYS_ioctl __NR_ioctl +#endif +#if defined(__NR_ioperm) + #define SYS_ioperm __NR_ioperm +#endif +#if defined(__NR_iopl) + #define SYS_iopl __NR_iopl +#endif +#if defined(__NR_ioprio_get) + #define SYS_ioprio_get __NR_ioprio_get +#endif +#if defined(__NR_ioprio_set) + #define SYS_ioprio_set __NR_ioprio_set +#endif +#if defined(__NR_ipc) + #define SYS_ipc __NR_ipc +#endif +#if defined(__NR_kcmp) + #define SYS_kcmp __NR_kcmp +#endif +#if defined(__NR_kexec_file_load) + #define SYS_kexec_file_load __NR_kexec_file_load +#endif +#if defined(__NR_kexec_load) + #define SYS_kexec_load __NR_kexec_load +#endif +#if defined(__NR_keyctl) + #define SYS_keyctl __NR_keyctl +#endif +#if defined(__NR_kill) + #define SYS_kill __NR_kill +#endif +#if defined(__NR_lchown) + #define SYS_lchown __NR_lchown +#endif +#if defined(__NR_lchown32) + #define SYS_lchown32 __NR_lchown32 +#endif +#if defined(__NR_lgetxattr) + #define SYS_lgetxattr __NR_lgetxattr +#endif +#if defined(__NR_link) + #define SYS_link __NR_link +#endif +#if defined(__NR_linkat) + #define SYS_linkat __NR_linkat +#endif +#if defined(__NR_listen) + #define SYS_listen __NR_listen +#endif +#if defined(__NR_listxattr) + #define SYS_listxattr __NR_listxattr +#endif +#if defined(__NR_llistxattr) + #define SYS_llistxattr __NR_llistxattr +#endif +#if defined(__NR_llseek) + #define SYS_llseek __NR_llseek +#endif +#if defined(__NR_lock) + #define SYS_lock __NR_lock +#endif +#if defined(__NR_lookup_dcookie) + #define SYS_lookup_dcookie __NR_lookup_dcookie +#endif +#if defined(__NR_lremovexattr) + #define SYS_lremovexattr __NR_lremovexattr +#endif +#if defined(__NR_lseek) + #define SYS_lseek __NR_lseek +#endif +#if defined(__NR_lsetxattr) + #define SYS_lsetxattr __NR_lsetxattr +#endif +#if defined(__NR_lstat) + #define SYS_lstat __NR_lstat +#endif +#if defined(__NR_lstat64) + #define SYS_lstat64 __NR_lstat64 +#endif +#if defined(__NR_madvise) + #define SYS_madvise __NR_madvise +#endif +#if defined(__NR_mbind) + #define SYS_mbind __NR_mbind +#endif +#if defined(__NR_membarrier) + #define SYS_membarrier __NR_membarrier +#endif +#if defined(__NR_memfd_create) + #define SYS_memfd_create __NR_memfd_create +#endif +#if defined(__NR_migrate_pages) + #define SYS_migrate_pages __NR_migrate_pages +#endif +#if defined(__NR_mincore) + #define SYS_mincore __NR_mincore +#endif +#if defined(__NR_mkdir) + #define SYS_mkdir __NR_mkdir +#endif +#if defined(__NR_mkdirat) + #define SYS_mkdirat __NR_mkdirat +#endif +#if defined(__NR_mknod) + #define SYS_mknod __NR_mknod +#endif +#if defined(__NR_mknodat) + #define SYS_mknodat __NR_mknodat +#endif +#if defined(__NR_mlock) + #define SYS_mlock __NR_mlock +#endif +#if defined(__NR_mlock2) + #define SYS_mlock2 __NR_mlock2 +#endif +#if defined(__NR_mlockall) + #define SYS_mlockall __NR_mlockall +#endif +#if defined(__NR_mmap) + #define SYS_mmap __NR_mmap +#endif +#if defined(__NR_mmap2) + #define SYS_mmap2 __NR_mmap2 +#endif +#if defined(__NR_modify_ldt) + #define SYS_modify_ldt __NR_modify_ldt +#endif +#if defined(__NR_mount) + #define SYS_mount __NR_mount +#endif +#if defined(__NR_move_pages) + #define SYS_move_pages __NR_move_pages +#endif +#if defined(__NR_mprotect) + #define SYS_mprotect __NR_mprotect +#endif +#if defined(__NR_mpx) + #define SYS_mpx __NR_mpx +#endif +#if defined(__NR_mq_getsetattr) + #define SYS_mq_getsetattr __NR_mq_getsetattr +#endif +#if defined(__NR_mq_notify) + #define SYS_mq_notify __NR_mq_notify +#endif +#if defined(__NR_mq_open) + #define SYS_mq_open __NR_mq_open +#endif +#if defined(__NR_mq_timedreceive) + #define SYS_mq_timedreceive __NR_mq_timedreceive +#endif +#if defined(__NR_mq_timedsend) + #define SYS_mq_timedsend __NR_mq_timedsend +#endif +#if defined(__NR_mq_unlink) + #define SYS_mq_unlink __NR_mq_unlink +#endif +#if defined(__NR_mremap) + #define SYS_mremap __NR_mremap +#endif +#if defined(__NR_msgctl) + #define SYS_msgctl __NR_msgctl +#endif +#if defined(__NR_msgget) + #define SYS_msgget __NR_msgget +#endif +#if defined(__NR_msgrcv) + #define SYS_msgrcv __NR_msgrcv +#endif +#if defined(__NR_msgsnd) + #define SYS_msgsnd __NR_msgsnd +#endif +#if defined(__NR_msync) + #define SYS_msync __NR_msync +#endif +#if defined(__NR_munlock) + #define SYS_munlock __NR_munlock +#endif +#if defined(__NR_munlockall) + #define SYS_munlockall __NR_munlockall +#endif +#if defined(__NR_munmap) + #define SYS_munmap __NR_munmap +#endif +#if defined(__NR_name_to_handle_at) + #define SYS_name_to_handle_at __NR_name_to_handle_at +#endif +#if defined(__NR_nanosleep) + #define SYS_nanosleep __NR_nanosleep +#endif +#if defined(__NR_newfstatat) + #define SYS_newfstatat __NR_newfstatat +#endif +#if defined(__NR_nfsservctl) + #define SYS_nfsservctl __NR_nfsservctl +#endif +#if defined(__NR_nice) + #define SYS_nice __NR_nice +#endif +#if defined(__NR_oldfstat) + #define SYS_oldfstat __NR_oldfstat +#endif +#if defined(__NR_oldlstat) + #define SYS_oldlstat __NR_oldlstat +#endif +#if defined(__NR_oldolduname) + #define SYS_oldolduname __NR_oldolduname +#endif +#if defined(__NR_oldstat) + #define SYS_oldstat __NR_oldstat +#endif +#if defined(__NR_olduname) + #define SYS_olduname __NR_olduname +#endif +#if defined(__NR_oldwait4) + #define SYS_oldwait4 __NR_oldwait4 +#endif +#if defined(__NR_open) + #define SYS_open __NR_open +#endif +#if defined(__NR_open_by_handle_at) + #define SYS_open_by_handle_at __NR_open_by_handle_at +#endif +#if defined(__NR_openat) + #define SYS_openat __NR_openat +#endif +#if defined(__NR_pause) + #define SYS_pause __NR_pause +#endif +#if defined(__NR_pciconfig_iobase) + #define SYS_pciconfig_iobase __NR_pciconfig_iobase +#endif +#if defined(__NR_pciconfig_read) + #define SYS_pciconfig_read __NR_pciconfig_read +#endif +#if defined(__NR_pciconfig_write) + #define SYS_pciconfig_write __NR_pciconfig_write +#endif +#if defined(__NR_perf_event_open) + #define SYS_perf_event_open __NR_perf_event_open +#endif +#if defined(__NR_personality) + #define SYS_personality __NR_personality +#endif +#if defined(__NR_pipe) + #define SYS_pipe __NR_pipe +#endif +#if defined(__NR_pipe2) + #define SYS_pipe2 __NR_pipe2 +#endif +#if defined(__NR_pivot_root) + #define SYS_pivot_root __NR_pivot_root +#endif +#if defined(__NR_pkey_alloc) + #define SYS_pkey_alloc __NR_pkey_alloc +#endif +#if defined(__NR_pkey_free) + #define SYS_pkey_free __NR_pkey_free +#endif +#if defined(__NR_pkey_mprotect) + #define SYS_pkey_mprotect __NR_pkey_mprotect +#endif +#if defined(__NR_poll) + #define SYS_poll __NR_poll +#endif +#if defined(__NR_ppoll) + #define SYS_ppoll __NR_ppoll +#endif +#if defined(__NR_prctl) + #define SYS_prctl __NR_prctl +#endif +#if defined(__NR_pread64) + #define SYS_pread64 __NR_pread64 +#endif +#if defined(__NR_preadv) + #define SYS_preadv __NR_preadv +#endif +#if defined(__NR_preadv2) + #define SYS_preadv2 __NR_preadv2 +#endif +#if defined(__NR_prlimit64) + #define SYS_prlimit64 __NR_prlimit64 +#endif +#if defined(__NR_process_vm_readv) + #define SYS_process_vm_readv __NR_process_vm_readv +#endif +#if defined(__NR_process_vm_writev) + #define SYS_process_vm_writev __NR_process_vm_writev +#endif +#if defined(__NR_prof) + #define SYS_prof __NR_prof +#endif +#if defined(__NR_profil) + #define SYS_profil __NR_profil +#endif +#if defined(__NR_pselect6) + #define SYS_pselect6 __NR_pselect6 +#endif +#if defined(__NR_ptrace) + #define SYS_ptrace __NR_ptrace +#endif +#if defined(__NR_putpmsg) + #define SYS_putpmsg __NR_putpmsg +#endif +#if defined(__NR_pwrite64) + #define SYS_pwrite64 __NR_pwrite64 +#endif +#if defined(__NR_pwritev) + #define SYS_pwritev __NR_pwritev +#endif +#if defined(__NR_pwritev2) + #define SYS_pwritev2 __NR_pwritev2 +#endif +#if defined(__NR_query_module) + #define SYS_query_module __NR_query_module +#endif +#if defined(__NR_quotactl) + #define SYS_quotactl __NR_quotactl +#endif +#if defined(__NR_read) + #define SYS_read __NR_read +#endif +#if defined(__NR_readahead) + #define SYS_readahead __NR_readahead +#endif +#if defined(__NR_readdir) + #define SYS_readdir __NR_readdir +#endif +#if defined(__NR_readlink) + #define SYS_readlink __NR_readlink +#endif +#if defined(__NR_readlinkat) + #define SYS_readlinkat __NR_readlinkat +#endif +#if defined(__NR_readv) + #define SYS_readv __NR_readv +#endif +#if defined(__NR_reboot) + #define SYS_reboot __NR_reboot +#endif +#if defined(__NR_recv) + #define SYS_recv __NR_recv +#endif +#if defined(__NR_recvfrom) + #define SYS_recvfrom __NR_recvfrom +#endif +#if defined(__NR_recvmmsg) + #define SYS_recvmmsg __NR_recvmmsg +#endif +#if defined(__NR_recvmsg) + #define SYS_recvmsg __NR_recvmsg +#endif +#if defined(__NR_remap_file_pages) + #define SYS_remap_file_pages __NR_remap_file_pages +#endif +#if defined(__NR_removexattr) + #define SYS_removexattr __NR_removexattr +#endif +#if defined(__NR_rename) + #define SYS_rename __NR_rename +#endif +#if defined(__NR_renameat) + #define SYS_renameat __NR_renameat +#endif +#if defined(__NR_renameat2) + #define SYS_renameat2 __NR_renameat2 +#endif +#if defined(__NR_request_key) + #define SYS_request_key __NR_request_key +#endif +#if defined(__NR_restart_syscall) + #define SYS_restart_syscall __NR_restart_syscall +#endif +#if defined(__NR_rmdir) + #define SYS_rmdir __NR_rmdir +#endif +#if defined(__NR_rt_sigaction) + #define SYS_rt_sigaction __NR_rt_sigaction +#endif +#if defined(__NR_rt_sigpending) + #define SYS_rt_sigpending __NR_rt_sigpending +#endif +#if defined(__NR_rt_sigprocmask) + #define SYS_rt_sigprocmask __NR_rt_sigprocmask +#endif +#if defined(__NR_rt_sigqueueinfo) + #define SYS_rt_sigqueueinfo __NR_rt_sigqueueinfo +#endif +#if defined(__NR_rt_sigreturn) + #define SYS_rt_sigreturn __NR_rt_sigreturn +#endif +#if defined(__NR_rt_sigsuspend) + #define SYS_rt_sigsuspend __NR_rt_sigsuspend +#endif +#if defined(__NR_rt_sigtimedwait) + #define SYS_rt_sigtimedwait __NR_rt_sigtimedwait +#endif +#if defined(__NR_rt_tgsigqueueinfo) + #define SYS_rt_tgsigqueueinfo __NR_rt_tgsigqueueinfo +#endif +#if defined(__NR_sched_get_priority_max) + #define SYS_sched_get_priority_max __NR_sched_get_priority_max +#endif +#if defined(__NR_sched_get_priority_min) + #define SYS_sched_get_priority_min __NR_sched_get_priority_min +#endif +#if defined(__NR_sched_getaffinity) + #define SYS_sched_getaffinity __NR_sched_getaffinity +#endif +#if defined(__NR_sched_getattr) + #define SYS_sched_getattr __NR_sched_getattr +#endif +#if defined(__NR_sched_getparam) + #define SYS_sched_getparam __NR_sched_getparam +#endif +#if defined(__NR_sched_getscheduler) + #define SYS_sched_getscheduler __NR_sched_getscheduler +#endif +#if defined(__NR_sched_rr_get_interval) + #define SYS_sched_rr_get_interval __NR_sched_rr_get_interval +#endif +#if defined(__NR_sched_setaffinity) + #define SYS_sched_setaffinity __NR_sched_setaffinity +#endif +#if defined(__NR_sched_setattr) + #define SYS_sched_setattr __NR_sched_setattr +#endif +#if defined(__NR_sched_setparam) + #define SYS_sched_setparam __NR_sched_setparam +#endif +#if defined(__NR_sched_setscheduler) + #define SYS_sched_setscheduler __NR_sched_setscheduler +#endif +#if defined(__NR_sched_yield) + #define SYS_sched_yield __NR_sched_yield +#endif +#if defined(__NR_seccomp) + #define SYS_seccomp __NR_seccomp +#endif +#if defined(__NR_security) + #define SYS_security __NR_security +#endif +#if defined(__NR_select) + #define SYS_select __NR_select +#endif +#if defined(__NR_semctl) + #define SYS_semctl __NR_semctl +#endif +#if defined(__NR_semget) + #define SYS_semget __NR_semget +#endif +#if defined(__NR_semop) + #define SYS_semop __NR_semop +#endif +#if defined(__NR_semtimedop) + #define SYS_semtimedop __NR_semtimedop +#endif +#if defined(__NR_send) + #define SYS_send __NR_send +#endif +#if defined(__NR_sendfile) + #define SYS_sendfile __NR_sendfile +#endif +#if defined(__NR_sendfile64) + #define SYS_sendfile64 __NR_sendfile64 +#endif +#if defined(__NR_sendmmsg) + #define SYS_sendmmsg __NR_sendmmsg +#endif +#if defined(__NR_sendmsg) + #define SYS_sendmsg __NR_sendmsg +#endif +#if defined(__NR_sendto) + #define SYS_sendto __NR_sendto +#endif +#if defined(__NR_set_mempolicy) + #define SYS_set_mempolicy __NR_set_mempolicy +#endif +#if defined(__NR_set_robust_list) + #define SYS_set_robust_list __NR_set_robust_list +#endif +#if defined(__NR_set_thread_area) + #define SYS_set_thread_area __NR_set_thread_area +#endif +#if defined(__NR_set_tid_address) + #define SYS_set_tid_address __NR_set_tid_address +#endif +#if defined(__NR_setdomainname) + #define SYS_setdomainname __NR_setdomainname +#endif +#if defined(__NR_setfsgid) + #define SYS_setfsgid __NR_setfsgid +#endif +#if defined(__NR_setfsgid32) + #define SYS_setfsgid32 __NR_setfsgid32 +#endif +#if defined(__NR_setfsuid) + #define SYS_setfsuid __NR_setfsuid +#endif +#if defined(__NR_setfsuid32) + #define SYS_setfsuid32 __NR_setfsuid32 +#endif +#if defined(__NR_setgid) + #define SYS_setgid __NR_setgid +#endif +#if defined(__NR_setgid32) + #define SYS_setgid32 __NR_setgid32 +#endif +#if defined(__NR_setgroups) + #define SYS_setgroups __NR_setgroups +#endif +#if defined(__NR_setgroups32) + #define SYS_setgroups32 __NR_setgroups32 +#endif +#if defined(__NR_sethostname) + #define SYS_sethostname __NR_sethostname +#endif +#if defined(__NR_setitimer) + #define SYS_setitimer __NR_setitimer +#endif +#if defined(__NR_setns) + #define SYS_setns __NR_setns +#endif +#if defined(__NR_setpgid) + #define SYS_setpgid __NR_setpgid +#endif +#if defined(__NR_setpriority) + #define SYS_setpriority __NR_setpriority +#endif +#if defined(__NR_setregid) + #define SYS_setregid __NR_setregid +#endif +#if defined(__NR_setregid32) + #define SYS_setregid32 __NR_setregid32 +#endif +#if defined(__NR_setresgid) + #define SYS_setresgid __NR_setresgid +#endif +#if defined(__NR_setresgid32) + #define SYS_setresgid32 __NR_setresgid32 +#endif +#if defined(__NR_setresuid) + #define SYS_setresuid __NR_setresuid +#endif +#if defined(__NR_setresuid32) + #define SYS_setresuid32 __NR_setresuid32 +#endif +#if defined(__NR_setreuid) + #define SYS_setreuid __NR_setreuid +#endif +#if defined(__NR_setreuid32) + #define SYS_setreuid32 __NR_setreuid32 +#endif +#if defined(__NR_setrlimit) + #define SYS_setrlimit __NR_setrlimit +#endif +#if defined(__NR_setsid) + #define SYS_setsid __NR_setsid +#endif +#if defined(__NR_setsockopt) + #define SYS_setsockopt __NR_setsockopt +#endif +#if defined(__NR_settimeofday) + #define SYS_settimeofday __NR_settimeofday +#endif +#if defined(__NR_setuid) + #define SYS_setuid __NR_setuid +#endif +#if defined(__NR_setuid32) + #define SYS_setuid32 __NR_setuid32 +#endif +#if defined(__NR_setxattr) + #define SYS_setxattr __NR_setxattr +#endif +#if defined(__NR_sgetmask) + #define SYS_sgetmask __NR_sgetmask +#endif +#if defined(__NR_shmat) + #define SYS_shmat __NR_shmat +#endif +#if defined(__NR_shmctl) + #define SYS_shmctl __NR_shmctl +#endif +#if defined(__NR_shmdt) + #define SYS_shmdt __NR_shmdt +#endif +#if defined(__NR_shmget) + #define SYS_shmget __NR_shmget +#endif +#if defined(__NR_shutdown) + #define SYS_shutdown __NR_shutdown +#endif +#if defined(__NR_sigaction) + #define SYS_sigaction __NR_sigaction +#endif +#if defined(__NR_sigaltstack) + #define SYS_sigaltstack __NR_sigaltstack +#endif +#if defined(__NR_signal) + #define SYS_signal __NR_signal +#endif +#if defined(__NR_signalfd) + #define SYS_signalfd __NR_signalfd +#endif +#if defined(__NR_signalfd4) + #define SYS_signalfd4 __NR_signalfd4 +#endif +#if defined(__NR_sigpending) + #define SYS_sigpending __NR_sigpending +#endif +#if defined(__NR_sigprocmask) + #define SYS_sigprocmask __NR_sigprocmask +#endif +#if defined(__NR_sigreturn) + #define SYS_sigreturn __NR_sigreturn +#endif +#if defined(__NR_sigsuspend) + #define SYS_sigsuspend __NR_sigsuspend +#endif +#if defined(__NR_socket) + #define SYS_socket __NR_socket +#endif +#if defined(__NR_socketcall) + #define SYS_socketcall __NR_socketcall +#endif +#if defined(__NR_socketpair) + #define SYS_socketpair __NR_socketpair +#endif +#if defined(__NR_splice) + #define SYS_splice __NR_splice +#endif +#if defined(__NR_ssetmask) + #define SYS_ssetmask __NR_ssetmask +#endif +#if defined(__NR_stat) + #define SYS_stat __NR_stat +#endif +#if defined(__NR_stat64) + #define SYS_stat64 __NR_stat64 +#endif +#if defined(__NR_statfs) + #define SYS_statfs __NR_statfs +#endif +#if defined(__NR_statfs64) + #define SYS_statfs64 __NR_statfs64 +#endif +#if defined(__NR_stime) + #define SYS_stime __NR_stime +#endif +#if defined(__NR_stty) + #define SYS_stty __NR_stty +#endif +#if defined(__NR_swapoff) + #define SYS_swapoff __NR_swapoff +#endif +#if defined(__NR_swapon) + #define SYS_swapon __NR_swapon +#endif +#if defined(__NR_symlink) + #define SYS_symlink __NR_symlink +#endif +#if defined(__NR_symlinkat) + #define SYS_symlinkat __NR_symlinkat +#endif +#if defined(__NR_sync) + #define SYS_sync __NR_sync +#endif +#if defined(__NR_sync_file_range) + #define SYS_sync_file_range __NR_sync_file_range +#endif +#if defined(__NR_sync_file_range2) + #define SYS_sync_file_range2 __NR_sync_file_range2 +#endif +#if defined(__NR_syncfs) + #define SYS_syncfs __NR_syncfs +#endif +#if defined(__NR_syscall) + #define SYS_syscall __NR_syscall +#endif +#if defined(__NR_syscalls) + #define SYS_syscalls __NR_syscalls +#endif +#if defined(__NR_sysfs) + #define SYS_sysfs __NR_sysfs +#endif +#if defined(__NR_sysinfo) + #define SYS_sysinfo __NR_sysinfo +#endif +#if defined(__NR_syslog) + #define SYS_syslog __NR_syslog +#endif +#if defined(__NR_sysmips) + #define SYS_sysmips __NR_sysmips +#endif +#if defined(__NR_tee) + #define SYS_tee __NR_tee +#endif +#if defined(__NR_tgkill) + #define SYS_tgkill __NR_tgkill +#endif +#if defined(__NR_time) + #define SYS_time __NR_time +#endif +#if defined(__NR_timer_create) + #define SYS_timer_create __NR_timer_create +#endif +#if defined(__NR_timer_delete) + #define SYS_timer_delete __NR_timer_delete +#endif +#if defined(__NR_timer_getoverrun) + #define SYS_timer_getoverrun __NR_timer_getoverrun +#endif +#if defined(__NR_timer_gettime) + #define SYS_timer_gettime __NR_timer_gettime +#endif +#if defined(__NR_timer_settime) + #define SYS_timer_settime __NR_timer_settime +#endif +#if defined(__NR_timerfd) + #define SYS_timerfd __NR_timerfd +#endif +#if defined(__NR_timerfd_create) + #define SYS_timerfd_create __NR_timerfd_create +#endif +#if defined(__NR_timerfd_gettime) + #define SYS_timerfd_gettime __NR_timerfd_gettime +#endif +#if defined(__NR_timerfd_settime) + #define SYS_timerfd_settime __NR_timerfd_settime +#endif +#if defined(__NR_times) + #define SYS_times __NR_times +#endif +#if defined(__NR_tkill) + #define SYS_tkill __NR_tkill +#endif +#if defined(__NR_truncate) + #define SYS_truncate __NR_truncate +#endif +#if defined(__NR_truncate64) + #define SYS_truncate64 __NR_truncate64 +#endif +#if defined(__NR_tuxcall) + #define SYS_tuxcall __NR_tuxcall +#endif +#if defined(__NR_ugetrlimit) + #define SYS_ugetrlimit __NR_ugetrlimit +#endif +#if defined(__NR_ulimit) + #define SYS_ulimit __NR_ulimit +#endif +#if defined(__NR_umask) + #define SYS_umask __NR_umask +#endif +#if defined(__NR_umount) + #define SYS_umount __NR_umount +#endif +#if defined(__NR_umount2) + #define SYS_umount2 __NR_umount2 +#endif +#if defined(__NR_uname) + #define SYS_uname __NR_uname +#endif +#if defined(__NR_unlink) + #define SYS_unlink __NR_unlink +#endif +#if defined(__NR_unlinkat) + #define SYS_unlinkat __NR_unlinkat +#endif +#if defined(__NR_unshare) + #define SYS_unshare __NR_unshare +#endif +#if defined(__NR_uselib) + #define SYS_uselib __NR_uselib +#endif +#if defined(__NR_userfaultfd) + #define SYS_userfaultfd __NR_userfaultfd +#endif +#if defined(__NR_ustat) + #define SYS_ustat __NR_ustat +#endif +#if defined(__NR_utime) + #define SYS_utime __NR_utime +#endif +#if defined(__NR_utimensat) + #define SYS_utimensat __NR_utimensat +#endif +#if defined(__NR_utimes) + #define SYS_utimes __NR_utimes +#endif +#if defined(__NR_vfork) + #define SYS_vfork __NR_vfork +#endif +#if defined(__NR_vhangup) + #define SYS_vhangup __NR_vhangup +#endif +#if defined(__NR_vm86) + #define SYS_vm86 __NR_vm86 +#endif +#if defined(__NR_vm86old) + #define SYS_vm86old __NR_vm86old +#endif +#if defined(__NR_vmsplice) + #define SYS_vmsplice __NR_vmsplice +#endif +#if defined(__NR_vserver) + #define SYS_vserver __NR_vserver +#endif +#if defined(__NR_wait4) + #define SYS_wait4 __NR_wait4 +#endif +#if defined(__NR_waitid) + #define SYS_waitid __NR_waitid +#endif +#if defined(__NR_waitpid) + #define SYS_waitpid __NR_waitpid +#endif +#if defined(__NR_write) + #define SYS_write __NR_write +#endif +#if defined(__NR_writev) + #define SYS_writev __NR_writev +#endif +#endif /* _BIONIC_BITS_GLIBC_SYSCALLS_H_ */ diff --git a/headers/bits/ioctl.h b/headers/bits/ioctl.h new file mode 100644 index 000000000..53116cae6 --- /dev/null +++ b/headers/bits/ioctl.h @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _BITS_IOCTL_H_ +#define _BITS_IOCTL_H_ + +#include <sys/cdefs.h> + +__BEGIN_DECLS + +int ioctl(int, int, ...); + +__END_DECLS + +#endif diff --git a/headers/bits/lockf.h b/headers/bits/lockf.h new file mode 100644 index 000000000..522291047 --- /dev/null +++ b/headers/bits/lockf.h @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _BITS_LOCKF_H_ +#define _BITS_LOCKF_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +#define F_ULOCK 0 +#define F_LOCK 1 +#define F_TLOCK 2 +#define F_TEST 3 + +__BEGIN_DECLS + +#if defined(__USE_FILE_OFFSET64) +int lockf(int, int, off_t) __RENAME(lockf64); +#else + +#if __ANDROID_API__ >= 24 +int lockf(int, int, off_t) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + +#endif + +#if __ANDROID_API__ >= 24 +int lockf64(int, int, off64_t) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + + +__END_DECLS + +#endif diff --git a/headers/bits/mbstate_t.h b/headers/bits/mbstate_t.h new file mode 100644 index 000000000..057a2c99c --- /dev/null +++ b/headers/bits/mbstate_t.h @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _BITS_MBSTATE_T_H_ +#define _BITS_MBSTATE_T_H_ + +#include <sys/cdefs.h> + +typedef struct { + unsigned char __seq[4]; +#ifdef __LP64__ + unsigned char __reserved[4]; +#endif +} mbstate_t; + +#endif diff --git a/headers/bits/posix_limits.h b/headers/bits/posix_limits.h new file mode 100644 index 000000000..c498c6919 --- /dev/null +++ b/headers/bits/posix_limits.h @@ -0,0 +1,158 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _BITS_POSIX_LIMITS_H_ +#define _BITS_POSIX_LIMITS_H_ + +#include <sys/cdefs.h> + +/* Any constant values here other than -1 or 200809L are explicitly specified by POSIX.1-2008. */ +/* Keep this list sorted by name. */ +#define _POSIX_ADVISORY_INFO 200809L +#define _POSIX_AIO_LISTIO_MAX 2 +#define _POSIX_AIO_MAX 1 +#define _POSIX_ARG_MAX 4096 +#define _POSIX_ASYNCHRONOUS_IO -1 /* not implemented */ +#define _POSIX_BARRIERS 200809L +#define _POSIX_CHILD_MAX 25 +#define _POSIX_CHOWN_RESTRICTED 1 /* yes, chown requires appropriate privileges */ +#define _POSIX_CLOCK_SELECTION 200809L +#define _POSIX_CPUTIME 0 /* Use sysconf to detect support at runtime. */ +#define _POSIX_DELAYTIMER_MAX 32 +#define _POSIX_FSYNC 200809L /* fdatasync() supported */ +#define _POSIX_HOST_NAME_MAX 255 +#define _POSIX_IPV6 200809L +#define _POSIX_JOB_CONTROL 1 /* job control is a Linux feature */ +#define _POSIX_LINK_MAX 8 +#define _POSIX_LOGIN_NAME_MAX 9 /* includes trailing NUL */ +#define _POSIX_MAPPED_FILES 200809L /* mmap-ed files supported */ +#define _POSIX_MAX_CANON 255 +#define _POSIX_MAX_INPUT 255 +#define _POSIX_MEMLOCK 200809L +#define _POSIX_MEMLOCK_RANGE 200809L +#define _POSIX_MEMORY_PROTECTION 200809L +#define _POSIX_MESSAGE_PASSING -1 /* not implemented */ +#define _POSIX_MONOTONIC_CLOCK 0 /* the monotonic clock may be available; ask sysconf */ +#define _POSIX_MQ_OPEN_MAX 8 +#define _POSIX_MQ_PRIO_MAX 32 +#define _POSIX_NAME_MAX 14 +#define _POSIX_NGROUPS_MAX 8 +#define _POSIX_NO_TRUNC 1 /* very long pathnames generate an error */ +#define _POSIX_OPEN_MAX 20 +#define _POSIX_PATH_MAX 256 +#define _POSIX_PIPE_BUF 512 +#define _POSIX_PRIORITY_SCHEDULING 200809L /* priority scheduling is a Linux feature */ +#define _POSIX_PRIORITIZED_IO -1 /* not implemented */ +#define _POSIX_RAW_SOCKETS 200809L +#define _POSIX_READER_WRITER_LOCKS 200809L +#define _POSIX_REALTIME_SIGNALS 200809L +#define _POSIX_REGEXP 1 +#define _POSIX_RE_DUP_MAX 255 +#define _POSIX_SAVED_IDS 1 /* saved user ids is a Linux feature */ +#define _POSIX_SEMAPHORES 200809L +#define _POSIX_SEM_NSEMS_MAX 256 +#define _POSIX_SEM_VALUE_MAX 32767 +#define _POSIX_SHARED_MEMORY_OBJECTS -1 /* shm_open()/shm_unlink() not implemented */ +#define _POSIX_SHELL 1 /* system() supported */ +#define _POSIX_SIGQUEUE_MAX 32 +#define _POSIX_SPAWN -1 /* not implemented */ +#define _POSIX_SPIN_LOCKS 200809L +#define _POSIX_SPORADIC_SERVER -1 /* not implemented */ +#define _POSIX_SSIZE_MAX 32767 +#define _POSIX_STREAM_MAX 8 +#define _POSIX_SYMLINK_MAX 255 +#define _POSIX_SYMLOOP_MAX 8 +#define _POSIX_SYNCHRONIZED_IO 200809L /* synchronized i/o supported */ +#define _POSIX_THREADS 200809L /* we support threads */ +#define _POSIX_THREAD_ATTR_STACKADDR 200809L +#define _POSIX_THREAD_ATTR_STACKSIZE 200809L +#define _POSIX_THREAD_CPUTIME 0 /* Use sysconf to detect support at runtime. */ +#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4 +#define _POSIX_THREAD_KEYS_MAX 128 +#define _POSIX_THREAD_PRIORITY_SCHEDULING 200809L +#define _POSIX_THREAD_PRIO_INHERIT -1 /* not implemented */ +#define _POSIX_THREAD_PRIO_PROTECT -1 /* not implemented */ +#define _POSIX_THREAD_PROCESS_SHARED -1 /* not implemented */ +#define _POSIX_THREAD_ROBUST_PRIO_INHERIT -1 /* not implemented */ +#define _POSIX_THREAD_ROBUST_PRIO_PROTECT -1 /* not implemented */ +#define _POSIX_THREAD_SAFE_FUNCTIONS 200809L +#define _POSIX_THREAD_SPORADIC_SERVER -1 /* not implemented */ +#define _POSIX_THREAD_THREADS_MAX 64 +#define _POSIX_TIMEOUTS 200809L +#define _POSIX_TIMERS 200809L /* Posix timers are supported */ +#define _POSIX_TIMER_MAX 32 +#define _POSIX_TRACE -1 /* not implemented */ +#define _POSIX_TRACE_EVENT_FILTER -1 /* not implemented */ +#define _POSIX_TRACE_INHERIT -1 /* not implemented */ +#define _POSIX_TRACE_LOG -1 /* not implemented */ +#define _POSIX_TRACE_NAME_MAX 8 +#define _POSIX_TRACE_SYS_MAX 8 +#define _POSIX_TRACE_USER_EVENT_MAX 32 +#define _POSIX_TTY_NAME_MAX 9 /* includes trailing NUL */ +#define _POSIX_TYPED_MEMORY_OBJECTS -1 /* not implemented */ +#define _POSIX_TZNAME_MAX 6 +#define _POSIX_VDISABLE '\0' + +#if defined(__LP64__) +#define _POSIX_V7_ILP32_OFF32 -1 +#define _POSIX_V7_ILP32_OFFBIG -1 +#define _POSIX_V7_LP64_OFF64 1 +#define _POSIX_V7_LPBIG_OFFBIG 1 +#else +#define _POSIX_V7_ILP32_OFF32 1 +#define _POSIX_V7_ILP32_OFFBIG -1 +#define _POSIX_V7_LP64_OFF64 -1 +#define _POSIX_V7_LPBIG_OFFBIG -1 +#endif + +#define _POSIX2_BC_BASE_MAX 99 +#define _POSIX2_BC_DIM_MAX 2048 +#define _POSIX2_BC_SCALE_MAX 99 +#define _POSIX2_BC_STRING_MAX 1000 +#define _POSIX2_CHARCLASS_NAME_MAX 14 +#define _POSIX2_CHAR_TERM -1 /* not implemented */ +#define _POSIX2_COLL_WEIGHTS_MAX 2 +#define _POSIX2_C_BIND _POSIX_VERSION +#define _POSIX2_C_DEV -1 /* c dev utilities not implemented */ +#define _POSIX2_EXPR_NEST_MAX 32 +#define _POSIX2_LINE_MAX 2048 +#define _POSIX2_LOCALEDEF -1 /* localedef utilitiy not implemented */ +#define _POSIX2_RE_DUP_MAX _POSIX_RE_DUP_MAX +#define _POSIX2_SW_DEV -1 /* software dev utilities not implemented */ +#define _POSIX2_UPE -1 /* user portability utilities not implemented */ + +#define _XOPEN_ENH_I18N -1 /* we don't support internationalization in the C library */ +#define _XOPEN_CRYPT -1 /* don't support X/Open Encryption */ +#define _XOPEN_IOV_MAX 16 +#define _XOPEN_LEGACY -1 /* not support all */ +#define _XOPEN_REALTIME -1 /* we don't support all these functions */ +#define _XOPEN_REALTIME_THREADS -1 /* same here */ +#define _XOPEN_SHM -1 +#define _XOPEN_UNIX 1 + +#endif diff --git a/headers/bits/pthread_types.h b/headers/bits/pthread_types.h new file mode 100644 index 000000000..7fc379b6a --- /dev/null +++ b/headers/bits/pthread_types.h @@ -0,0 +1,101 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _BITS_PTHREAD_TYPES_H_ +#define _BITS_PTHREAD_TYPES_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +typedef struct { + uint32_t flags; + void* stack_base; + size_t stack_size; + size_t guard_size; + int32_t sched_policy; + int32_t sched_priority; +#ifdef __LP64__ + char __reserved[16]; +#endif +} pthread_attr_t; + +typedef struct { +#if defined(__LP64__) + int64_t __private[4]; +#else + int32_t __private[8]; +#endif +} pthread_barrier_t; + +typedef int pthread_barrierattr_t; + +typedef struct { +#if defined(__LP64__) + int32_t __private[12]; +#else + int32_t __private[1]; +#endif +} pthread_cond_t; + +typedef long pthread_condattr_t; + +typedef int pthread_key_t; + +typedef struct { +#if defined(__LP64__) + int32_t __private[10]; +#else + int32_t __private[1]; +#endif +} pthread_mutex_t; + +typedef long pthread_mutexattr_t; + +typedef int pthread_once_t; + +typedef struct { +#if defined(__LP64__) + int32_t __private[14]; +#else + int32_t __private[10]; +#endif +} pthread_rwlock_t; + +typedef long pthread_rwlockattr_t; + +typedef struct { +#if defined(__LP64__) + int64_t __private; +#else + int32_t __private[2]; +#endif +} pthread_spinlock_t; + +typedef long pthread_t; + +#endif diff --git a/headers/bits/sa_family_t.h b/headers/bits/sa_family_t.h new file mode 100644 index 000000000..98ca27f18 --- /dev/null +++ b/headers/bits/sa_family_t.h @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _BITS_SA_FAMILY_T_H_ +#define _BITS_SA_FAMILY_T_H_ + +#include <sys/cdefs.h> + +typedef unsigned short sa_family_t; + +#endif diff --git a/headers/bits/seek_constants.h b/headers/bits/seek_constants.h new file mode 100644 index 000000000..34c5866c6 --- /dev/null +++ b/headers/bits/seek_constants.h @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _BITS_SEEK_CONSTANTS_H_ +#define _BITS_SEEK_CONSTANTS_H_ + +#define SEEK_SET 0 +#define SEEK_CUR 1 +#define SEEK_END 2 + +#endif diff --git a/headers/bits/strcasecmp.h b/headers/bits/strcasecmp.h new file mode 100644 index 000000000..f5e98a0c7 --- /dev/null +++ b/headers/bits/strcasecmp.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _BITS_STRCASECMP_H_ +#define _BITS_STRCASECMP_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <xlocale.h> + +__BEGIN_DECLS + +int strcasecmp(const char*, const char*) __attribute_pure__; + +#if __ANDROID_API__ >= 23 +int strcasecmp_l(const char*, const char*, locale_t) __attribute_pure__ __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +int strncasecmp(const char*, const char*, size_t) __attribute_pure__; + +#if __ANDROID_API__ >= 23 +int strncasecmp_l(const char*, const char*, size_t, locale_t) __attribute_pure__ __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +__END_DECLS + +#endif diff --git a/headers/bits/struct_file.h b/headers/bits/struct_file.h new file mode 100644 index 000000000..08e18a13a --- /dev/null +++ b/headers/bits/struct_file.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef BITS_FILE_H +#define BITS_FILE_H + +#include <sys/cdefs.h> + +__BEGIN_DECLS + +struct __sFILE { +#if defined(__LP64__) + char __private[152]; +#else + char __private[84]; +#endif +} __attribute__((aligned(sizeof(void*)))); + +__END_DECLS + +#endif /* BITS_FILE_H */ diff --git a/headers/bits/sysconf.h b/headers/bits/sysconf.h new file mode 100644 index 000000000..2cbbb11e9 --- /dev/null +++ b/headers/bits/sysconf.h @@ -0,0 +1,196 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _BITS_SYSCONF_H_ +#define _BITS_SYSCONF_H_ + +#include <sys/cdefs.h> + +/* as listed by Posix sysconf() description */ +/* most of these will return -1 and ENOSYS */ + +#define _SC_ARG_MAX 0x0000 +#define _SC_BC_BASE_MAX 0x0001 +#define _SC_BC_DIM_MAX 0x0002 +#define _SC_BC_SCALE_MAX 0x0003 +#define _SC_BC_STRING_MAX 0x0004 +#define _SC_CHILD_MAX 0x0005 +#define _SC_CLK_TCK 0x0006 +#define _SC_COLL_WEIGHTS_MAX 0x0007 +#define _SC_EXPR_NEST_MAX 0x0008 +#define _SC_LINE_MAX 0x0009 +#define _SC_NGROUPS_MAX 0x000a +#define _SC_OPEN_MAX 0x000b +#define _SC_PASS_MAX 0x000c +#define _SC_2_C_BIND 0x000d +#define _SC_2_C_DEV 0x000e +#define _SC_2_C_VERSION 0x000f /* Obsolescent in POSIX.1-2008, TODO: remove it. */ +#define _SC_2_CHAR_TERM 0x0010 +#define _SC_2_FORT_DEV 0x0011 +#define _SC_2_FORT_RUN 0x0012 +#define _SC_2_LOCALEDEF 0x0013 +#define _SC_2_SW_DEV 0x0014 +#define _SC_2_UPE 0x0015 +#define _SC_2_VERSION 0x0016 +#define _SC_JOB_CONTROL 0x0017 +#define _SC_SAVED_IDS 0x0018 +#define _SC_VERSION 0x0019 +#define _SC_RE_DUP_MAX 0x001a +#define _SC_STREAM_MAX 0x001b +#define _SC_TZNAME_MAX 0x001c +#define _SC_XOPEN_CRYPT 0x001d +#define _SC_XOPEN_ENH_I18N 0x001e +#define _SC_XOPEN_SHM 0x001f +#define _SC_XOPEN_VERSION 0x0020 +#define _SC_XOPEN_XCU_VERSION 0x0021 /* Obsolescent in POSIX.1-2008, TODO: remove it. */ +#define _SC_XOPEN_REALTIME 0x0022 +#define _SC_XOPEN_REALTIME_THREADS 0x0023 +#define _SC_XOPEN_LEGACY 0x0024 +#define _SC_ATEXIT_MAX 0x0025 +#define _SC_IOV_MAX 0x0026 +#define _SC_PAGESIZE 0x0027 +#define _SC_PAGE_SIZE 0x0028 +#define _SC_XOPEN_UNIX 0x0029 +#define _SC_XBS5_ILP32_OFF32 0x002a /* Obsolescent in POSIX.1-2008, TODO: remove it. */ +#define _SC_XBS5_ILP32_OFFBIG 0x002b /* Obsolescent in POSIX.1-2008, TODO: remove it. */ +#define _SC_XBS5_LP64_OFF64 0x002c /* Obsolescent in POSIX.1-2008, TODO: remove it. */ +#define _SC_XBS5_LPBIG_OFFBIG 0x002d /* Obsolescent in POSIX.1-2008, TODO: remove it. */ +#define _SC_AIO_LISTIO_MAX 0x002e +#define _SC_AIO_MAX 0x002f +#define _SC_AIO_PRIO_DELTA_MAX 0x0030 +#define _SC_DELAYTIMER_MAX 0x0031 +#define _SC_MQ_OPEN_MAX 0x0032 +#define _SC_MQ_PRIO_MAX 0x0033 +#define _SC_RTSIG_MAX 0x0034 +#define _SC_SEM_NSEMS_MAX 0x0035 +#define _SC_SEM_VALUE_MAX 0x0036 +#define _SC_SIGQUEUE_MAX 0x0037 +#define _SC_TIMER_MAX 0x0038 +#define _SC_ASYNCHRONOUS_IO 0x0039 +#define _SC_FSYNC 0x003a +#define _SC_MAPPED_FILES 0x003b +#define _SC_MEMLOCK 0x003c +#define _SC_MEMLOCK_RANGE 0x003d +#define _SC_MEMORY_PROTECTION 0x003e +#define _SC_MESSAGE_PASSING 0x003f +#define _SC_PRIORITIZED_IO 0x0040 +#define _SC_PRIORITY_SCHEDULING 0x0041 +#define _SC_REALTIME_SIGNALS 0x0042 +#define _SC_SEMAPHORES 0x0043 +#define _SC_SHARED_MEMORY_OBJECTS 0x0044 +#define _SC_SYNCHRONIZED_IO 0x0045 +#define _SC_TIMERS 0x0046 +#define _SC_GETGR_R_SIZE_MAX 0x0047 +#define _SC_GETPW_R_SIZE_MAX 0x0048 +#define _SC_LOGIN_NAME_MAX 0x0049 +#define _SC_THREAD_DESTRUCTOR_ITERATIONS 0x004a +#define _SC_THREAD_KEYS_MAX 0x004b +#define _SC_THREAD_STACK_MIN 0x004c +#define _SC_THREAD_THREADS_MAX 0x004d +#define _SC_TTY_NAME_MAX 0x004e + +#define _SC_THREADS 0x004f +#define _SC_THREAD_ATTR_STACKADDR 0x0050 +#define _SC_THREAD_ATTR_STACKSIZE 0x0051 +#define _SC_THREAD_PRIORITY_SCHEDULING 0x0052 +#define _SC_THREAD_PRIO_INHERIT 0x0053 +#define _SC_THREAD_PRIO_PROTECT 0x0054 +#define _SC_THREAD_SAFE_FUNCTIONS 0x0055 + +#define _SC_NPROCESSORS_CONF 0x0060 +#define _SC_NPROCESSORS_ONLN 0x0061 +#define _SC_PHYS_PAGES 0x0062 +#define _SC_AVPHYS_PAGES 0x0063 +#define _SC_MONOTONIC_CLOCK 0x0064 + +#define _SC_2_PBS 0x0065 +#define _SC_2_PBS_ACCOUNTING 0x0066 +#define _SC_2_PBS_CHECKPOINT 0x0067 +#define _SC_2_PBS_LOCATE 0x0068 +#define _SC_2_PBS_MESSAGE 0x0069 +#define _SC_2_PBS_TRACK 0x006a +#define _SC_ADVISORY_INFO 0x006b +#define _SC_BARRIERS 0x006c +#define _SC_CLOCK_SELECTION 0x006d +#define _SC_CPUTIME 0x006e +#define _SC_HOST_NAME_MAX 0x006f +#define _SC_IPV6 0x0070 +#define _SC_RAW_SOCKETS 0x0071 +#define _SC_READER_WRITER_LOCKS 0x0072 +#define _SC_REGEXP 0x0073 +#define _SC_SHELL 0x0074 +#define _SC_SPAWN 0x0075 +#define _SC_SPIN_LOCKS 0x0076 +#define _SC_SPORADIC_SERVER 0x0077 +#define _SC_SS_REPL_MAX 0x0078 +#define _SC_SYMLOOP_MAX 0x0079 +#define _SC_THREAD_CPUTIME 0x007a +#define _SC_THREAD_PROCESS_SHARED 0x007b +#define _SC_THREAD_ROBUST_PRIO_INHERIT 0x007c +#define _SC_THREAD_ROBUST_PRIO_PROTECT 0x007d +#define _SC_THREAD_SPORADIC_SERVER 0x007e +#define _SC_TIMEOUTS 0x007f +#define _SC_TRACE 0x0080 +#define _SC_TRACE_EVENT_FILTER 0x0081 +#define _SC_TRACE_EVENT_NAME_MAX 0x0082 +#define _SC_TRACE_INHERIT 0x0083 +#define _SC_TRACE_LOG 0x0084 +#define _SC_TRACE_NAME_MAX 0x0085 +#define _SC_TRACE_SYS_MAX 0x0086 +#define _SC_TRACE_USER_EVENT_MAX 0x0087 +#define _SC_TYPED_MEMORY_OBJECTS 0x0088 +#define _SC_V7_ILP32_OFF32 0x0089 +#define _SC_V7_ILP32_OFFBIG 0x008a +#define _SC_V7_LP64_OFF64 0x008b +#define _SC_V7_LPBIG_OFFBIG 0x008c +#define _SC_XOPEN_STREAMS 0x008d +#define _SC_XOPEN_UUCP 0x008e + +#define _SC_LEVEL1_ICACHE_SIZE 0x008f +#define _SC_LEVEL1_ICACHE_ASSOC 0x0090 +#define _SC_LEVEL1_ICACHE_LINESIZE 0x0091 +#define _SC_LEVEL1_DCACHE_SIZE 0x0092 +#define _SC_LEVEL1_DCACHE_ASSOC 0x0093 +#define _SC_LEVEL1_DCACHE_LINESIZE 0x0094 +#define _SC_LEVEL2_CACHE_SIZE 0x0095 +#define _SC_LEVEL2_CACHE_ASSOC 0x0096 +#define _SC_LEVEL2_CACHE_LINESIZE 0x0097 +#define _SC_LEVEL3_CACHE_SIZE 0x0098 +#define _SC_LEVEL3_CACHE_ASSOC 0x0099 +#define _SC_LEVEL3_CACHE_LINESIZE 0x009a +#define _SC_LEVEL4_CACHE_SIZE 0x009b +#define _SC_LEVEL4_CACHE_ASSOC 0x009c +#define _SC_LEVEL4_CACHE_LINESIZE 0x009d + +__BEGIN_DECLS + +long sysconf(int __name); + +__END_DECLS + +#endif /* _SYS_SYSCONF_H_ */ diff --git a/headers/bits/timespec.h b/headers/bits/timespec.h new file mode 100644 index 000000000..df7a7ce4d --- /dev/null +++ b/headers/bits/timespec.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _BITS_TIMESPEC_H_ +#define _BITS_TIMESPEC_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +/* + * This file is used to include timespec definition without introducing the whole + * <linux/time.h>, <sys/time.h> or <time.h>. + */ +#ifndef _STRUCT_TIMESPEC +#define _STRUCT_TIMESPEC +struct timespec { + time_t tv_sec; + long tv_nsec; +}; +#endif + +#endif diff --git a/headers/bits/wchar_limits.h b/headers/bits/wchar_limits.h new file mode 100644 index 000000000..ffad6041f --- /dev/null +++ b/headers/bits/wchar_limits.h @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _BITS_WCHAR_LIMITS_H_ +#define _BITS_WCHAR_LIMITS_H_ + +#include <sys/cdefs.h> + +/* Both GCC and clang define __WCHAR_MAX__. */ +#define WCHAR_MAX __WCHAR_MAX__ + +/* As of 3.4, clang still doesn't define __WCHAR_MIN__. */ +#if defined(__WCHAR_UNSIGNED__) +# define WCHAR_MIN L'\0' +#else +# define WCHAR_MIN (-(WCHAR_MAX) - 1) +#endif + +#endif diff --git a/headers/bits/wctype.h b/headers/bits/wctype.h new file mode 100644 index 000000000..426e5ce73 --- /dev/null +++ b/headers/bits/wctype.h @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _BITS_WCTYPE_H_ +#define _BITS_WCTYPE_H_ + +#include <sys/cdefs.h> + +__BEGIN_DECLS + +typedef __WINT_TYPE__ wint_t; + +#define WEOF __BIONIC_CAST(static_cast, wint_t, -1) + +int iswalnum(wint_t); +int iswalpha(wint_t); + +#if __ANDROID_API__ >= 21 +int iswblank(wint_t) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int iswcntrl(wint_t); +int iswdigit(wint_t); +int iswgraph(wint_t); +int iswlower(wint_t); +int iswprint(wint_t); +int iswpunct(wint_t); +int iswspace(wint_t); +int iswupper(wint_t); +int iswxdigit(wint_t); + +wint_t towlower(wint_t); +wint_t towupper(wint_t); + +typedef long wctype_t; +wctype_t wctype(const char*); +int iswctype(wint_t, wctype_t); + +typedef const void* wctrans_t; +wint_t towctrans(wint_t, wctrans_t) __INTRODUCED_IN_FUTURE __VERSIONER_NO_GUARD; +wctrans_t wctrans(const char*) __INTRODUCED_IN_FUTURE __VERSIONER_NO_GUARD; + +__END_DECLS + +#endif diff --git a/headers/byteswap.h b/headers/byteswap.h new file mode 100644 index 000000000..0838e6c54 --- /dev/null +++ b/headers/byteswap.h @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _BYTESWAP_H_ +#define _BYTESWAP_H_ + +#include <sys/cdefs.h> +#include <sys/endian.h> + +#define bswap_16(x) __swap16(x) +#define bswap_32(x) __swap32(x) +#define bswap_64(x) __swap64(x) + +#endif /* _BYTESWAP_H_ */ diff --git a/headers/complex.h b/headers/complex.h new file mode 100644 index 000000000..19cc73f2f --- /dev/null +++ b/headers/complex.h @@ -0,0 +1,296 @@ +/*- + * Copyright (c) 2001-2011 The FreeBSD Project. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +#ifndef _COMPLEX_H +#define _COMPLEX_H + +#include <sys/cdefs.h> + +#ifdef __GNUC__ +#define _Complex_I ((float _Complex)1.0i) +#endif + +#ifdef __generic +_Static_assert(__generic(_Complex_I, float _Complex, 1, 0), + "_Complex_I must be of type float _Complex"); +#endif + +#define complex _Complex +#define I _Complex_I + +#if __STDC_VERSION__ >= 201112L +#ifdef __clang__ +#define CMPLX(x, y) ((double complex){ x, y }) +#define CMPLXF(x, y) ((float complex){ x, y }) +#define CMPLXL(x, y) ((long double complex){ x, y }) +#else +#define CMPLX(x, y) __builtin_complex((double)(x), (double)(y)) +#define CMPLXF(x, y) __builtin_complex((float)(x), (float)(y)) +#define CMPLXL(x, y) __builtin_complex((long double)(x), (long double)(y)) +#endif +#endif + +__BEGIN_DECLS + +/* 7.3.5 Trigonometric functions */ +/* 7.3.5.1 The cacos functions */ + +#if __ANDROID_API__ >= 23 +double complex cacos(double complex) __INTRODUCED_IN(23); +float complex cacosf(float complex) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +long double complex cacosl(long double complex) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + +/* 7.3.5.2 The casin functions */ + +#if __ANDROID_API__ >= 23 +double complex casin(double complex) __INTRODUCED_IN(23); +float complex casinf(float complex) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +long double complex casinl(long double complex) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + +/* 7.3.5.1 The catan functions */ + +#if __ANDROID_API__ >= 23 +double complex catan(double complex) __INTRODUCED_IN(23); +float complex catanf(float complex) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +long double complex catanl(long double complex) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + +/* 7.3.5.1 The ccos functions */ + +#if __ANDROID_API__ >= 23 +double complex ccos(double complex) __INTRODUCED_IN(23); +float complex ccosf(float complex) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +long double complex ccosl(long double complex) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + +/* 7.3.5.1 The csin functions */ + +#if __ANDROID_API__ >= 23 +double complex csin(double complex) __INTRODUCED_IN(23); +float complex csinf(float complex) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +long double complex csinl(long double complex) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + +/* 7.3.5.1 The ctan functions */ + +#if __ANDROID_API__ >= 23 +double complex ctan(double complex) __INTRODUCED_IN(23); +float complex ctanf(float complex) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +long double complex ctanl(long double complex) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + +/* 7.3.6 Hyperbolic functions */ +/* 7.3.6.1 The cacosh functions */ + +#if __ANDROID_API__ >= 23 +double complex cacosh(double complex) __INTRODUCED_IN(23); +float complex cacoshf(float complex) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +long double complex cacoshl(long double complex) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + +/* 7.3.6.2 The casinh functions */ + +#if __ANDROID_API__ >= 23 +double complex casinh(double complex) __INTRODUCED_IN(23); +float complex casinhf(float complex) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +long double complex casinhl(long double complex) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + +/* 7.3.6.3 The catanh functions */ + +#if __ANDROID_API__ >= 23 +double complex catanh(double complex) __INTRODUCED_IN(23); +float complex catanhf(float complex) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +long double complex catanhl(long double complex) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + +/* 7.3.6.4 The ccosh functions */ + +#if __ANDROID_API__ >= 23 +double complex ccosh(double complex) __INTRODUCED_IN(23); +float complex ccoshf(float complex) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +long double complex ccoshl(long double complex) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + +/* 7.3.6.5 The csinh functions */ + +#if __ANDROID_API__ >= 23 +double complex csinh(double complex) __INTRODUCED_IN(23); +float complex csinhf(float complex) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +long double complex csinhl(long double complex) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + +/* 7.3.6.6 The ctanh functions */ + +#if __ANDROID_API__ >= 23 +double complex ctanh(double complex) __INTRODUCED_IN(23); +float complex ctanhf(float complex) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +long double complex ctanhl(long double complex) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + +/* 7.3.7 Exponential and logarithmic functions */ +/* 7.3.7.1 The cexp functions */ + +#if __ANDROID_API__ >= 23 +double complex cexp(double complex) __INTRODUCED_IN(23); +float complex cexpf(float complex) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +long double complex cexpl(long double complex) __INTRODUCED_IN_FUTURE; +/* 7.3.7.2 The clog functions */ +double complex clog(double complex) __INTRODUCED_IN_FUTURE; +float complex clogf(float complex) __INTRODUCED_IN_FUTURE; +long double complex clogl(long double complex) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + +/* 7.3.8 Power and absolute-value functions */ +/* 7.3.8.1 The cabs functions */ + +#if __ANDROID_API__ >= 23 +double cabs(double complex) __INTRODUCED_IN(23); +float cabsf(float complex) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if (!defined(__LP64__) && __ANDROID_API__ >= 21) || (defined(__LP64__) && __ANDROID_API__ >= 23) +long double cabsl(long double complex) __INTRODUCED_IN_32(21) __INTRODUCED_IN_64(23); +#endif /* (!defined(__LP64__) && __ANDROID_API__ >= 21) || (defined(__LP64__) && __ANDROID_API__ >= 23) */ + +/* 7.3.8.2 The cpow functions */ + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +double complex cpow(double complex, double complex) __INTRODUCED_IN_FUTURE; +float complex cpowf(float complex, float complex) __INTRODUCED_IN_FUTURE; +long double complex cpowl(long double complex, long double complex) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + +/* 7.3.8.3 The csqrt functions */ + +#if __ANDROID_API__ >= 23 +double complex csqrt(double complex) __INTRODUCED_IN(23); +float complex csqrtf(float complex) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if (!defined(__LP64__) && __ANDROID_API__ >= 21) || (defined(__LP64__) && __ANDROID_API__ >= 23) +long double complex csqrtl(long double complex) __INTRODUCED_IN_32(21) __INTRODUCED_IN_64(23); +#endif /* (!defined(__LP64__) && __ANDROID_API__ >= 21) || (defined(__LP64__) && __ANDROID_API__ >= 23) */ + + +/* 7.3.9 Manipulation functions */ +/* 7.3.9.1 The carg functions */ + +#if __ANDROID_API__ >= 23 +double carg(double complex) __INTRODUCED_IN(23); +float cargf(float complex) __INTRODUCED_IN(23); +long double cargl(long double complex) __INTRODUCED_IN(23); +/* 7.3.9.2 The cimag functions */ +double cimag(double complex) __INTRODUCED_IN(23); +float cimagf(float complex) __INTRODUCED_IN(23); +long double cimagl(long double complex) __INTRODUCED_IN(23); +/* 7.3.9.3 The conj functions */ +double complex conj(double complex) __INTRODUCED_IN(23); +float complex conjf(float complex) __INTRODUCED_IN(23); +long double complex conjl(long double complex) __INTRODUCED_IN(23); +/* 7.3.9.4 The cproj functions */ +double complex cproj(double complex) __INTRODUCED_IN(23); +float complex cprojf(float complex) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if (!defined(__LP64__) && __ANDROID_API__ >= 21) || (defined(__LP64__) && __ANDROID_API__ >= 23) +long double complex cprojl(long double complex) __INTRODUCED_IN_32(21) __INTRODUCED_IN_64(23); +#endif /* (!defined(__LP64__) && __ANDROID_API__ >= 21) || (defined(__LP64__) && __ANDROID_API__ >= 23) */ + +/* 7.3.9.5 The creal functions */ + +#if __ANDROID_API__ >= 23 +double creal(double complex) __INTRODUCED_IN(23); +float crealf(float complex) __INTRODUCED_IN(23); +long double creall(long double complex) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +__END_DECLS + +#endif /* _COMPLEX_H */ diff --git a/headers/cpio.h b/headers/cpio.h new file mode 100644 index 000000000..ceeeb8786 --- /dev/null +++ b/headers/cpio.h @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _CPIO_H_ +#define _CPIO_H_ + +#include <sys/cdefs.h> + +#define C_IRUSR 0000400 +#define C_IWUSR 0000200 +#define C_IXUSR 0000100 +#define C_IRGRP 0000040 +#define C_IWGRP 0000020 +#define C_IXGRP 0000010 +#define C_IROTH 0000004 +#define C_IWOTH 0000002 +#define C_IXOTH 0000001 +#define C_ISUID 0004000 +#define C_ISGID 0002000 +#define C_ISVTX 0001000 +#define C_ISDIR 0040000 +#define C_ISFIFO 0010000 +#define C_ISREG 0100000 +#define C_ISBLK 0060000 +#define C_ISCHR 0020000 +#define C_ISCTG 0110000 +#define C_ISLNK 0120000 +#define C_ISSOCK 0140000 + +#define MAGIC "070707" + +#endif /* _CPIO_H_ */ diff --git a/headers/ctype.h b/headers/ctype.h new file mode 100644 index 000000000..7cae92edd --- /dev/null +++ b/headers/ctype.h @@ -0,0 +1,109 @@ +/* $OpenBSD: ctype.h,v 1.19 2005/12/13 00:35:22 millert Exp $ */ +/* $NetBSD: ctype.h,v 1.14 1994/10/26 00:55:47 cgd Exp $ */ + +/* + * Copyright (c) 1989 The Regents of the University of California. + * All rights reserved. + * (c) UNIX System Laboratories, Inc. + * All or some portions of this file are derived from material licensed + * to the University of California by American Telephone and Telegraph + * Co. or Unix System Laboratories, Inc. and are reproduced herein with + * the permission of UNIX System Laboratories, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)ctype.h 5.3 (Berkeley) 4/3/91 + */ + +#ifndef _CTYPE_H_ +#define _CTYPE_H_ + +#include <sys/cdefs.h> +#include <xlocale.h> + +#define _CTYPE_U 0x01 +#define _CTYPE_L 0x02 +#define _CTYPE_D 0x04 +#define _CTYPE_S 0x08 +#define _CTYPE_P 0x10 +#define _CTYPE_C 0x20 +#define _CTYPE_X 0x40 +#define _CTYPE_B 0x80 +#define _CTYPE_R (_CTYPE_P|_CTYPE_U|_CTYPE_L|_CTYPE_D|_CTYPE_B) +#define _CTYPE_A (_CTYPE_L|_CTYPE_U) + +/* _CTYPE_N was added to NDK r10 and is expected by gnu-libstdc++ */ +#define _CTYPE_N _CTYPE_D + +__BEGIN_DECLS + +extern const char* _ctype_; + +int isalnum(int); +int isalpha(int); +int isblank(int); +int iscntrl(int); +int isdigit(int); +int isgraph(int); +int islower(int); +int isprint(int); +int ispunct(int); +int isspace(int); +int isupper(int); +int isxdigit(int); +int tolower(int); +int toupper(int); + +#if __ANDROID_API__ >= __ANDROID_API_L__ +int isalnum_l(int, locale_t) __INTRODUCED_IN(21); +int isalpha_l(int, locale_t) __INTRODUCED_IN(21); +int isblank_l(int, locale_t) __INTRODUCED_IN(21); +int iscntrl_l(int, locale_t) __INTRODUCED_IN(21); +int isdigit_l(int, locale_t) __INTRODUCED_IN(21); +int isgraph_l(int, locale_t) __INTRODUCED_IN(21); +int islower_l(int, locale_t) __INTRODUCED_IN(21); +int isprint_l(int, locale_t) __INTRODUCED_IN(21); +int ispunct_l(int, locale_t) __INTRODUCED_IN(21); +int isspace_l(int, locale_t) __INTRODUCED_IN(21); +int isupper_l(int, locale_t) __INTRODUCED_IN(21); +int isxdigit_l(int, locale_t) __INTRODUCED_IN(21); +int tolower_l(int, locale_t) __INTRODUCED_IN(21); +int toupper_l(int, locale_t) __INTRODUCED_IN(21); +#else +// Implemented as static inlines before 21. +#endif + +int isascii(int); +int toascii(int); + +#if __ANDROID_API__ >= 21 +int _tolower(int) __INTRODUCED_IN(21); +int _toupper(int) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +__END_DECLS + +#endif /* !_CTYPE_H_ */ diff --git a/headers/dirent.h b/headers/dirent.h new file mode 100644 index 000000000..3823b831b --- /dev/null +++ b/headers/dirent.h @@ -0,0 +1,117 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _DIRENT_H_ +#define _DIRENT_H_ + +#include <stdint.h> +#include <sys/cdefs.h> + +__BEGIN_DECLS + +#ifndef DT_UNKNOWN +#define DT_UNKNOWN 0 +#define DT_FIFO 1 +#define DT_CHR 2 +#define DT_DIR 4 +#define DT_BLK 6 +#define DT_REG 8 +#define DT_LNK 10 +#define DT_SOCK 12 +#define DT_WHT 14 +#endif + +#define __DIRENT64_BODY \ + uint64_t d_ino; \ + int64_t d_off; \ + unsigned short d_reclen; \ + unsigned char d_type; \ + char d_name[256]; \ + +struct dirent { __DIRENT64_BODY }; +struct dirent64 { __DIRENT64_BODY }; + +#undef __DIRENT64_BODY + +/* glibc compatibility. */ +#undef _DIRENT_HAVE_D_NAMLEN /* Linux doesn't have a d_namlen field. */ +#define _DIRENT_HAVE_D_RECLEN +#define _DIRENT_HAVE_D_OFF +#define _DIRENT_HAVE_D_TYPE + +#define d_fileno d_ino + +typedef struct DIR DIR; + +DIR* opendir(const char*); +DIR* fdopendir(int); +struct dirent* readdir(DIR*); + +#if __ANDROID_API__ >= 21 +struct dirent64* readdir64(DIR*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int readdir_r(DIR*, struct dirent*, struct dirent**); + +#if __ANDROID_API__ >= 21 +int readdir64_r(DIR*, struct dirent64*, struct dirent64**) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int closedir(DIR*); +void rewinddir(DIR*); + +#if __ANDROID_API__ >= 23 +void seekdir(DIR*, long) __INTRODUCED_IN(23); +long telldir(DIR*) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +int dirfd(DIR*); +int alphasort(const struct dirent**, const struct dirent**); + +#if __ANDROID_API__ >= 21 +int alphasort64(const struct dirent64**, const struct dirent64**) __INTRODUCED_IN(21); +int scandir64(const char*, struct dirent64***, int (*)(const struct dirent64*), + int (*)(const struct dirent64**, const struct dirent64**)) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int scandir(const char*, struct dirent***, int (*)(const struct dirent*), int (*)(const struct dirent**, const struct dirent**)); + +#if defined(__USE_GNU) + +#if __ANDROID_API__ >= 24 +int scandirat64(int, const char*, struct dirent64***, int (*)(const struct dirent64*), + int (*)(const struct dirent64**, const struct dirent64**)) __INTRODUCED_IN(24); +int scandirat(int, const char*, struct dirent***, int (*)(const struct dirent*), + int (*)(const struct dirent**, const struct dirent**)) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + +#endif + +__END_DECLS + +#endif /* _DIRENT_H_ */ diff --git a/headers/dlfcn.h b/headers/dlfcn.h new file mode 100644 index 000000000..d365f42ee --- /dev/null +++ b/headers/dlfcn.h @@ -0,0 +1,96 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef __DLFCN_H__ +#define __DLFCN_H__ + +#include <stdint.h> +#include <sys/cdefs.h> + +__BEGIN_DECLS + +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wnullability-completeness" +#endif + +typedef struct { + /* Pathname of shared object that contains address. */ + const char* dli_fname; + /* Address at which shared object is loaded. */ + void* dli_fbase; + /* Name of nearest symbol with address lower than addr. */ + const char* dli_sname; + /* Exact address of symbol named in dli_sname. */ + void* dli_saddr; +} Dl_info; + +void* dlopen(const char* filename, int flag); +int dlclose(void* _Nonnull handle); +char* dlerror(void); +void* dlsym(void* handle, const char* _Nonnull symbol); + +#if __ANDROID_API__ >= 24 +void* dlvsym(void* handle, const char* _Nonnull symbol, const char* _Nonnull version) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + +int dladdr(const void* addr, Dl_info* _Nonnull info); + +enum { +#if defined(__LP64__) + RTLD_NOW = 2, +#else + RTLD_NOW = 0, +#endif + RTLD_LAZY = 1, + + RTLD_LOCAL = 0, +#if defined(__LP64__) + RTLD_GLOBAL = 0x00100, +#else + RTLD_GLOBAL = 2, +#endif + RTLD_NOLOAD = 4, + RTLD_NODELETE = 0x01000, +}; + +#if defined (__LP64__) +#define RTLD_DEFAULT __BIONIC_CAST(reinterpret_cast, void*, 0) +#define RTLD_NEXT __BIONIC_CAST(reinterpret_cast, void*, -1L) +#else +#define RTLD_DEFAULT __BIONIC_CAST(reinterpret_cast, void*, 0xffffffff) +#define RTLD_NEXT __BIONIC_CAST(reinterpret_cast, void*, 0xfffffffe) +#endif + +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + +__END_DECLS + +#endif /* __DLFCN_H */ diff --git a/headers/elf.h b/headers/elf.h new file mode 100644 index 000000000..ae05d3dde --- /dev/null +++ b/headers/elf.h @@ -0,0 +1,215 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _ELF_H +#define _ELF_H + +#include <sys/cdefs.h> + +#include <linux/auxvec.h> +#include <linux/elf.h> +#include <linux/elf-em.h> +#include <machine/elf_machdep.h> + +#define ELF32_R_INFO(sym, type) ((((Elf32_Word)sym) << 8) | ((type) & 0xff)) +#define ELF64_R_INFO(sym, type) ((((Elf64_Xword)sym) << 32) | ((type) & 0xffffffff)) + +typedef __s64 Elf32_Sxword; + +typedef struct { + __u32 a_type; + union { + __u32 a_val; + } a_un; +} Elf32_auxv_t; + +typedef struct { + __u64 a_type; + union { + __u64 a_val; + } a_un; +} Elf64_auxv_t; + +typedef Elf32_Half Elf32_Versym; +typedef Elf64_Half Elf64_Versym; + +typedef struct { + Elf32_Half vd_version; + Elf32_Half vd_flags; + Elf32_Half vd_ndx; + Elf32_Half vd_cnt; + Elf32_Word vd_hash; + Elf32_Word vd_aux; + Elf32_Word vd_next; +} Elf32_Verdef; + +typedef struct { + Elf32_Word vda_name; + Elf32_Word vda_next; +} Elf32_Verdaux; + +typedef struct { + Elf64_Half vd_version; + Elf64_Half vd_flags; + Elf64_Half vd_ndx; + Elf64_Half vd_cnt; + Elf64_Word vd_hash; + Elf64_Word vd_aux; + Elf64_Word vd_next; +} Elf64_Verdef; + +typedef struct { + Elf64_Word vda_name; + Elf64_Word vda_next; +} Elf64_Verdaux; + +typedef struct { + Elf32_Half vn_version; + Elf32_Half vn_cnt; + Elf32_Word vn_file; + Elf32_Word vn_aux; + Elf32_Word vn_next; +} Elf32_Verneed; + +typedef struct { + Elf32_Word vna_hash; + Elf32_Half vna_flags; + Elf32_Half vna_other; + Elf32_Word vna_name; + Elf32_Word vna_next; +} Elf32_Vernaux; + +typedef struct { + Elf64_Half vn_version; + Elf64_Half vn_cnt; + Elf64_Word vn_file; + Elf64_Word vn_aux; + Elf64_Word vn_next; +} Elf64_Verneed; + +typedef struct { + Elf64_Word vna_hash; + Elf64_Half vna_flags; + Elf64_Half vna_other; + Elf64_Word vna_name; + Elf64_Word vna_next; +} Elf64_Vernaux; + +#define DF_ORIGIN 0x00000001 +#define DF_SYMBOLIC 0x00000002 +#define DF_TEXTREL 0x00000004 +#define DF_BIND_NOW 0x00000008 +#define DF_STATIC_TLS 0x00000010 + +#define DF_1_NOW 0x00000001 /* Perform complete relocation processing. */ +#define DF_1_GLOBAL 0x00000002 /* implies RTLD_GLOBAL */ +#define DF_1_GROUP 0x00000004 +#define DF_1_NODELETE 0x00000008 /* implies RTLD_NODELETE */ +#define DF_1_LOADFLTR 0x00000010 +#define DF_1_INITFIRST 0x00000020 +#define DF_1_NOOPEN 0x00000040 /* Object can not be used with dlopen(3) */ +#define DF_1_ORIGIN 0x00000080 +#define DF_1_DIRECT 0x00000100 +#define DF_1_TRANS 0x00000200 +#define DF_1_INTERPOSE 0x00000400 +#define DF_1_NODEFLIB 0x00000800 +#define DF_1_NODUMP 0x00001000 /* Object cannot be dumped with dldump(3) */ +#define DF_1_CONFALT 0x00002000 +#define DF_1_ENDFILTEE 0x00004000 +#define DF_1_DISPRELDNE 0x00008000 +#define DF_1_DISPRELPND 0x00010000 +#define DF_1_NODIRECT 0x00020000 +#define DF_1_IGNMULDEF 0x00040000 /* Internal use */ +#define DF_1_NOKSYMS 0x00080000 /* Internal use */ +#define DF_1_NOHDR 0x00100000 /* Internal use */ +#define DF_1_EDITED 0x00200000 +#define DF_1_NORELOC 0x00400000 /* Internal use */ +#define DF_1_SYMINTPOSE 0x00800000 +#define DF_1_GLOBAUDIT 0x01000000 +#define DF_1_SINGLETON 0x02000000 +#define DF_1_STUB 0x04000000 +#define DF_1_PIE 0x08000000 + +#define DT_BIND_NOW 24 +#define DT_INIT_ARRAY 25 +#define DT_FINI_ARRAY 26 +#define DT_INIT_ARRAYSZ 27 +#define DT_FINI_ARRAYSZ 28 +#define DT_RUNPATH 29 +#define DT_FLAGS 30 +/* glibc and BSD disagree for DT_ENCODING; glibc looks wrong. */ +#define DT_PREINIT_ARRAY 32 +#define DT_PREINIT_ARRAYSZ 33 + +/* Android compressed rel/rela sections */ +#define DT_ANDROID_REL (DT_LOOS + 2) +#define DT_ANDROID_RELSZ (DT_LOOS + 3) + +#define DT_ANDROID_RELA (DT_LOOS + 4) +#define DT_ANDROID_RELASZ (DT_LOOS + 5) + +/* gnu hash entry */ +#define DT_GNU_HASH 0x6ffffef5 + +#define ELFOSABI_SYSV 0 /* Synonym for ELFOSABI_NONE used by valgrind. */ + +#define PT_GNU_RELRO 0x6474e552 + +#define STB_LOOS 10 +#define STB_HIOS 12 +#define STB_LOPROC 13 +#define STB_HIPROC 15 + +#define SHT_LOOS 0x60000000 +#define SHT_HIOS 0x6fffffff + +#define STT_GNU_IFUNC 10 +#define STT_LOOS 10 +#define STT_HIOS 12 +#define STT_LOPROC 13 +#define STT_HIPROC 15 + +#define STV_DEFAULT 0 +#define STV_INTERNAL 1 +#define STV_HIDDEN 2 +#define STV_PROTECTED 3 + +/* The kernel uses NT_PRFPREG but glibc also offers NT_FPREGSET */ +#define NT_FPREGSET NT_PRFPREG + +#define ELF_NOTE_GNU "GNU" + +#define NT_GNU_BUILD_ID 3 + +#define VER_FLG_BASE 0x1 +#define VER_FLG_WEAK 0x2 + +#define VER_NDX_LOCAL 0 +#define VER_NDX_GLOBAL 1 + +#endif /* _ELF_H */ diff --git a/headers/endian.h b/headers/endian.h new file mode 100644 index 000000000..65e29305c --- /dev/null +++ b/headers/endian.h @@ -0,0 +1 @@ +#include <sys/endian.h> diff --git a/headers/err.h b/headers/err.h new file mode 100644 index 000000000..ca62c9ec7 --- /dev/null +++ b/headers/err.h @@ -0,0 +1,58 @@ +/* $OpenBSD: err.h,v 1.10 2006/01/06 18:53:04 millert Exp $ */ +/* $NetBSD: err.h,v 1.11 1994/10/26 00:55:52 cgd Exp $ */ + +/*- + * Copyright (c) 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)err.h 8.1 (Berkeley) 6/2/93 + */ + +#ifndef _ERR_H_ +#define _ERR_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +__BEGIN_DECLS + +/* printf's format string isn't nullable; the err family's one is, + * so we can't use __errlike here. */ +#define __errlike(x, y) __attribute__((__format__(printf, x, y))) + +__noreturn void err(int, const char *, ...) __errlike(2, 3); +__noreturn void verr(int, const char *, __va_list) __errlike(2, 0); +__noreturn void errx(int, const char *, ...) __errlike(2, 3); +__noreturn void verrx(int, const char *, __va_list) __errlike(2, 0); +void warn(const char *, ...) __errlike(1, 2); +void vwarn(const char *, __va_list) __errlike(1, 0); +void warnx(const char *, ...) __errlike(1, 2); +void vwarnx(const char *, __va_list) __errlike(1, 0); + +__END_DECLS + +#endif /* !_ERR_H_ */ diff --git a/headers/errno.h b/headers/errno.h new file mode 100644 index 000000000..3f4cff90b --- /dev/null +++ b/headers/errno.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef _ERRNO_H +#define _ERRNO_H + +#include <sys/cdefs.h> +#include <linux/errno.h> + +__BEGIN_DECLS + +/* on Linux, ENOTSUP and EOPNOTSUPP are defined as the same error code + * even if 1000.3 states that they should be different + */ +#ifndef ENOTSUP +#define ENOTSUP EOPNOTSUPP +#endif + +/* internal function returning the address of the thread-specific errno */ +volatile int* __errno(void) __attribute_const__; + +/* a macro expanding to the errno l-value */ +#define errno (*__errno()) + +__END_DECLS + +#include <android/legacy_errno_inlines.h> + +#endif /* _ERRNO_H */ diff --git a/headers/error.h b/headers/error.h new file mode 100644 index 000000000..d6262a445 --- /dev/null +++ b/headers/error.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2015 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _ERROR_H +#define _ERROR_H 1 + +#include <sys/cdefs.h> + +__BEGIN_DECLS + + +#if __ANDROID_API__ >= 23 +extern void (* _Nullable error_print_progname)(void) __INTRODUCED_IN(23); +extern unsigned int error_message_count __INTRODUCED_IN(23); +extern int error_one_per_line __INTRODUCED_IN(23); + +void error(int, int, const char* _Nonnull, ...) __printflike(3, 4) __INTRODUCED_IN(23); +void error_at_line(int, int, const char* _Nullable, unsigned int, const char* _Nonnull, ...) + __printflike(5, 6) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +__END_DECLS + +#endif diff --git a/headers/fcntl.h b/headers/fcntl.h new file mode 100644 index 000000000..9efed0503 --- /dev/null +++ b/headers/fcntl.h @@ -0,0 +1,191 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _FCNTL_H +#define _FCNTL_H + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <linux/fadvise.h> +#include <linux/falloc.h> +#include <linux/fcntl.h> +#include <linux/stat.h> +#include <linux/uio.h> + +#include <bits/fcntl.h> +#include <bits/seek_constants.h> + +#if defined(__USE_GNU) || defined(__USE_BSD) +#include <bits/lockf.h> +#endif + +__BEGIN_DECLS + +#ifdef __LP64__ +/* LP64 kernels don't have F_*64 defines because their flock is 64-bit. */ +#define F_GETLK64 F_GETLK +#define F_SETLK64 F_SETLK +#define F_SETLKW64 F_SETLKW +#endif + +#define O_ASYNC FASYNC +#define O_RSYNC O_SYNC + +#define SPLICE_F_MOVE 1 +#define SPLICE_F_NONBLOCK 2 +#define SPLICE_F_MORE 4 +#define SPLICE_F_GIFT 8 + +#define SYNC_FILE_RANGE_WAIT_BEFORE 1 +#define SYNC_FILE_RANGE_WRITE 2 +#define SYNC_FILE_RANGE_WAIT_AFTER 4 + +int creat(const char*, mode_t); + +#if __ANDROID_API__ >= 21 +int creat64(const char*, mode_t) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int openat(int, const char*, int, ...); + +#if __ANDROID_API__ >= 21 +int openat64(int, const char*, int, ...) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int open(const char*, int, ...); + +#if __ANDROID_API__ >= 21 +int open64(const char*, int, ...) __INTRODUCED_IN(21); +ssize_t splice(int, off64_t*, int, off64_t*, size_t, unsigned int) __INTRODUCED_IN(21); +ssize_t tee(int, int, size_t, unsigned int) __INTRODUCED_IN(21); +ssize_t vmsplice(int, const struct iovec*, size_t, unsigned int) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +#if defined(__USE_FILE_OFFSET64) + +#if __ANDROID_API__ >= 21 +int fallocate(int, int, off_t, off_t) __RENAME(fallocate64) __INTRODUCED_IN(21); +int posix_fadvise(int, off_t, off_t, int) __RENAME(posix_fadvise64) __INTRODUCED_IN(21); +int posix_fallocate(int, off_t, off_t) __RENAME(posix_fallocate64) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +#else + +#if __ANDROID_API__ >= 21 +int fallocate(int, int, off_t, off_t) __INTRODUCED_IN(21); +int posix_fadvise(int, off_t, off_t, int) __INTRODUCED_IN(21); +int posix_fallocate(int, off_t, off_t) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +#endif + +#if __ANDROID_API__ >= 21 +int fallocate64(int, int, off64_t, off64_t) __INTRODUCED_IN(21); +int posix_fadvise64(int, off64_t, off64_t, int) __INTRODUCED_IN(21); +int posix_fallocate64(int, off64_t, off64_t) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +#if defined(__USE_GNU) + +#if __ANDROID_API__ >= 16 +ssize_t readahead(int, off64_t, size_t) __INTRODUCED_IN(16); +#endif /* __ANDROID_API__ >= 16 */ + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +int sync_file_range(int, off64_t, off64_t, unsigned int) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + +#endif + + +#if __ANDROID_API__ >= 17 +int __open_2(const char*, int) __INTRODUCED_IN(17); +#endif /* __ANDROID_API__ >= 17 */ + +int __open_real(const char*, int, ...) __RENAME(open); + +#if __ANDROID_API__ >= 17 +int __openat_2(int, const char*, int) __INTRODUCED_IN(17); +#endif /* __ANDROID_API__ >= 17 */ + +int __openat_real(int, const char*, int, ...) __RENAME(openat); +__errordecl(__creat_missing_mode, "called with O_CREAT, but missing mode"); +__errordecl(__creat_too_many_args, "too many arguments"); + +#if defined(__BIONIC_FORTIFY) + +#if !defined(__clang__) + +__BIONIC_FORTIFY_INLINE +int open(const char* pathname, int flags, ...) { + if (__builtin_constant_p(flags)) { + if ((flags & O_CREAT) && __builtin_va_arg_pack_len() == 0) { + __creat_missing_mode(); /* Compile time error. */ + } + } + + if (__builtin_va_arg_pack_len() > 1) { + __creat_too_many_args(); /* Compile time error. */ + } + + if ((__builtin_va_arg_pack_len() == 0) && !__builtin_constant_p(flags)) { + return __open_2(pathname, flags); + } + + return __open_real(pathname, flags, __builtin_va_arg_pack()); +} + +__BIONIC_FORTIFY_INLINE +int openat(int dirfd, const char* pathname, int flags, ...) { + if (__builtin_constant_p(flags)) { + if ((flags & O_CREAT) && __builtin_va_arg_pack_len() == 0) { + __creat_missing_mode(); /* Compile time error. */ + } + } + + if (__builtin_va_arg_pack_len() > 1) { + __creat_too_many_args(); /* Compile time error. */ + } + + if ((__builtin_va_arg_pack_len() == 0) && !__builtin_constant_p(flags)) { + return __openat_2(dirfd, pathname, flags); + } + + return __openat_real(dirfd, pathname, flags, __builtin_va_arg_pack()); +} + +#endif /* !defined(__clang__) */ + +#endif /* defined(__BIONIC_FORTIFY) */ + +__END_DECLS + +#endif /* _FCNTL_H */ diff --git a/headers/features.h b/headers/features.h new file mode 100644 index 000000000..a279c7f0e --- /dev/null +++ b/headers/features.h @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _FEATURES_H_ +#define _FEATURES_H_ + +/* Our <features.h> macro fun is all in <sys/cdefs.h>. */ +#include <sys/cdefs.h> + +#endif /* _FEATURES_H_ */ diff --git a/headers/fenv.h b/headers/fenv.h new file mode 100644 index 000000000..a4c37e62f --- /dev/null +++ b/headers/fenv.h @@ -0,0 +1,80 @@ +/* $OpenBSD: fenv.h,v 1.2 2011/05/25 21:46:49 martynas Exp $ */ +/* $NetBSD: fenv.h,v 1.2.4.1 2011/02/08 16:18:55 bouyer Exp $ */ + +/* + * Copyright (c) 2010 The NetBSD Foundation, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _FENV_H_ +#define _FENV_H_ + +#include <sys/cdefs.h> +#include <machine/fenv.h> + +__BEGIN_DECLS + +// fenv was always available on x86. +#if __ANDROID_API__ >= __ANDROID_API_L__ || defined(__i386__) +int feclearexcept(int) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9); +int fegetexceptflag(fexcept_t*, int) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) + __INTRODUCED_IN_X86(9); +int feraiseexcept(int) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9); +int fesetexceptflag(const fexcept_t*, int) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) + __INTRODUCED_IN_X86(9); +int fetestexcept(int) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9); + +int fegetround(void) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9); +int fesetround(int) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9); + +int fegetenv(fenv_t*) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9); +int feholdexcept(fenv_t*) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9); +int fesetenv(const fenv_t*) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9); +int feupdateenv(const fenv_t*) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) + __INTRODUCED_IN_X86(9); + +int feenableexcept(int) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9); +int fedisableexcept(int) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9); +int fegetexcept(void) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9); +#else +/* Defined as inlines for pre-21 ARM and MIPS. */ +#endif + +/* + * The following constant represents the default floating-point environment + * (that is, the one installed at program startup) and has type pointer to + * const-qualified fenv_t. + * + * It can be used as an argument to the functions that manage the floating-point + * environment, namely fesetenv() and feupdateenv(). + */ +extern const fenv_t __fe_dfl_env; +#define FE_DFL_ENV (&__fe_dfl_env) + +__END_DECLS + +#include <android/legacy_fenv_inlines_arm.h> +#include <android/legacy_fenv_inlines_mips.h> + +#endif /* ! _FENV_H_ */ diff --git a/headers/fnmatch.h b/headers/fnmatch.h new file mode 100644 index 000000000..1a5348b93 --- /dev/null +++ b/headers/fnmatch.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef _FNMATCH_H +#define _FNMATCH_H + +#include <sys/cdefs.h> + +__BEGIN_DECLS + +#define FNM_NOMATCH 1 /* Match failed. */ +#define FNM_NOSYS 2 /* Function not supported (unused). */ + +#define FNM_NOESCAPE 0x01 /* Disable backslash escaping. */ +#define FNM_PATHNAME 0x02 /* Slash must be matched by slash. */ +#define FNM_PERIOD 0x04 /* Period must be matched by period. */ +#define FNM_LEADING_DIR 0x08 /* Ignore /<tail> after Imatch. */ +#define FNM_CASEFOLD 0x10 /* Case insensitive search. */ + +#define FNM_IGNORECASE FNM_CASEFOLD +#define FNM_FILE_NAME FNM_PATHNAME + +int fnmatch(const char* pattern, const char* string, int flags); + +__END_DECLS + +#endif /* _FNMATCH_H */ diff --git a/headers/fts.h b/headers/fts.h new file mode 100644 index 000000000..b46c19c09 --- /dev/null +++ b/headers/fts.h @@ -0,0 +1,126 @@ +/* $OpenBSD: fts.h,v 1.12 2009/08/27 16:19:27 millert Exp $ */ +/* $NetBSD: fts.h,v 1.5 1994/12/28 01:41:50 mycroft Exp $ */ + +/* + * Copyright (c) 1989, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)fts.h 8.3 (Berkeley) 8/14/94 + */ + +#ifndef _FTS_H_ +#define _FTS_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +typedef struct { + struct _ftsent *fts_cur; /* current node */ + struct _ftsent *fts_child; /* linked list of children */ + struct _ftsent **fts_array; /* sort array */ + dev_t fts_dev; /* starting device # */ + char *fts_path; /* path for this descent */ + int fts_rfd; /* fd for root */ + size_t fts_pathlen; /* sizeof(path) */ + int fts_nitems; /* elements in the sort array */ + int (*fts_compar)(); /* compare function */ + +#define FTS_COMFOLLOW 0x0001 /* follow command line symlinks */ +#define FTS_LOGICAL 0x0002 /* logical walk */ +#define FTS_NOCHDIR 0x0004 /* don't change directories */ +#define FTS_NOSTAT 0x0008 /* don't get stat info */ +#define FTS_PHYSICAL 0x0010 /* physical walk */ +#define FTS_SEEDOT 0x0020 /* return dot and dot-dot */ +#define FTS_XDEV 0x0040 /* don't cross devices */ +#define FTS_OPTIONMASK 0x00ff /* valid user option mask */ + +#define FTS_NAMEONLY 0x1000 /* (private) child names only */ +#define FTS_STOP 0x2000 /* (private) unrecoverable error */ + int fts_options; /* fts_open options, global flags */ +} FTS; + +typedef struct _ftsent { + struct _ftsent *fts_cycle; /* cycle node */ + struct _ftsent *fts_parent; /* parent directory */ + struct _ftsent *fts_link; /* next file in directory */ + long fts_number; /* local numeric value */ + void *fts_pointer; /* local address value */ + char *fts_accpath; /* access path */ + char *fts_path; /* root path */ + int fts_errno; /* errno for this node */ + int fts_symfd; /* fd for symlink */ + size_t fts_pathlen; /* strlen(fts_path) */ + size_t fts_namelen; /* strlen(fts_name) */ + + ino_t fts_ino; /* inode */ + dev_t fts_dev; /* device */ + nlink_t fts_nlink; /* link count */ + +#define FTS_ROOTPARENTLEVEL -1 +#define FTS_ROOTLEVEL 0 +#define FTS_MAXLEVEL 0x7fff + short fts_level; /* depth (-1 to N) */ + +#define FTS_D 1 /* preorder directory */ +#define FTS_DC 2 /* directory that causes cycles */ +#define FTS_DEFAULT 3 /* none of the above */ +#define FTS_DNR 4 /* unreadable directory */ +#define FTS_DOT 5 /* dot or dot-dot */ +#define FTS_DP 6 /* postorder directory */ +#define FTS_ERR 7 /* error; errno is set */ +#define FTS_F 8 /* regular file */ +#define FTS_INIT 9 /* initialized only */ +#define FTS_NS 10 /* stat(2) failed */ +#define FTS_NSOK 11 /* no stat(2) requested */ +#define FTS_SL 12 /* symbolic link */ +#define FTS_SLNONE 13 /* symbolic link without target */ + unsigned short fts_info; /* user flags for FTSENT structure */ + +#define FTS_DONTCHDIR 0x01 /* don't chdir .. to the parent */ +#define FTS_SYMFOLLOW 0x02 /* followed a symlink to get here */ + unsigned short fts_flags; /* private flags for FTSENT structure */ + +#define FTS_AGAIN 1 /* read node again */ +#define FTS_FOLLOW 2 /* follow symbolic link */ +#define FTS_NOINSTR 3 /* no instructions */ +#define FTS_SKIP 4 /* discard node */ + unsigned short fts_instr; /* fts_set() instructions */ + + struct stat *fts_statp; /* stat(2) information */ + char fts_name[1]; /* file name */ +} FTSENT; + +__BEGIN_DECLS +FTSENT *fts_children(FTS *, int); +int fts_close(FTS *); +FTS *fts_open(char * const *, int, + int (*)(const FTSENT **, const FTSENT **)); +FTSENT *fts_read(FTS *); +int fts_set(FTS *, FTSENT *, int); +__END_DECLS + +#endif /* !_FTS_H_ */ diff --git a/headers/ftw.h b/headers/ftw.h new file mode 100644 index 000000000..fd9c62e26 --- /dev/null +++ b/headers/ftw.h @@ -0,0 +1,74 @@ +/* $NetBSD: ftw.h,v 1.1 2005/12/30 23:07:33 agc Exp $ */ + +/* From OpenBSD: ftw.h,v 1.1 2003/07/21 21:13:18 millert Exp */ + +/* + * Copyright (c) 2003 Todd C. Miller <Todd.Miller@courtesan.com> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Sponsored in part by the Defense Advanced Research Projects + * Agency (DARPA) and Air Force Research Laboratory, Air Force + * Materiel Command, USAF, under agreement number F39502-99-1-0512. + */ + +#ifndef _FTW_H +#define _FTW_H + +#include <sys/cdefs.h> +#include <sys/stat.h> +#include <sys/types.h> + +/* + * Valid flags for the 3rd argument to the function that is passed as the + * second argument to ftw(3) and nftw(3). Say it three times fast! + */ +#define FTW_F 0 /* File. */ +#define FTW_D 1 /* Directory. */ +#define FTW_DNR 2 /* Directory without read permission. */ +#define FTW_DP 3 /* Directory with subdirectories visited. */ +#define FTW_NS 4 /* Unknown type; stat() failed. */ +#define FTW_SL 5 /* Symbolic link. */ +#define FTW_SLN 6 /* Sym link that names a nonexistent file. */ + +/* + * Flags for use as the 4th argument to nftw(3). These may be ORed together. + */ +#define FTW_PHYS 0x01 /* Physical walk, don't follow sym links. */ +#define FTW_MOUNT 0x02 /* The walk does not cross a mount point. */ +#define FTW_DEPTH 0x04 /* Subdirs visited before the dir itself. */ +#define FTW_CHDIR 0x08 /* Change to a directory before reading it. */ + +struct FTW { + int base; + int level; +}; + +__BEGIN_DECLS + +#if __ANDROID_API__ >= 17 +int ftw(const char*, int (*)(const char*, const struct stat*, int), int) __INTRODUCED_IN(17); +int nftw(const char*, int (*)(const char*, const struct stat*, int, struct FTW*), int, int) + __INTRODUCED_IN(17); +#endif /* __ANDROID_API__ >= 17 */ + + +#if __ANDROID_API__ >= 21 +int ftw64(const char*, int (*)(const char*, const struct stat64*, int), int) __INTRODUCED_IN(21); +int nftw64(const char*, int (*)(const char*, const struct stat64*, int, struct FTW*), int, int) + __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +__END_DECLS + +#endif /* !_FTW_H */ diff --git a/headers/getopt.h b/headers/getopt.h new file mode 100644 index 000000000..46d2eb79c --- /dev/null +++ b/headers/getopt.h @@ -0,0 +1,73 @@ +/* $NetBSD: getopt.h,v 1.4 2000/07/07 10:43:54 ad Exp $ */ +/* $FreeBSD$ */ + +/*- + * Copyright (c) 2000 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by Dieter Baron and Thomas Klausner. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _GETOPT_H_ +#define _GETOPT_H_ + +#include <sys/cdefs.h> + +#include <bits/getopt.h> + +/* + * GNU-like getopt_long()/getopt_long_only() with 4.4BSD optreset extension. + */ +#define no_argument 0 +#define required_argument 1 +#define optional_argument 2 + +struct option { + /* name of long option */ + const char *name; + /* + * one of no_argument, required_argument, and optional_argument: + * whether option takes an argument + */ + int has_arg; + /* if not NULL, set *flag to val when option found */ + int *flag; + /* if flag not NULL, value to set *flag to; else return value */ + int val; +}; + +__BEGIN_DECLS +int getopt_long(int, char * const *, const char *, + const struct option *, int *); +int getopt_long_only(int, char * const *, const char *, + const struct option *, int *); + +#ifndef _OPTRESET_DECLARED +#define _OPTRESET_DECLARED +extern int optreset; /* getopt(3) external variable */ +#endif +__END_DECLS + +#endif /* !_GETOPT_H_ */ diff --git a/headers/grp.h b/headers/grp.h new file mode 100644 index 000000000..3dbead52f --- /dev/null +++ b/headers/grp.h @@ -0,0 +1,73 @@ +/*- + * Copyright (c) 1989, 1993 + * The Regents of the University of California. All rights reserved. + * (c) UNIX System Laboratories, Inc. + * All or some portions of this file are derived from material licensed + * to the University of California by American Telephone and Telegraph + * Co. or Unix System Laboratories, Inc. and are reproduced herein with + * the permission of UNIX System Laboratories, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _GRP_H_ +#define _GRP_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +struct group { + char* gr_name; /* group name */ + char* gr_passwd; /* group password */ + gid_t gr_gid; /* group id */ + char** gr_mem; /* group members */ +}; + +__BEGIN_DECLS + +struct group* getgrgid(gid_t); +struct group* getgrnam(const char*); + +/* Note: Android has thousands and thousands of ids to iterate through. */ + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +struct group* getgrent(void) __INTRODUCED_IN_FUTURE; + +void setgrent(void) __INTRODUCED_IN_FUTURE; +void endgrent(void) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + +#if __ANDROID_API__ >= 24 +int getgrgid_r(gid_t, struct group*, char*, size_t, struct group**) __INTRODUCED_IN(24); +int getgrnam_r(const char*, struct group*, char*, size_t, struct group**) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + +int getgrouplist (const char*, gid_t, gid_t*, int*); +int initgroups (const char*, gid_t); + +__END_DECLS + +#endif /* !_GRP_H_ */ diff --git a/headers/ifaddrs.h b/headers/ifaddrs.h new file mode 100644 index 000000000..ed3c1a4f4 --- /dev/null +++ b/headers/ifaddrs.h @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2015 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _IFADDRS_H_ +#define _IFADDRS_H_ + +#include <sys/cdefs.h> +#include <netinet/in.h> +#include <sys/socket.h> + +__BEGIN_DECLS + +struct ifaddrs { + struct ifaddrs* ifa_next; + char* ifa_name; + unsigned int ifa_flags; + struct sockaddr* ifa_addr; + struct sockaddr* ifa_netmask; + union { + struct sockaddr* ifu_broadaddr; + struct sockaddr* ifu_dstaddr; + } ifa_ifu; + void* ifa_data; +}; + +#define ifa_broadaddr ifa_ifu.ifu_broadaddr +#define ifa_dstaddr ifa_ifu.ifu_dstaddr + + +#if __ANDROID_API__ >= 24 +void freeifaddrs(struct ifaddrs*) __INTRODUCED_IN(24); +int getifaddrs(struct ifaddrs**) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + + +__END_DECLS + +#endif diff --git a/headers/inttypes.h b/headers/inttypes.h new file mode 100644 index 000000000..f1d9c764f --- /dev/null +++ b/headers/inttypes.h @@ -0,0 +1,274 @@ +/* $OpenBSD: inttypes.h,v 1.9 2006/01/15 00:47:51 millert Exp $ */ + +/* + * Copyright (c) 1997, 2005 Todd C. Miller <Todd.Miller@courtesan.com> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _INTTYPES_H_ +#define _INTTYPES_H_ + +#include <stdint.h> +#include <sys/cdefs.h> + +#ifdef __LP64__ +#define __PRI_64_prefix "l" +#define __PRI_PTR_prefix "l" +#else +#define __PRI_64_prefix "ll" +#define __PRI_PTR_prefix +#endif +#define __PRI_FAST_prefix __PRI_PTR_prefix + +/* + * 7.8.1 Macros for format specifiers + * + * Each of the following object-like macros expands to a string + * literal containing a conversion specifier, possibly modified by + * a prefix such as hh, h, l, or ll, suitable for use within the + * format argument of a formatted input/output function when + * converting the corresponding integer type. These macro names + * have the general form of PRI (character string literals for the + * fprintf family) or SCN (character string literals for the fscanf + * family), followed by the conversion specifier, followed by a + * name corresponding to a similar typedef name. For example, + * PRIdFAST32 can be used in a format string to print the value of + * an integer of type int_fast32_t. + */ + +/* fprintf macros for signed integers */ +#define PRId8 "d" /* int8_t */ +#define PRId16 "d" /* int16_t */ +#define PRId32 "d" /* int32_t */ +#define PRId64 __PRI_64_prefix"d" /* int64_t */ + +#define PRIdLEAST8 "d" /* int_least8_t */ +#define PRIdLEAST16 "d" /* int_least16_t */ +#define PRIdLEAST32 "d" /* int_least32_t */ +#define PRIdLEAST64 __PRI_64_prefix"d" /* int_least64_t */ + +#define PRIdFAST8 "d" /* int_fast8_t */ +#define PRIdFAST16 __PRI_FAST_prefix"d" /* int_fast16_t */ +#define PRIdFAST32 __PRI_FAST_prefix"d" /* int_fast32_t */ +#define PRIdFAST64 __PRI_64_prefix"d" /* int_fast64_t */ + +#define PRIdMAX "jd" /* intmax_t */ +#define PRIdPTR __PRI_PTR_prefix"d" /* intptr_t */ + +#define PRIi8 "i" /* int8_t */ +#define PRIi16 "i" /* int16_t */ +#define PRIi32 "i" /* int32_t */ +#define PRIi64 __PRI_64_prefix"i" /* int64_t */ + +#define PRIiLEAST8 "i" /* int_least8_t */ +#define PRIiLEAST16 "i" /* int_least16_t */ +#define PRIiLEAST32 "i" /* int_least32_t */ +#define PRIiLEAST64 __PRI_64_prefix"i" /* int_least64_t */ + +#define PRIiFAST8 "i" /* int_fast8_t */ +#define PRIiFAST16 __PRI_FAST_prefix"i" /* int_fast16_t */ +#define PRIiFAST32 __PRI_FAST_prefix"i" /* int_fast32_t */ +#define PRIiFAST64 __PRI_64_prefix"i" /* int_fast64_t */ + +#define PRIiMAX "ji" /* intmax_t */ +#define PRIiPTR __PRI_PTR_prefix"i" /* intptr_t */ + +/* fprintf macros for unsigned integers */ +#define PRIo8 "o" /* int8_t */ +#define PRIo16 "o" /* int16_t */ +#define PRIo32 "o" /* int32_t */ +#define PRIo64 __PRI_64_prefix"o" /* int64_t */ + +#define PRIoLEAST8 "o" /* int_least8_t */ +#define PRIoLEAST16 "o" /* int_least16_t */ +#define PRIoLEAST32 "o" /* int_least32_t */ +#define PRIoLEAST64 __PRI_64_prefix"o" /* int_least64_t */ + +#define PRIoFAST8 "o" /* int_fast8_t */ +#define PRIoFAST16 __PRI_FAST_prefix"o" /* int_fast16_t */ +#define PRIoFAST32 __PRI_FAST_prefix"o" /* int_fast32_t */ +#define PRIoFAST64 __PRI_64_prefix"o" /* int_fast64_t */ + +#define PRIoMAX "jo" /* intmax_t */ +#define PRIoPTR __PRI_PTR_prefix"o" /* intptr_t */ + +#define PRIu8 "u" /* uint8_t */ +#define PRIu16 "u" /* uint16_t */ +#define PRIu32 "u" /* uint32_t */ +#define PRIu64 __PRI_64_prefix"u" /* uint64_t */ + +#define PRIuLEAST8 "u" /* uint_least8_t */ +#define PRIuLEAST16 "u" /* uint_least16_t */ +#define PRIuLEAST32 "u" /* uint_least32_t */ +#define PRIuLEAST64 __PRI_64_prefix"u" /* uint_least64_t */ + +#define PRIuFAST8 "u" /* uint_fast8_t */ +#define PRIuFAST16 __PRI_FAST_prefix"u" /* uint_fast16_t */ +#define PRIuFAST32 __PRI_FAST_prefix"u" /* uint_fast32_t */ +#define PRIuFAST64 __PRI_64_prefix"u" /* uint_fast64_t */ + +#define PRIuMAX "ju" /* uintmax_t */ +#define PRIuPTR __PRI_PTR_prefix"u" /* uintptr_t */ + +#define PRIx8 "x" /* uint8_t */ +#define PRIx16 "x" /* uint16_t */ +#define PRIx32 "x" /* uint32_t */ +#define PRIx64 __PRI_64_prefix"x" /* uint64_t */ + +#define PRIxLEAST8 "x" /* uint_least8_t */ +#define PRIxLEAST16 "x" /* uint_least16_t */ +#define PRIxLEAST32 "x" /* uint_least32_t */ +#define PRIxLEAST64 __PRI_64_prefix"x" /* uint_least64_t */ + +#define PRIxFAST8 "x" /* uint_fast8_t */ +#define PRIxFAST16 __PRI_FAST_prefix"x" /* uint_fast16_t */ +#define PRIxFAST32 __PRI_FAST_prefix"x" /* uint_fast32_t */ +#define PRIxFAST64 __PRI_64_prefix"x" /* uint_fast64_t */ + +#define PRIxMAX "jx" /* uintmax_t */ +#define PRIxPTR __PRI_PTR_prefix"x" /* uintptr_t */ + +#define PRIX8 "X" /* uint8_t */ +#define PRIX16 "X" /* uint16_t */ +#define PRIX32 "X" /* uint32_t */ +#define PRIX64 __PRI_64_prefix"X" /* uint64_t */ + +#define PRIXLEAST8 "X" /* uint_least8_t */ +#define PRIXLEAST16 "X" /* uint_least16_t */ +#define PRIXLEAST32 "X" /* uint_least32_t */ +#define PRIXLEAST64 __PRI_64_prefix"X" /* uint_least64_t */ + +#define PRIXFAST8 "X" /* uint_fast8_t */ +#define PRIXFAST16 __PRI_FAST_prefix"X" /* uint_fast16_t */ +#define PRIXFAST32 __PRI_FAST_prefix"X" /* uint_fast32_t */ +#define PRIXFAST64 __PRI_64_prefix"X" /* uint_fast64_t */ + +#define PRIXMAX "jX" /* uintmax_t */ +#define PRIXPTR __PRI_PTR_prefix"X" /* uintptr_t */ + +/* fscanf macros for signed integers */ +#define SCNd8 "hhd" /* int8_t */ +#define SCNd16 "hd" /* int16_t */ +#define SCNd32 "d" /* int32_t */ +#define SCNd64 __PRI_64_prefix"d" /* int64_t */ + +#define SCNdLEAST8 "hhd" /* int_least8_t */ +#define SCNdLEAST16 "hd" /* int_least16_t */ +#define SCNdLEAST32 "d" /* int_least32_t */ +#define SCNdLEAST64 __PRI_64_prefix"d" /* int_least64_t */ + +#define SCNdFAST8 "hhd" /* int_fast8_t */ +#define SCNdFAST16 __PRI_FAST_prefix"d" /* int_fast16_t */ +#define SCNdFAST32 __PRI_FAST_prefix"d" /* int_fast32_t */ +#define SCNdFAST64 __PRI_64_prefix"d" /* int_fast64_t */ + +#define SCNdMAX "jd" /* intmax_t */ +#define SCNdPTR __PRI_PTR_prefix"d" /* intptr_t */ + +#define SCNi8 "hhi" /* int8_t */ +#define SCNi16 "hi" /* int16_t */ +#define SCNi32 "i" /* int32_t */ +#define SCNi64 __PRI_64_prefix"i" /* int64_t */ + +#define SCNiLEAST8 "hhi" /* int_least8_t */ +#define SCNiLEAST16 "hi" /* int_least16_t */ +#define SCNiLEAST32 "i" /* int_least32_t */ +#define SCNiLEAST64 __PRI_64_prefix"i" /* int_least64_t */ + +#define SCNiFAST8 "hhi" /* int_fast8_t */ +#define SCNiFAST16 __PRI_FAST_prefix"i" /* int_fast16_t */ +#define SCNiFAST32 __PRI_FAST_prefix"i" /* int_fast32_t */ +#define SCNiFAST64 __PRI_64_prefix"i" /* int_fast64_t */ + +#define SCNiMAX "ji" /* intmax_t */ +#define SCNiPTR __PRI_PTR_prefix"i" /* intptr_t */ + +/* fscanf macros for unsigned integers */ +#define SCNo8 "hho" /* uint8_t */ +#define SCNo16 "ho" /* uint16_t */ +#define SCNo32 "o" /* uint32_t */ +#define SCNo64 __PRI_64_prefix"o" /* uint64_t */ + +#define SCNoLEAST8 "hho" /* uint_least8_t */ +#define SCNoLEAST16 "ho" /* uint_least16_t */ +#define SCNoLEAST32 "o" /* uint_least32_t */ +#define SCNoLEAST64 __PRI_64_prefix"o" /* uint_least64_t */ + +#define SCNoFAST8 "hho" /* uint_fast8_t */ +#define SCNoFAST16 __PRI_FAST_prefix"o" /* uint_fast16_t */ +#define SCNoFAST32 __PRI_FAST_prefix"o" /* uint_fast32_t */ +#define SCNoFAST64 __PRI_64_prefix"o" /* uint_fast64_t */ + +#define SCNoMAX "jo" /* uintmax_t */ +#define SCNoPTR __PRI_PTR_prefix"o" /* uintptr_t */ + +#define SCNu8 "hhu" /* uint8_t */ +#define SCNu16 "hu" /* uint16_t */ +#define SCNu32 "u" /* uint32_t */ +#define SCNu64 __PRI_64_prefix"u" /* uint64_t */ + +#define SCNuLEAST8 "hhu" /* uint_least8_t */ +#define SCNuLEAST16 "hu" /* uint_least16_t */ +#define SCNuLEAST32 "u" /* uint_least32_t */ +#define SCNuLEAST64 __PRI_64_prefix"u" /* uint_least64_t */ + +#define SCNuFAST8 "hhu" /* uint_fast8_t */ +#define SCNuFAST16 __PRI_FAST_prefix"u" /* uint_fast16_t */ +#define SCNuFAST32 __PRI_FAST_prefix"u" /* uint_fast32_t */ +#define SCNuFAST64 __PRI_64_prefix"u" /* uint_fast64_t */ + +#define SCNuMAX "ju" /* uintmax_t */ +#define SCNuPTR __PRI_PTR_prefix"u" /* uintptr_t */ + +#define SCNx8 "hhx" /* uint8_t */ +#define SCNx16 "hx" /* uint16_t */ +#define SCNx32 "x" /* uint32_t */ +#define SCNx64 __PRI_64_prefix"x" /* uint64_t */ + +#define SCNxLEAST8 "hhx" /* uint_least8_t */ +#define SCNxLEAST16 "hx" /* uint_least16_t */ +#define SCNxLEAST32 "x" /* uint_least32_t */ +#define SCNxLEAST64 __PRI_64_prefix"x" /* uint_least64_t */ + +#define SCNxFAST8 "hhx" /* uint_fast8_t */ +#define SCNxFAST16 __PRI_FAST_prefix"x" /* uint_fast16_t */ +#define SCNxFAST32 __PRI_FAST_prefix"x" /* uint_fast32_t */ +#define SCNxFAST64 __PRI_64_prefix"x" /* uint_fast64_t */ + +#define SCNxMAX "jx" /* uintmax_t */ +#define SCNxPTR __PRI_PTR_prefix"x" /* uintptr_t */ + +typedef struct { + intmax_t quot; /* quotient */ + intmax_t rem; /* remainder */ +} imaxdiv_t; + +__BEGIN_DECLS + +#if __ANDROID_API__ >= 19 +intmax_t imaxabs(intmax_t) __attribute_const__ __INTRODUCED_IN(19); +imaxdiv_t imaxdiv(intmax_t, intmax_t) __attribute_const__ __INTRODUCED_IN(19); +#endif /* __ANDROID_API__ >= 19 */ + +intmax_t strtoimax(const char *, char **, int); +uintmax_t strtoumax(const char *, char **, int); + +#if __ANDROID_API__ >= 21 +intmax_t wcstoimax(const wchar_t* __restrict, wchar_t** __restrict, int) __INTRODUCED_IN(21); +uintmax_t wcstoumax(const wchar_t* __restrict, wchar_t** __restrict, int) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +__END_DECLS + +#endif /* _INTTYPES_H_ */ diff --git a/headers/langinfo.h b/headers/langinfo.h new file mode 100644 index 000000000..17306f7d5 --- /dev/null +++ b/headers/langinfo.h @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _LANGINFO_H_ +#define _LANGINFO_H_ + +#include <sys/cdefs.h> + +#include <nl_types.h> +#include <xlocale.h> + +__BEGIN_DECLS + +#define CODESET 1 +#define D_T_FMT 2 +#define D_FMT 3 +#define T_FMT 4 +#define T_FMT_AMPM 5 +#define AM_STR 6 +#define PM_STR 7 +#define DAY_1 8 +#define DAY_2 9 +#define DAY_3 10 +#define DAY_4 11 +#define DAY_5 12 +#define DAY_6 13 +#define DAY_7 14 +#define ABDAY_1 15 +#define ABDAY_2 16 +#define ABDAY_3 17 +#define ABDAY_4 18 +#define ABDAY_5 19 +#define ABDAY_6 20 +#define ABDAY_7 21 +#define MON_1 22 +#define MON_2 23 +#define MON_3 24 +#define MON_4 25 +#define MON_5 26 +#define MON_6 27 +#define MON_7 28 +#define MON_8 29 +#define MON_9 30 +#define MON_10 31 +#define MON_11 32 +#define MON_12 33 +#define ABMON_1 34 +#define ABMON_2 35 +#define ABMON_3 36 +#define ABMON_4 37 +#define ABMON_5 38 +#define ABMON_6 39 +#define ABMON_7 40 +#define ABMON_8 41 +#define ABMON_9 42 +#define ABMON_10 43 +#define ABMON_11 44 +#define ABMON_12 45 +#define ERA 46 +#define ERA_D_FMT 47 +#define ERA_D_T_FMT 48 +#define ERA_T_FMT 49 +#define ALT_DIGITS 50 +#define RADIXCHAR 51 +#define THOUSEP 52 +#define YESEXPR 53 +#define NOEXPR 54 +#define CRNCYSTR 55 + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +char* nl_langinfo(nl_item) __INTRODUCED_IN_FUTURE; +char* nl_langinfo_l(nl_item, locale_t) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + +__END_DECLS + +#endif diff --git a/headers/lastlog.h b/headers/lastlog.h new file mode 100644 index 000000000..4f461067e --- /dev/null +++ b/headers/lastlog.h @@ -0,0 +1,2 @@ +/* This is a BSD synonym for <utmp.h> that's also provided by glibc. */ +#include <utmp.h> diff --git a/headers/libgen.h b/headers/libgen.h new file mode 100644 index 000000000..f864ee109 --- /dev/null +++ b/headers/libgen.h @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _LIBGEN_H +#define _LIBGEN_H + +#include <sys/cdefs.h> +#include <sys/types.h> + + +__BEGIN_DECLS + +/* + * Including <string.h> will get you the GNU basename, unless <libgen.h> is + * included, either before or after including <string.h>. + * + * Note that this has the wrong argument cv-qualifiers, but doesn't modify its + * input and uses thread-local storage for the result if necessary. + */ +char* __posix_basename(const char*) __RENAME(basename); + +#define basename __posix_basename + +/* This has the wrong argument cv-qualifiers, but doesn't modify its input and uses thread-local storage for the result if necessary. */ +char* dirname(const char*); + +#if !defined(__LP64__) +/* These non-standard functions are not needed on Android; basename and dirname use thread-local storage. */ +int dirname_r(const char*, char*, size_t); +int basename_r(const char*, char*, size_t); +#endif + +__END_DECLS + +#endif /* _LIBGEN_H */ diff --git a/headers/limits.h b/headers/limits.h new file mode 100644 index 000000000..a25eb6595 --- /dev/null +++ b/headers/limits.h @@ -0,0 +1,152 @@ +/* $OpenBSD: limits.h,v 1.13 2005/12/31 19:29:38 millert Exp $ */ +/* $NetBSD: limits.h,v 1.7 1994/10/26 00:56:00 cgd Exp $ */ + +/* + * Copyright (c) 1988 The Regents of the University of California. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)limits.h 5.9 (Berkeley) 4/3/91 + */ + +#ifndef _LIMITS_H_ +#define _LIMITS_H_ + +#include <sys/cdefs.h> + +/* Historically bionic exposed the content of <float.h> from <limits.h> and <sys/limits.h> too. */ +#include <float.h> + +#include <linux/limits.h> + +#define PASS_MAX 128 /* _PASSWORD_LEN from <pwd.h> */ + +#define NL_ARGMAX 9 +#define NL_LANGMAX 14 +#define NL_MSGMAX 32767 +#define NL_NMAX 1 +#define NL_SETMAX 255 +#define NL_TEXTMAX 255 + +#define TMP_MAX 308915776 + +/* TODO: get all these from the compiler's <limits.h>? */ + +#define CHAR_BIT 8 +#ifdef __LP64__ +# define LONG_BIT 64 +#else +# define LONG_BIT 32 +#endif + +#define SCHAR_MAX 0x7f /* max value for a signed char */ +#define SCHAR_MIN (-0x7f-1) /* min value for a signed char */ + +#define UCHAR_MAX 0xffU /* max value for an unsigned char */ +#ifdef __CHAR_UNSIGNED__ +# define CHAR_MIN 0 /* min value for a char */ +# define CHAR_MAX 0xff /* max value for a char */ +#else +# define CHAR_MAX 0x7f +# define CHAR_MIN (-0x7f-1) +#endif + +#define USHRT_MAX 0xffffU /* max value for an unsigned short */ +#define SHRT_MAX 0x7fff /* max value for a short */ +#define SHRT_MIN (-0x7fff-1) /* min value for a short */ + +#define UINT_MAX 0xffffffffU /* max value for an unsigned int */ +#define INT_MAX 0x7fffffff /* max value for an int */ +#define INT_MIN (-0x7fffffff-1) /* min value for an int */ + +#ifdef __LP64__ +# define ULONG_MAX 0xffffffffffffffffUL /* max value for unsigned long */ +# define LONG_MAX 0x7fffffffffffffffL /* max value for a signed long */ +# define LONG_MIN (-0x7fffffffffffffffL-1) /* min value for a signed long */ +#else +# define ULONG_MAX 0xffffffffUL /* max value for an unsigned long */ +# define LONG_MAX 0x7fffffffL /* max value for a long */ +# define LONG_MIN (-0x7fffffffL-1)/* min value for a long */ +#endif + +# define ULLONG_MAX 0xffffffffffffffffULL /* max value for unsigned long long */ +# define LLONG_MAX 0x7fffffffffffffffLL /* max value for a signed long long */ +# define LLONG_MIN (-0x7fffffffffffffffLL-1) /* min value for a signed long long */ + +/* GLibc compatibility definitions. + Note that these are defined by GCC's <limits.h> + only when __GNU_LIBRARY__ is defined, i.e. when + targetting GLibc. */ +#ifndef LONG_LONG_MIN +#define LONG_LONG_MIN LLONG_MIN +#endif + +#ifndef LONG_LONG_MAX +#define LONG_LONG_MAX LLONG_MAX +#endif + +#ifndef ULONG_LONG_MAX +#define ULONG_LONG_MAX ULLONG_MAX +#endif + +#if defined(__USE_BSD) || defined(__BIONIC__) /* Historically bionic exposed these. */ +# define UID_MAX UINT_MAX /* max value for a uid_t */ +# define GID_MAX UINT_MAX /* max value for a gid_t */ +#if defined(__LP64__) +#define SIZE_T_MAX ULONG_MAX +#else +#define SIZE_T_MAX UINT_MAX +#endif +#endif + +#if defined(__LP64__) +#define SSIZE_MAX LONG_MAX +#else +#define SSIZE_MAX INT_MAX +#endif + +#define MB_LEN_MAX 4 + +#define IOV_MAX 1024 +#define SEM_VALUE_MAX 0x3fffffff + +/* POSIX says these belong in <unistd.h> but BSD has some in <limits.h>. */ +#include <bits/posix_limits.h> + +#define HOST_NAME_MAX _POSIX_HOST_NAME_MAX + +#define _POSIX_VERSION 200809L /* Posix C language bindings version */ +#define _POSIX2_VERSION -1 /* we don't support Posix command-line tools */ +#define _XOPEN_VERSION 700 /* by Posix definition */ + +/* >= _POSIX_THREAD_DESTRUCTOR_ITERATIONS */ +#define PTHREAD_DESTRUCTOR_ITERATIONS 4 +/* >= _POSIX_THREAD_KEYS_MAX */ +#define PTHREAD_KEYS_MAX 128 +/* bionic has no specific limit */ +#undef PTHREAD_THREADS_MAX + +#endif /* !_LIMITS_H_ */ diff --git a/headers/link.h b/headers/link.h new file mode 100644 index 000000000..d284cfa0a --- /dev/null +++ b/headers/link.h @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef _LINK_H_ +#define _LINK_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +#include <elf.h> + +__BEGIN_DECLS + +#if defined(__LP64__) +#define ElfW(type) Elf64_ ## type +#else +#define ElfW(type) Elf32_ ## type +#endif + +struct dl_phdr_info { + ElfW(Addr) dlpi_addr; + const char* dlpi_name; + const ElfW(Phdr)* dlpi_phdr; + ElfW(Half) dlpi_phnum; +}; + +#if defined(__arm__) + +#if __ANDROID_API__ >= 21 +int dl_iterate_phdr(int (*)(struct dl_phdr_info*, size_t, void*), void*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +#else +int dl_iterate_phdr(int (*)(struct dl_phdr_info*, size_t, void*), void*); +#endif + +#ifdef __arm__ +typedef long unsigned int* _Unwind_Ptr; +_Unwind_Ptr dl_unwind_find_exidx(_Unwind_Ptr, int*); +#endif + +/* Used by the dynamic linker to communicate with the debugger. */ +struct link_map { + ElfW(Addr) l_addr; + char* l_name; + ElfW(Dyn)* l_ld; + struct link_map* l_next; + struct link_map* l_prev; +}; + +/* Used by the dynamic linker to communicate with the debugger. */ +struct r_debug { + int32_t r_version; + struct link_map* r_map; + ElfW(Addr) r_brk; + enum { + RT_CONSISTENT, + RT_ADD, + RT_DELETE + } r_state; + ElfW(Addr) r_ldbase; +}; + +__END_DECLS + +#endif /* _LINK_H_ */ diff --git a/headers/locale.h b/headers/locale.h new file mode 100644 index 000000000..16397878c --- /dev/null +++ b/headers/locale.h @@ -0,0 +1,119 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _LOCALE_H_ +#define _LOCALE_H_ + +#include <sys/cdefs.h> +#include <xlocale.h> + +#define __need_NULL +#include <stddef.h> + +__BEGIN_DECLS + +#define LC_CTYPE 0 +#define LC_NUMERIC 1 +#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 +#define LC_TELEPHONE 10 +#define LC_MEASUREMENT 11 +#define LC_IDENTIFICATION 12 + +#define LC_CTYPE_MASK (1 << LC_CTYPE) +#define LC_NUMERIC_MASK (1 << LC_NUMERIC) +#define LC_TIME_MASK (1 << LC_TIME) +#define LC_COLLATE_MASK (1 << LC_COLLATE) +#define LC_MONETARY_MASK (1 << LC_MONETARY) +#define LC_MESSAGES_MASK (1 << LC_MESSAGES) +#define LC_PAPER_MASK (1 << LC_PAPER) +#define LC_NAME_MASK (1 << LC_NAME) +#define LC_ADDRESS_MASK (1 << LC_ADDRESS) +#define LC_TELEPHONE_MASK (1 << LC_TELEPHONE) +#define LC_MEASUREMENT_MASK (1 << LC_MEASUREMENT) +#define LC_IDENTIFICATION_MASK (1 << LC_IDENTIFICATION) + +#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) + +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; +}; + +struct lconv* localeconv(void) __INTRODUCED_IN(21) __VERSIONER_NO_GUARD; + + +#if __ANDROID_API__ >= 21 +locale_t duplocale(locale_t) __INTRODUCED_IN(21); +void freelocale(locale_t) __INTRODUCED_IN(21); +locale_t newlocale(int, const char*, locale_t) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +char* setlocale(int, const char*); + +#if __ANDROID_API__ >= 21 +locale_t uselocale(locale_t) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +#define LC_GLOBAL_LOCALE __BIONIC_CAST(reinterpret_cast, locale_t, -1L) + +__END_DECLS + +#endif /* _LOCALE_H_ */ diff --git a/headers/malloc.h b/headers/malloc.h new file mode 100644 index 000000000..12c7011fd --- /dev/null +++ b/headers/malloc.h @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef LIBC_INCLUDE_MALLOC_H_ +#define LIBC_INCLUDE_MALLOC_H_ + +#include <sys/cdefs.h> +#include <stddef.h> +#include <stdio.h> + +__BEGIN_DECLS + +#if defined(__clang__) +#define __BIONIC_ALLOC_SIZE(...) /* clang doesn't support attribute alloc_size. */ +#else +#define __BIONIC_ALLOC_SIZE(...) __attribute__((__alloc_size__(__VA_ARGS__))) +#endif + +void* malloc(size_t byte_count) __mallocfunc __BIONIC_ALLOC_SIZE(1) __wur; +void* calloc(size_t item_count, size_t item_size) __mallocfunc __BIONIC_ALLOC_SIZE(1,2) __wur; +void* realloc(void* p, size_t byte_count) __BIONIC_ALLOC_SIZE(2) __wur; +void free(void* p); + +void* memalign(size_t alignment, size_t byte_count) __mallocfunc __BIONIC_ALLOC_SIZE(2) __wur; + +#if __ANDROID_API__ >= 17 +size_t malloc_usable_size(const void* p) __INTRODUCED_IN(17); +#endif /* __ANDROID_API__ >= 17 */ + + +#ifndef STRUCT_MALLINFO_DECLARED +#define STRUCT_MALLINFO_DECLARED 1 +struct mallinfo { + size_t arena; /* Total number of non-mmapped bytes currently allocated from OS. */ + size_t ordblks; /* Number of free chunks. */ + size_t smblks; /* (Unused.) */ + size_t hblks; /* (Unused.) */ + size_t hblkhd; /* Total number of bytes in mmapped regions. */ + size_t usmblks; /* Maximum total allocated space; greater than total if trimming has occurred. */ + size_t fsmblks; /* (Unused.) */ + size_t uordblks; /* Total allocated space (normal or mmapped.) */ + size_t fordblks; /* Total free space. */ + size_t keepcost; /* Upper bound on number of bytes releasable by malloc_trim. */ +}; +#endif /* STRUCT_MALLINFO_DECLARED */ + +struct mallinfo mallinfo(void); + +/* + * XML structure for malloc_info(3) is in the following format: + * + * <malloc version="jemalloc-1"> + * <heap nr="INT"> + * <allocated-large>INT</allocated-large> + * <allocated-huge>INT</allocated-huge> + * <allocated-bins>INT</allocated-bins> + * <bins-total>INT</bins-total> + * <bin nr="INT"> + * <allocated>INT</allocated> + * <nmalloc>INT</nmalloc> + * <ndalloc>INT</ndalloc> + * </bin> + * <!-- more bins --> + * </heap> + * <!-- more heaps --> + * </malloc> + */ + +#if __ANDROID_API__ >= 23 +int malloc_info(int, FILE*) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +__END_DECLS + +#endif /* LIBC_INCLUDE_MALLOC_H_ */ diff --git a/headers/math.h b/headers/math.h new file mode 100644 index 000000000..1a0719c2c --- /dev/null +++ b/headers/math.h @@ -0,0 +1,455 @@ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * from: @(#)fdlibm.h 5.1 93/09/24 + * $FreeBSD$ + */ + +#ifndef _MATH_H_ +#define _MATH_H_ + +#include <sys/cdefs.h> +#include <limits.h> + +__BEGIN_DECLS + +#define HUGE_VAL __builtin_huge_val() + +#define FP_ILOGB0 (-INT_MAX) +#define FP_ILOGBNAN INT_MAX + +#define HUGE_VALF __builtin_huge_valf() +#define HUGE_VALL __builtin_huge_vall() +#define INFINITY __builtin_inff() +#define NAN __builtin_nanf("") + +#define MATH_ERRNO 1 +#define MATH_ERREXCEPT 2 +#define math_errhandling MATH_ERREXCEPT + +#if defined(__FP_FAST_FMA) +#define FP_FAST_FMA 1 +#endif +#if defined(__FP_FAST_FMAF) +#define FP_FAST_FMAF 1 +#endif +#if defined(__FP_FAST_FMAL) +#define FP_FAST_FMAL 1 +#endif + +/* Symbolic constants to classify floating point numbers. */ +#define FP_INFINITE 0x01 +#define FP_NAN 0x02 +#define FP_NORMAL 0x04 +#define FP_SUBNORMAL 0x08 +#define FP_ZERO 0x10 +#define fpclassify(x) \ + __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, x) + +#define isfinite(x) __builtin_isfinite(x) +#define isinf(x) __builtin_isinf(x) +#define isnan(x) __builtin_isnan(x) +#define isnormal(x) __builtin_isnormal(x) + +#define isgreater(x, y) __builtin_isgreater((x), (y)) +#define isgreaterequal(x, y) __builtin_isgreaterequal((x), (y)) +#define isless(x, y) __builtin_isless((x), (y)) +#define islessequal(x, y) __builtin_islessequal((x), (y)) +#define islessgreater(x, y) __builtin_islessgreater((x), (y)) +#define isunordered(x, y) __builtin_isunordered((x), (y)) + +#define signbit(x) \ + ((sizeof(x) == sizeof(float)) ? __builtin_signbitf(x) \ + : (sizeof(x) == sizeof(double)) ? __builtin_signbit(x) \ + : __builtin_signbitl(x)) + +typedef double __double_t; +typedef __double_t double_t; +typedef float __float_t; +typedef __float_t float_t; + +#if defined(__USE_BSD) +#define HUGE MAXFLOAT +#endif + +extern int signgam; + +/* + * Most of these functions depend on the rounding mode and have the side + * effect of raising floating-point exceptions, so they are not declared + * as __attribute_const__. In C99, FENV_ACCESS affects the purity of these functions. + */ + +int __fpclassifyd(double) __attribute_const__; +int __fpclassifyf(float) __attribute_const__; +int __fpclassifyl(long double) __attribute_const__; +int __isfinitef(float) __attribute_const__; +int __isfinite(double) __attribute_const__; +int __isfinitel(long double) __attribute_const__; +int __isinff(float) __attribute_const__; +int __isinfl(long double) __attribute_const__; + +#if __ANDROID_API__ >= 21 +int __isnanf(float) __attribute_const__ __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int __isnanl(long double) __attribute_const__; +int __isnormalf(float) __attribute_const__; +int __isnormal(double) __attribute_const__; +int __isnormall(long double) __attribute_const__; +int __signbit(double) __attribute_const__; +int __signbitf(float) __attribute_const__; +int __signbitl(long double) __attribute_const__; + +double acos(double); +double asin(double); +double atan(double); +double atan2(double, double); +double cos(double); +double sin(double); +double tan(double); + +double cosh(double); +double sinh(double); +double tanh(double); + +double exp(double); +double frexp(double, int *); /* fundamentally !__attribute_const__ */ +double ldexp(double, int); +double log(double); +double log10(double); +double modf(double, double *); /* fundamentally !__attribute_const__ */ + +double pow(double, double); +double sqrt(double); + +double ceil(double); +double fabs(double) __attribute_const__; +double floor(double); +double fmod(double, double); + +double acosh(double); +double asinh(double); +double atanh(double); +double cbrt(double); +double erf(double); +double erfc(double); +double exp2(double); +double expm1(double); +double fma(double, double, double); +double hypot(double, double); +int ilogb(double) __attribute_const__; +double lgamma(double); +long long llrint(double); +long long llround(double); +double log1p(double); + +#if __ANDROID_API__ >= 18 +double log2(double) __INTRODUCED_IN(18); +#endif /* __ANDROID_API__ >= 18 */ + +double logb(double); +long lrint(double); +long lround(double); + + +#if (defined(__LP64__)) || (defined(__arm__) && __ANDROID_API__ >= 13) || (defined(__mips__) && !defined(__LP64__) && __ANDROID_API__ >= 13) || (defined(__i386__)) +double nan(const char*) __attribute_const__ __INTRODUCED_IN_ARM(13) __INTRODUCED_IN_MIPS(13) + __INTRODUCED_IN_X86(9); +#endif /* (defined(__LP64__)) || (defined(__arm__) && __ANDROID_API__ >= 13) || (defined(__mips__) && !defined(__LP64__) && __ANDROID_API__ >= 13) || (defined(__i386__)) */ + + +double nextafter(double, double); +double remainder(double, double); +double remquo(double, double, int*); +double rint(double); + +double copysign(double, double) __attribute_const__; +double fdim(double, double); +double fmax(double, double) __attribute_const__; +double fmin(double, double) __attribute_const__; +double nearbyint(double); +double round(double); +double scalbln(double, long) __INTRODUCED_IN_X86(18) __VERSIONER_NO_GUARD; +double scalbn(double, int); +double tgamma(double); +double trunc(double); + +float acosf(float); +float asinf(float); +float atanf(float); +float atan2f(float, float); +float cosf(float); +float sinf(float); +float tanf(float); + +float coshf(float); +float sinhf(float); +float tanhf(float); + +float exp2f(float); +float expf(float); +float expm1f(float); +float frexpf(float, int *); /* fundamentally !__attribute_const__ */ +int ilogbf(float) __attribute_const__; +float ldexpf(float, int); +float log10f(float); +float log1pf(float); + +#if __ANDROID_API__ >= 18 +float log2f(float) __INTRODUCED_IN(18); +#endif /* __ANDROID_API__ >= 18 */ + +float logf(float); +float modff(float, float *); /* fundamentally !__attribute_const__ */ + +float powf(float, float); +float sqrtf(float); + +float ceilf(float); +float fabsf(float) __attribute_const__; +float floorf(float); +float fmodf(float, float); +float roundf(float); + +float erff(float); +float erfcf(float); +float hypotf(float, float); +float lgammaf(float); + +#if (defined(__LP64__)) || (defined(__arm__) && __ANDROID_API__ >= 13) || (defined(__mips__) && !defined(__LP64__) && __ANDROID_API__ >= 13) || (defined(__i386__)) +float tgammaf(float) __INTRODUCED_IN_ARM(13) __INTRODUCED_IN_MIPS(13) __INTRODUCED_IN_X86(9); +#endif /* (defined(__LP64__)) || (defined(__arm__) && __ANDROID_API__ >= 13) || (defined(__mips__) && !defined(__LP64__) && __ANDROID_API__ >= 13) || (defined(__i386__)) */ + + +float acoshf(float); +float asinhf(float); +float atanhf(float); +float cbrtf(float); +float logbf(float); +float copysignf(float, float) __attribute_const__; +long long llrintf(float); +long long llroundf(float); +long lrintf(float); +long lroundf(float); + +#if (defined(__LP64__)) || (defined(__arm__) && __ANDROID_API__ >= 13) || (defined(__mips__) && !defined(__LP64__) && __ANDROID_API__ >= 13) || (defined(__i386__)) +float nanf(const char*) __attribute_const__ __INTRODUCED_IN_ARM(13) __INTRODUCED_IN_MIPS(13) + __INTRODUCED_IN_X86(9); +#endif /* (defined(__LP64__)) || (defined(__arm__) && __ANDROID_API__ >= 13) || (defined(__mips__) && !defined(__LP64__) && __ANDROID_API__ >= 13) || (defined(__i386__)) */ + +float nearbyintf(float); +float nextafterf(float, float); +float remainderf(float, float); +float remquof(float, float, int *); +float rintf(float); +float scalblnf(float, long) __INTRODUCED_IN_X86(18) __VERSIONER_NO_GUARD; +float scalbnf(float, int); +float truncf(float); + +float fdimf(float, float); +float fmaf(float, float, float); +float fmaxf(float, float) __attribute_const__; +float fminf(float, float) __attribute_const__; + + +#if __ANDROID_API__ >= 21 +long double acoshl(long double) __INTRODUCED_IN(21); +long double acosl(long double) __INTRODUCED_IN(21); +long double asinhl(long double) __INTRODUCED_IN(21); +long double asinl(long double) __INTRODUCED_IN(21); +long double atan2l(long double, long double) __INTRODUCED_IN(21); +long double atanhl(long double) __INTRODUCED_IN(21); +long double atanl(long double) __INTRODUCED_IN(21); +long double cbrtl(long double) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +long double ceill(long double); +long double copysignl(long double, long double) __attribute_const__; + +#if __ANDROID_API__ >= 21 +long double coshl(long double) __INTRODUCED_IN(21); +long double cosl(long double) __INTRODUCED_IN(21); +long double erfcl(long double) __INTRODUCED_IN(21); +long double erfl(long double) __INTRODUCED_IN(21); +long double exp2l(long double) __INTRODUCED_IN(21); +long double expl(long double) __INTRODUCED_IN(21); +long double expm1l(long double) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +long double fabsl(long double) __attribute_const__; +long double fdiml(long double, long double); +long double floorl(long double); +long double fmal(long double, long double, long double) __INTRODUCED_IN(21) __VERSIONER_NO_GUARD; +long double fmaxl(long double, long double) __attribute_const__; +long double fminl(long double, long double) __attribute_const__; + +#if __ANDROID_API__ >= 21 +long double fmodl(long double, long double) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +long double frexpl(long double value, int*) + __INTRODUCED_IN(21) __VERSIONER_NO_GUARD; /* fundamentally !__attribute_const__ */ + +#if __ANDROID_API__ >= 21 +long double hypotl(long double, long double) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int ilogbl(long double) __attribute_const__; +long double ldexpl(long double, int); + +#if __ANDROID_API__ >= 21 +long double lgammal(long double) __INTRODUCED_IN(21); +long long llrintl(long double) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +long long llroundl(long double); + +#if __ANDROID_API__ >= 21 +long double log10l(long double) __INTRODUCED_IN(21); +long double log1pl(long double) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +#if __ANDROID_API__ >= 18 +long double log2l(long double) __INTRODUCED_IN(18); +long double logbl(long double) __INTRODUCED_IN(18); +#endif /* __ANDROID_API__ >= 18 */ + + +#if __ANDROID_API__ >= 21 +long double logl(long double) __INTRODUCED_IN(21); +long lrintl(long double) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +long lroundl(long double); + +#if __ANDROID_API__ >= 21 +long double modfl(long double, long double*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + /* fundamentally !__attribute_const__ */ + +#if __ANDROID_API__ >= 13 +long double nanl(const char*) __attribute_const__ __INTRODUCED_IN(13); +#endif /* __ANDROID_API__ >= 13 */ + + +#if __ANDROID_API__ >= 21 +long double nearbyintl(long double) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +long double nextafterl(long double, long double) __INTRODUCED_IN(21) __VERSIONER_NO_GUARD; +double nexttoward(double, long double) __INTRODUCED_IN(18) __VERSIONER_NO_GUARD; +float nexttowardf(float, long double); +long double nexttowardl(long double, long double) __INTRODUCED_IN(18) __VERSIONER_NO_GUARD; + +#if __ANDROID_API__ >= 21 +long double powl(long double, long double) __INTRODUCED_IN(21); +long double remainderl(long double, long double) __INTRODUCED_IN(21); +long double remquol(long double, long double, int*) __INTRODUCED_IN(21); +long double rintl(long double) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +long double roundl(long double); +long double scalblnl(long double, long) __INTRODUCED_IN_X86(18) __VERSIONER_NO_GUARD; +long double scalbnl(long double, int); + +#if __ANDROID_API__ >= 21 +long double sinhl(long double) __INTRODUCED_IN(21); +long double sinl(long double) __INTRODUCED_IN(21); +long double sqrtl(long double) __INTRODUCED_IN(21); +long double tanhl(long double) __INTRODUCED_IN(21); +long double tanl(long double) __INTRODUCED_IN(21); +long double tgammal(long double) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +long double truncl(long double); + +double j0(double); +double j1(double); +double jn(int, double); +double y0(double); +double y1(double); +double yn(int, double); + +#define M_E 2.7182818284590452354 /* e */ +#define M_LOG2E 1.4426950408889634074 /* log 2e */ +#define M_LOG10E 0.43429448190325182765 /* log 10e */ +#define M_LN2 0.69314718055994530942 /* log e2 */ +#define M_LN10 2.30258509299404568402 /* log e10 */ +#define M_PI 3.14159265358979323846 /* pi */ +#define M_PI_2 1.57079632679489661923 /* pi/2 */ +#define M_PI_4 0.78539816339744830962 /* pi/4 */ +#define M_1_PI 0.31830988618379067154 /* 1/pi */ +#define M_2_PI 0.63661977236758134308 /* 2/pi */ +#define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */ +#define M_SQRT2 1.41421356237309504880 /* sqrt(2) */ +#define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */ + +#define MAXFLOAT ((float)3.40282346638528860e+38) + +#if defined(__USE_BSD) || defined(__USE_GNU) +double gamma(double); +double scalb(double, double); +double drem(double, double); +int finite(double) __attribute_const__; +int isnanf(float) __attribute_const__; +double gamma_r(double, int*); +double lgamma_r(double, int*); +double significand(double); + +#if __ANDROID_API__ >= 23 +long double lgammal_r(long double, int*) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if __ANDROID_API__ >= 21 +long double significandl(long double) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +float dremf(float, float); +int finitef(float) __attribute_const__; +float gammaf(float); +float j0f(float); +float j1f(float); +float jnf(int, float); +float scalbf(float, float); +float y0f(float); +float y1f(float); +float ynf(int, float); +float gammaf_r(float, int *); +float lgammaf_r(float, int *); +float significandf(float); +#endif + +#if defined(__USE_GNU) +#define M_El 2.718281828459045235360287471352662498L /* e */ +#define M_LOG2El 1.442695040888963407359924681001892137L /* log 2e */ +#define M_LOG10El 0.434294481903251827651128918916605082L /* log 10e */ +#define M_LN2l 0.693147180559945309417232121458176568L /* log e2 */ +#define M_LN10l 2.302585092994045684017991454684364208L /* log e10 */ +#define M_PIl 3.141592653589793238462643383279502884L /* pi */ +#define M_PI_2l 1.570796326794896619231321691639751442L /* pi/2 */ +#define M_PI_4l 0.785398163397448309615660845819875721L /* pi/4 */ +#define M_1_PIl 0.318309886183790671537767526745028724L /* 1/pi */ +#define M_2_PIl 0.636619772367581343075535053490057448L /* 2/pi */ +#define M_2_SQRTPIl 1.128379167095512573896158903121545172L /* 2/sqrt(pi) */ +#define M_SQRT2l 1.414213562373095048801688724209698079L /* sqrt(2) */ +#define M_SQRT1_2l 0.707106781186547524400844362104849039L /* 1/sqrt(2) */ +void sincos(double, double*, double*); +void sincosf(float, float*, float*); +void sincosl(long double, long double*, long double*); +#endif + +__END_DECLS + +#endif /* !_MATH_H_ */ diff --git a/headers/memory.h b/headers/memory.h new file mode 100644 index 000000000..3b2f59002 --- /dev/null +++ b/headers/memory.h @@ -0,0 +1 @@ +#include <string.h> diff --git a/headers/mntent.h b/headers/mntent.h new file mode 100644 index 000000000..e26d1711f --- /dev/null +++ b/headers/mntent.h @@ -0,0 +1,80 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _MNTENT_H_ +#define _MNTENT_H_ + +#include <stdio.h> +#include <sys/cdefs.h> +#include <paths.h> /* for _PATH_MOUNTED */ + +#define MOUNTED _PATH_MOUNTED + +#define MNTTYPE_IGNORE "ignore" +#define MNTTYPE_NFS "nfs" +#define MNTTYPE_SWAP "swap" + +#define MNTOPT_DEFAULTS "defaults" +#define MNTOPT_NOAUTO "noauto" +#define MNTOPT_NOSUID "nosuid" +#define MNTOPT_RO "ro" +#define MNTOPT_RW "rw" +#define MNTOPT_SUID "suid" + +struct mntent { + char* mnt_fsname; + char* mnt_dir; + char* mnt_type; + char* mnt_opts; + int mnt_freq; + int mnt_passno; +}; + +__BEGIN_DECLS + + +#if __ANDROID_API__ >= 21 +int endmntent(FILE*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +struct mntent* getmntent(FILE*); + +#if __ANDROID_API__ >= 21 +struct mntent* getmntent_r(FILE*, struct mntent*, char*, int) __INTRODUCED_IN(21); +FILE* setmntent(const char*, const char*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +char* hasmntopt(const struct mntent*, const char*) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + +__END_DECLS + +#endif diff --git a/headers/net/ethernet.h b/headers/net/ethernet.h new file mode 100644 index 000000000..d5ba11f3f --- /dev/null +++ b/headers/net/ethernet.h @@ -0,0 +1,80 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _NET_ETHERNET_H_ +#define _NET_ETHERNET_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +#include <linux/if_ether.h> + +#define ETHERTYPE_IP 0x0800 +#define ETHERTYPE_ARP 0x0806 +#define ETHERTYPE_REVARP 0x8035 +#define ETHERTYPE_VLAN 0x8100 +#define ETHERTYPE_IPX 0x8137 +#define ETHERTYPE_IPV6 0x86dd +#define ETHERTYPE_LOOPBACK 0x9000 + +#define ETHERTYPE_TRAIL 0x1000 +#define ETHERTYPE_NTRAILER 16 + +/* + * Some basic Ethernet constants. + */ +#define ETHER_ADDR_LEN 6 /* length of an Ethernet address */ +#define ETHER_TYPE_LEN 2 /* length of the Ethernet type field */ +#define ETHER_CRC_LEN 4 /* length of the Ethernet CRC */ +#define ETHER_HDR_LEN ((ETHER_ADDR_LEN * 2) + ETHER_TYPE_LEN) +#define ETHER_MIN_LEN 64 /* minimum frame length, including CRC */ +#define ETHER_MAX_LEN 1518 /* maximum frame length, including CRC */ +#define ETHER_MAX_LEN_JUMBO 9018 /* maximum jumbo frame len, including CRC */ + +/* + * Ethernet address - 6 octets + * this is only used by the ethers(3) functions. + */ +struct ether_addr { + u_int8_t ether_addr_octet[ETHER_ADDR_LEN]; +} __attribute__((__packed__)); + +/* + * Structure of a 10Mb/s Ethernet header. + */ +struct ether_header { + u_int8_t ether_dhost[ETHER_ADDR_LEN]; + u_int8_t ether_shost[ETHER_ADDR_LEN]; + u_int16_t ether_type; +} __attribute__((__packed__)); + +#define ETHERMTU_JUMBO (ETHER_MAX_LEN_JUMBO - ETHER_HDR_LEN - ETHER_CRC_LEN) +#define ETHERMTU (ETHER_MAX_LEN - ETHER_HDR_LEN - ETHER_CRC_LEN) +#define ETHERMIN (ETHER_MIN_LEN - ETHER_HDR_LEN - ETHER_CRC_LEN) + +#endif diff --git a/headers/net/if.h b/headers/net/if.h new file mode 100644 index 000000000..b72105fbd --- /dev/null +++ b/headers/net/if.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _NET_IF_H_ +#define _NET_IF_H_ + +#include <sys/socket.h> +#include <linux/if.h> +#include <sys/cdefs.h> + +#ifndef IF_NAMESIZE +#define IF_NAMESIZE IFNAMSIZ +#endif + +__BEGIN_DECLS + +struct if_nameindex { + unsigned if_index; + char* if_name; +}; + +char* if_indextoname(unsigned, char*); +unsigned if_nametoindex(const char*); + +#if __ANDROID_API__ >= 24 +struct if_nameindex* if_nameindex(void) __INTRODUCED_IN(24); +void if_freenameindex(struct if_nameindex*) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + + +__END_DECLS + +#endif diff --git a/headers/net/if_arp.h b/headers/net/if_arp.h new file mode 100644 index 000000000..5eae82cea --- /dev/null +++ b/headers/net/if_arp.h @@ -0,0 +1,2 @@ +#include <sys/socket.h> +#include <linux/if_arp.h> diff --git a/headers/net/if_packet.h b/headers/net/if_packet.h new file mode 100644 index 000000000..b5e8e0e11 --- /dev/null +++ b/headers/net/if_packet.h @@ -0,0 +1 @@ +#include <linux/if_packet.h> diff --git a/headers/net/route.h b/headers/net/route.h new file mode 100644 index 000000000..9c53875c6 --- /dev/null +++ b/headers/net/route.h @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _NET_ROUTE_H_ +#define _NET_ROUTE_H_ + +#include <sys/cdefs.h> +#include <sys/socket.h> +#include <linux/route.h> +#include <linux/in6.h> +#include <linux/ipv6_route.h> + +#endif diff --git a/headers/netdb.h b/headers/netdb.h new file mode 100644 index 000000000..868a34206 --- /dev/null +++ b/headers/netdb.h @@ -0,0 +1,240 @@ +/*- + * Copyright (c) 1980, 1983, 1988, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * - + * Portions Copyright (c) 1993 by Digital Equipment Corporation. + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies, and that + * the name of Digital Equipment Corporation not be used in advertising or + * publicity pertaining to distribution of the document or software without + * specific, written prior permission. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL + * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT + * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR + * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS + * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS + * SOFTWARE. + * - + * --Copyright-- + */ + +/* + * @(#)netdb.h 8.1 (Berkeley) 6/2/93 + * From: Id: netdb.h,v 8.9 1996/11/19 08:39:29 vixie Exp $ + * $FreeBSD: /repoman/r/ncvs/src/include/netdb.h,v 1.41 2006/04/15 16:20:26 ume Exp $ + */ + +#ifndef _NETDB_H_ +#define _NETDB_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <sys/socket.h> + +#ifndef _PATH_HEQUIV +# define _PATH_HEQUIV "/system/etc/hosts.equiv" +#endif +#define _PATH_HOSTS "/system/etc/hosts" +#define _PATH_NETWORKS "/system/etc/networks" +#define _PATH_PROTOCOLS "/system/etc/protocols" +#define _PATH_SERVICES "/system/etc/services" + +/* + * Structures returned by network data base library. All addresses are + * supplied in host order, and returned in network order (suitable for + * use in system calls). + */ +struct hostent { + char *h_name; /* official name of host */ + char **h_aliases; /* alias list */ + int h_addrtype; /* host address type */ + int h_length; /* length of address */ + char **h_addr_list; /* list of addresses from name server */ +#define h_addr h_addr_list[0] /* address, for backward compatibility */ +}; + +struct netent { + char *n_name; /* official name of net */ + char **n_aliases; /* alias list */ + int n_addrtype; /* net address type */ + uint32_t n_net; /* network # */ +}; + +struct servent { + char *s_name; /* official service name */ + char **s_aliases; /* alias list */ + int s_port; /* port # */ + char *s_proto; /* protocol to use */ +}; + +struct protoent { + char *p_name; /* official protocol name */ + char **p_aliases; /* alias list */ + int p_proto; /* protocol # */ +}; + +struct addrinfo { + int ai_flags; /* AI_PASSIVE, AI_CANONNAME, AI_NUMERICHOST */ + int ai_family; /* PF_xxx */ + int ai_socktype; /* SOCK_xxx */ + int ai_protocol; /* 0 or IPPROTO_xxx for IPv4 and IPv6 */ + socklen_t ai_addrlen; /* length of ai_addr */ + char *ai_canonname; /* canonical name for hostname */ + struct sockaddr *ai_addr; /* binary address */ + struct addrinfo *ai_next; /* next structure in linked list */ +}; + +/* + * Error return codes from gethostbyname() and gethostbyaddr() + * (left in h_errno). + */ + +#define NETDB_INTERNAL -1 /* see errno */ +#define NETDB_SUCCESS 0 /* no problem */ +#define HOST_NOT_FOUND 1 /* Authoritative Answer Host not found */ +#define TRY_AGAIN 2 /* Non-Authoritative Host not found, or SERVERFAIL */ +#define NO_RECOVERY 3 /* Non recoverable errors, FORMERR, REFUSED, NOTIMP */ +#define NO_DATA 4 /* Valid name, no data record of requested type */ +#define NO_ADDRESS NO_DATA /* no address, look for MX record */ + +/* + * Error return codes from getaddrinfo() + */ +#define EAI_ADDRFAMILY 1 /* address family for hostname not supported */ +#define EAI_AGAIN 2 /* temporary failure in name resolution */ +#define EAI_BADFLAGS 3 /* invalid value for ai_flags */ +#define EAI_FAIL 4 /* non-recoverable failure in name resolution */ +#define EAI_FAMILY 5 /* ai_family not supported */ +#define EAI_MEMORY 6 /* memory allocation failure */ +#define EAI_NODATA 7 /* no address associated with hostname */ +#define EAI_NONAME 8 /* hostname nor servname provided, or not known */ +#define EAI_SERVICE 9 /* servname not supported for ai_socktype */ +#define EAI_SOCKTYPE 10 /* ai_socktype not supported */ +#define EAI_SYSTEM 11 /* system error returned in errno */ +#define EAI_BADHINTS 12 /* invalid value for hints */ +#define EAI_PROTOCOL 13 /* resolved protocol is unknown */ +#define EAI_OVERFLOW 14 /* argument buffer overflow */ +#define EAI_MAX 15 + +/* + * Flag values for getaddrinfo() + */ +#define AI_PASSIVE 0x00000001 /* get address to use bind() */ +#define AI_CANONNAME 0x00000002 /* fill ai_canonname */ +#define AI_NUMERICHOST 0x00000004 /* prevent host name resolution */ +#define AI_NUMERICSERV 0x00000008 /* prevent service name resolution */ +/* valid flags for addrinfo (not a standard def, apps should not use it) */ +#define AI_MASK \ + (AI_PASSIVE | AI_CANONNAME | AI_NUMERICHOST | AI_NUMERICSERV | \ + AI_ADDRCONFIG) + +#define AI_ALL 0x00000100 /* IPv6 and IPv4-mapped (with AI_V4MAPPED) */ +#define AI_V4MAPPED_CFG 0x00000200 /* accept IPv4-mapped if kernel supports */ +#define AI_ADDRCONFIG 0x00000400 /* only if any address is assigned */ +#define AI_V4MAPPED 0x00000800 /* accept IPv4-mapped IPv6 address */ +/* special recommended flags for getipnodebyname */ +#define AI_DEFAULT (AI_V4MAPPED_CFG | AI_ADDRCONFIG) + +/* + * Constants for getnameinfo() + */ +#define NI_MAXHOST 1025 +#define NI_MAXSERV 32 + +/* + * Flag values for getnameinfo() + */ +#define NI_NOFQDN 0x00000001 +#define NI_NUMERICHOST 0x00000002 +#define NI_NAMEREQD 0x00000004 +#define NI_NUMERICSERV 0x00000008 +#define NI_DGRAM 0x00000010 +#if 0 /* obsolete */ +#define NI_WITHSCOPEID 0x00000020 +#endif + +/* + * Scope delimit character + */ +#define SCOPE_DELIMITER '%' + +#define IPPORT_RESERVED 1024 + +__BEGIN_DECLS + +/* BIONIC-BEGIN */ +#define h_errno (*__get_h_errno()) +int* __get_h_errno(void); +/* BIONIC-END */ +void endservent(void); +struct hostent* gethostbyaddr(const void*, socklen_t, int); + +#if __ANDROID_API__ >= 23 +int gethostbyaddr_r(const void*, socklen_t, int, struct hostent*, char*, size_t, struct hostent**, + int*) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +struct hostent* gethostbyname(const char*); +int gethostbyname_r(const char*, struct hostent*, char*, size_t, struct hostent**, int*); +struct hostent* gethostbyname2(const char*, int); + +#if __ANDROID_API__ >= 23 +int gethostbyname2_r(const char*, int, struct hostent*, char*, size_t, struct hostent**, int*) + __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +struct hostent* gethostent(void); +struct netent* getnetbyaddr(uint32_t, int); +struct netent* getnetbyname(const char*); +struct protoent* getprotobyname(const char*); +struct protoent* getprotobynumber(int); +struct servent* getservbyname(const char*, const char*); +struct servent* getservbyport(int, const char*); +struct servent* getservent(void); +void herror(const char*); +const char* hstrerror(int); + +int getaddrinfo(const char*, const char*, const struct addrinfo*, struct addrinfo**); +/* POSIX getnameinfo uses socklen_t, not size_t, but LP64 sizeof(socklen_t) != sizeof(size_t). */ +int getnameinfo(const struct sockaddr*, socklen_t, char*, size_t, char*, size_t, int); +void freeaddrinfo(struct addrinfo*); +const char* gai_strerror(int); +void setservent(int); + +__END_DECLS + +#endif /* !_NETDB_H_ */ diff --git a/headers/netinet/ether.h b/headers/netinet/ether.h new file mode 100644 index 000000000..a69005f88 --- /dev/null +++ b/headers/netinet/ether.h @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _NETINET_ETHER_H_ +#define _NETINET_ETHER_H_ 1 + +#include <sys/cdefs.h> +#include <netinet/if_ether.h> + +__BEGIN_DECLS + + +#if __ANDROID_API__ >= 11 +char* ether_ntoa(const struct ether_addr*) __INTRODUCED_IN(11); +char* ether_ntoa_r(const struct ether_addr*, char*) __INTRODUCED_IN(11); +struct ether_addr* ether_aton(const char*) __INTRODUCED_IN(11); +struct ether_addr* ether_aton_r(const char*, struct ether_addr*) __INTRODUCED_IN(11); +#endif /* __ANDROID_API__ >= 11 */ + + +__END_DECLS + +#endif diff --git a/headers/netinet/icmp6.h b/headers/netinet/icmp6.h new file mode 100644 index 000000000..43ec5215c --- /dev/null +++ b/headers/netinet/icmp6.h @@ -0,0 +1,500 @@ +/* $NetBSD: icmp6.h,v 1.47 2013/07/01 12:43:15 christos Exp $ */ +/* $KAME: icmp6.h,v 1.84 2003/04/23 10:26:51 itojun Exp $ */ + + +/* + * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the project nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * Copyright (c) 1982, 1986, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)ip_icmp.h 8.1 (Berkeley) 6/10/93 + */ + +#ifndef _NETINET_ICMP6_H_ +#define _NETINET_ICMP6_H_ + +#include <netinet/in.h> /* android-added: glibc source compatibility. */ +#include <sys/cdefs.h> + +#define ICMPV6_PLD_MAXLEN 1232 /* IPV6_MMTU - sizeof(struct ip6_hdr) + - sizeof(struct icmp6_hdr) */ + +struct icmp6_hdr { + u_int8_t icmp6_type; /* type field */ + u_int8_t icmp6_code; /* code field */ + u_int16_t icmp6_cksum; /* checksum field */ + union { + u_int32_t icmp6_un_data32[1]; /* type-specific field */ + u_int16_t icmp6_un_data16[2]; /* type-specific field */ + u_int8_t icmp6_un_data8[4]; /* type-specific field */ + } icmp6_dataun; +} __packed; + +#define icmp6_data32 icmp6_dataun.icmp6_un_data32 +#define icmp6_data16 icmp6_dataun.icmp6_un_data16 +#define icmp6_data8 icmp6_dataun.icmp6_un_data8 +#define icmp6_pptr icmp6_data32[0] /* parameter prob */ +#define icmp6_mtu icmp6_data32[0] /* packet too big */ +#define icmp6_id icmp6_data16[0] /* echo request/reply */ +#define icmp6_seq icmp6_data16[1] /* echo request/reply */ +#define icmp6_maxdelay icmp6_data16[0] /* mcast group membership */ + +#define ICMP6_DST_UNREACH 1 /* dest unreachable, codes: */ +#define ICMP6_PACKET_TOO_BIG 2 /* packet too big */ +#define ICMP6_TIME_EXCEEDED 3 /* time exceeded, code: */ +#define ICMP6_PARAM_PROB 4 /* ip6 header bad */ + +#define ICMP6_ECHO_REQUEST 128 /* echo service */ +#define ICMP6_ECHO_REPLY 129 /* echo reply */ +#define MLD_LISTENER_QUERY 130 /* multicast listener query */ +#define MLD_LISTENER_REPORT 131 /* multicast listener report */ +#define MLD_LISTENER_DONE 132 /* multicast listener done */ +#define MLD_LISTENER_REDUCTION MLD_LISTENER_DONE /* RFC3542 definition */ + +/* RFC2292 decls */ +#define ICMP6_MEMBERSHIP_QUERY 130 /* group membership query */ +#define ICMP6_MEMBERSHIP_REPORT 131 /* group membership report */ +#define ICMP6_MEMBERSHIP_REDUCTION 132 /* group membership termination */ + +#define ND_ROUTER_SOLICIT 133 /* router solicitation */ +#define ND_ROUTER_ADVERT 134 /* router advertisement */ +#define ND_NEIGHBOR_SOLICIT 135 /* neighbor solicitation */ +#define ND_NEIGHBOR_ADVERT 136 /* neighbor advertisement */ +#define ND_REDIRECT 137 /* redirect */ + +#define ICMP6_ROUTER_RENUMBERING 138 /* router renumbering */ + +#define ICMP6_WRUREQUEST 139 /* who are you request */ +#define ICMP6_WRUREPLY 140 /* who are you reply */ +#define ICMP6_FQDN_QUERY 139 /* FQDN query */ +#define ICMP6_FQDN_REPLY 140 /* FQDN reply */ +#define ICMP6_NI_QUERY 139 /* node information request */ +#define ICMP6_NI_REPLY 140 /* node information reply */ +#define MLDV2_LISTENER_REPORT 143 /* RFC3810 listener report */ + +/* The definitions below are experimental. TBA */ +#define MLD_MTRACE_RESP 200 /* mtrace response(to sender) */ +#define MLD_MTRACE 201 /* mtrace messages */ + +#define ICMP6_MAXTYPE 201 + +#define ICMP6_DST_UNREACH_NOROUTE 0 /* no route to destination */ +#define ICMP6_DST_UNREACH_ADMIN 1 /* administratively prohibited */ +#define ICMP6_DST_UNREACH_NOTNEIGHBOR 2 /* not a neighbor(obsolete) */ +#define ICMP6_DST_UNREACH_BEYONDSCOPE 2 /* beyond scope of source address */ +#define ICMP6_DST_UNREACH_ADDR 3 /* address unreachable */ +#define ICMP6_DST_UNREACH_NOPORT 4 /* port unreachable */ +#define ICMP6_DST_UNREACH_POLICY 5 /* source address failed ingress/egress policy */ +#define ICMP6_DST_UNREACH_REJROUTE 6 /* reject route to destination */ +#define ICMP6_DST_UNREACH_SOURCERT 7 /* error in source routing header */ + +#define ICMP6_TIME_EXCEED_TRANSIT 0 /* ttl==0 in transit */ +#define ICMP6_TIME_EXCEED_REASSEMBLY 1 /* ttl==0 in reass */ + +#define ICMP6_PARAMPROB_HEADER 0 /* erroneous header field */ +#define ICMP6_PARAMPROB_NEXTHEADER 1 /* unrecognized next header */ +#define ICMP6_PARAMPROB_OPTION 2 /* unrecognized option */ + +#define ICMP6_INFOMSG_MASK 0x80 /* all informational messages */ + +#define ICMP6_NI_SUBJ_IPV6 0 /* Query Subject is an IPv6 address */ +#define ICMP6_NI_SUBJ_FQDN 1 /* Query Subject is a Domain name */ +#define ICMP6_NI_SUBJ_IPV4 2 /* Query Subject is an IPv4 address */ + +#define ICMP6_NI_SUCCESS 0 /* node information successful reply */ +#define ICMP6_NI_REFUSED 1 /* node information request is refused */ +#define ICMP6_NI_UNKNOWN 2 /* unknown Qtype */ + +#define ICMP6_ROUTER_RENUMBERING_COMMAND 0 /* rr command */ +#define ICMP6_ROUTER_RENUMBERING_RESULT 1 /* rr result */ +#define ICMP6_ROUTER_RENUMBERING_SEQNUM_RESET 255 /* rr seq num reset */ + +/* Used in kernel only */ +#define ND_REDIRECT_ONLINK 0 /* redirect to an on-link node */ +#define ND_REDIRECT_ROUTER 1 /* redirect to a better router */ + +/* + * Multicast Listener Discovery + */ +struct mld_hdr { + struct icmp6_hdr mld_icmp6_hdr; + struct in6_addr mld_addr; /* multicast address */ +} __packed; + +/* shortcut macro definitions */ +#define mld_type mld_icmp6_hdr.icmp6_type +#define mld_code mld_icmp6_hdr.icmp6_code +#define mld_cksum mld_icmp6_hdr.icmp6_cksum +#define mld_maxdelay mld_icmp6_hdr.icmp6_data16[0] +#define mld_reserved mld_icmp6_hdr.icmp6_data16[1] + +#define MLD_MINLEN 24 + +/* + * Neighbor Discovery + */ + +struct nd_router_solicit { /* router solicitation */ + struct icmp6_hdr nd_rs_hdr; + /* could be followed by options */ +} __packed; + +#define nd_rs_type nd_rs_hdr.icmp6_type +#define nd_rs_code nd_rs_hdr.icmp6_code +#define nd_rs_cksum nd_rs_hdr.icmp6_cksum +#define nd_rs_reserved nd_rs_hdr.icmp6_data32[0] + +struct nd_router_advert { /* router advertisement */ + struct icmp6_hdr nd_ra_hdr; + u_int32_t nd_ra_reachable; /* reachable time */ + u_int32_t nd_ra_retransmit; /* retransmit timer */ + /* could be followed by options */ +} __packed; + +#define nd_ra_type nd_ra_hdr.icmp6_type +#define nd_ra_code nd_ra_hdr.icmp6_code +#define nd_ra_cksum nd_ra_hdr.icmp6_cksum +#define nd_ra_curhoplimit nd_ra_hdr.icmp6_data8[0] +#define nd_ra_flags_reserved nd_ra_hdr.icmp6_data8[1] +#define ND_RA_FLAG_MANAGED 0x80 +#define ND_RA_FLAG_OTHER 0x40 +#define ND_RA_FLAG_HOME_AGENT 0x20 + +/* + * Router preference values based on RFC4191. + */ +#define ND_RA_FLAG_RTPREF_MASK 0x18 /* 00011000 */ + +#define ND_RA_FLAG_RTPREF_HIGH 0x08 /* 00001000 */ +#define ND_RA_FLAG_RTPREF_MEDIUM 0x00 /* 00000000 */ +#define ND_RA_FLAG_RTPREF_LOW 0x18 /* 00011000 */ +#define ND_RA_FLAG_RTPREF_RSV 0x10 /* 00010000 */ + +#define nd_ra_router_lifetime nd_ra_hdr.icmp6_data16[1] + +struct nd_neighbor_solicit { /* neighbor solicitation */ + struct icmp6_hdr nd_ns_hdr; + struct in6_addr nd_ns_target; /*target address */ + /* could be followed by options */ +} __packed; + +#define nd_ns_type nd_ns_hdr.icmp6_type +#define nd_ns_code nd_ns_hdr.icmp6_code +#define nd_ns_cksum nd_ns_hdr.icmp6_cksum +#define nd_ns_reserved nd_ns_hdr.icmp6_data32[0] + +struct nd_neighbor_advert { /* neighbor advertisement */ + struct icmp6_hdr nd_na_hdr; + struct in6_addr nd_na_target; /* target address */ + /* could be followed by options */ +} __packed; + +#define nd_na_type nd_na_hdr.icmp6_type +#define nd_na_code nd_na_hdr.icmp6_code +#define nd_na_cksum nd_na_hdr.icmp6_cksum +#define nd_na_flags_reserved nd_na_hdr.icmp6_data32[0] +#define ND_NA_FLAG_ROUTER 0x80 +#define ND_NA_FLAG_SOLICITED 0x40 +#define ND_NA_FLAG_OVERRIDE 0x20 + +struct nd_redirect { /* redirect */ + struct icmp6_hdr nd_rd_hdr; + struct in6_addr nd_rd_target; /* target address */ + struct in6_addr nd_rd_dst; /* destination address */ + /* could be followed by options */ +} __packed; + +#define nd_rd_type nd_rd_hdr.icmp6_type +#define nd_rd_code nd_rd_hdr.icmp6_code +#define nd_rd_cksum nd_rd_hdr.icmp6_cksum +#define nd_rd_reserved nd_rd_hdr.icmp6_data32[0] + +struct nd_opt_hdr { /* Neighbor discovery option header */ + u_int8_t nd_opt_type; + u_int8_t nd_opt_len; + /* followed by option specific data*/ +} __packed; + +#define ND_OPT_SOURCE_LINKADDR 1 +#define ND_OPT_TARGET_LINKADDR 2 +#define ND_OPT_PREFIX_INFORMATION 3 +#define ND_OPT_REDIRECTED_HEADER 4 +#define ND_OPT_MTU 5 +#define ND_OPT_ADVINTERVAL 7 +#define ND_OPT_HOMEAGENT_INFO 8 +#define ND_OPT_SOURCE_ADDRLIST 9 +#define ND_OPT_TARGET_ADDRLIST 10 +#define ND_OPT_MAP 23 /* RFC 5380 */ +#define ND_OPT_ROUTE_INFO 24 /* RFC 4191 */ +#define ND_OPT_RDNSS 25 /* RFC 6016 */ +#define ND_OPT_DNSSL 31 /* RFC 6016 */ + +struct nd_opt_route_info { /* route info */ + u_int8_t nd_opt_rti_type; + u_int8_t nd_opt_rti_len; + u_int8_t nd_opt_rti_prefixlen; + u_int8_t nd_opt_rti_flags; + u_int32_t nd_opt_rti_lifetime; + /* prefix follows */ +}; + +struct nd_opt_prefix_info { /* prefix information */ + u_int8_t nd_opt_pi_type; + u_int8_t nd_opt_pi_len; + u_int8_t nd_opt_pi_prefix_len; + u_int8_t nd_opt_pi_flags_reserved; + u_int32_t nd_opt_pi_valid_time; + u_int32_t nd_opt_pi_preferred_time; + u_int32_t nd_opt_pi_reserved2; + struct in6_addr nd_opt_pi_prefix; +} __packed; + +#define ND_OPT_PI_FLAG_ONLINK 0x80 +#define ND_OPT_PI_FLAG_AUTO 0x40 + +struct nd_opt_rd_hdr { /* redirected header */ + u_int8_t nd_opt_rh_type; + u_int8_t nd_opt_rh_len; + u_int16_t nd_opt_rh_reserved1; + u_int32_t nd_opt_rh_reserved2; + /* followed by IP header and data */ +} __packed; + +struct nd_opt_mtu { /* MTU option */ + u_int8_t nd_opt_mtu_type; + u_int8_t nd_opt_mtu_len; + u_int16_t nd_opt_mtu_reserved; + u_int32_t nd_opt_mtu_mtu; +} __packed; + +struct nd_opt_rdnss { /* RDNSS option RFC 6106 */ + u_int8_t nd_opt_rdnss_type; + u_int8_t nd_opt_rdnss_len; + u_int16_t nd_opt_rdnss_reserved; + u_int32_t nd_opt_rdnss_lifetime; + /* followed by list of IP prefixes */ +} __packed; + +struct nd_opt_dnssl { /* DNSSL option RFC 6106 */ + u_int8_t nd_opt_dnssl_type; + u_int8_t nd_opt_dnssl_len; + u_int16_t nd_opt_dnssl_reserved; + u_int32_t nd_opt_dnssl_lifetime; + /* followed by list of IP prefixes */ +} __packed; + +/* + * icmp6 namelookup + */ + +struct icmp6_namelookup { + struct icmp6_hdr icmp6_nl_hdr; + u_int8_t icmp6_nl_nonce[8]; + int32_t icmp6_nl_ttl; +#if 0 + u_int8_t icmp6_nl_len; + u_int8_t icmp6_nl_name[3]; +#endif + /* could be followed by options */ +} __packed; + +/* + * icmp6 node information + */ +struct icmp6_nodeinfo { + struct icmp6_hdr icmp6_ni_hdr; + u_int8_t icmp6_ni_nonce[8]; + /* could be followed by reply data */ +} __packed; + +/* + * BEGIN android-removed: glibc doesn't have these, and external/ping declares them itself. +#define ni_type icmp6_ni_hdr.icmp6_type +#define ni_code icmp6_ni_hdr.icmp6_code +#define ni_cksum icmp6_ni_hdr.icmp6_cksum +#define ni_qtype icmp6_ni_hdr.icmp6_data16[0] +#define ni_flags icmp6_ni_hdr.icmp6_data16[1] + * END android-removed + */ + +#define NI_QTYPE_NOOP 0 /* NOOP */ +#define NI_QTYPE_SUPTYPES 1 /* Supported Qtypes */ +#define NI_QTYPE_FQDN 2 /* FQDN (draft 04) */ +#define NI_QTYPE_DNSNAME 2 /* DNS Name */ +#define NI_QTYPE_NODEADDR 3 /* Node Addresses */ +#define NI_QTYPE_IPV4ADDR 4 /* IPv4 Addresses */ + +#define NI_SUPTYPE_FLAG_COMPRESS 0x0100 +#define NI_FQDN_FLAG_VALIDTTL 0x0100 + +#ifdef NAME_LOOKUPS_04 +#define NI_NODEADDR_FLAG_LINKLOCAL 0x0100 +#define NI_NODEADDR_FLAG_SITELOCAL 0x0200 +#define NI_NODEADDR_FLAG_GLOBAL 0x0400 +#define NI_NODEADDR_FLAG_ALL 0x0800 +#define NI_NODEADDR_FLAG_TRUNCATE 0x1000 +#define NI_NODEADDR_FLAG_ANYCAST 0x2000 /* just experimental. not in spec */ +#else /* draft-ietf-ipngwg-icmp-name-lookups-05 (and later?) */ +#define NI_NODEADDR_FLAG_TRUNCATE 0x0100 +#define NI_NODEADDR_FLAG_ALL 0x0200 +#define NI_NODEADDR_FLAG_COMPAT 0x0400 +#define NI_NODEADDR_FLAG_LINKLOCAL 0x0800 +#define NI_NODEADDR_FLAG_SITELOCAL 0x1000 +#define NI_NODEADDR_FLAG_GLOBAL 0x2000 +#define NI_NODEADDR_FLAG_ANYCAST 0x4000 /* just experimental. not in spec */ +#endif + +struct ni_reply_fqdn { + u_int32_t ni_fqdn_ttl; /* TTL */ + u_int8_t ni_fqdn_namelen; /* length in octets of the FQDN */ + u_int8_t ni_fqdn_name[3]; /* XXX: alignment */ +} __packed; + +/* + * Router Renumbering. as router-renum-08.txt + */ +struct icmp6_router_renum { /* router renumbering header */ + struct icmp6_hdr rr_hdr; + u_int8_t rr_segnum; + u_int8_t rr_flags; + u_int16_t rr_maxdelay; + u_int32_t rr_reserved; +} __packed; + +#define ICMP6_RR_FLAGS_TEST 0x80 +#define ICMP6_RR_FLAGS_REQRESULT 0x40 +#define ICMP6_RR_FLAGS_FORCEAPPLY 0x20 +#define ICMP6_RR_FLAGS_SPECSITE 0x10 +#define ICMP6_RR_FLAGS_PREVDONE 0x08 + +#define rr_type rr_hdr.icmp6_type +#define rr_code rr_hdr.icmp6_code +#define rr_cksum rr_hdr.icmp6_cksum +#define rr_seqnum rr_hdr.icmp6_data32[0] + +struct rr_pco_match { /* match prefix part */ + u_int8_t rpm_code; + u_int8_t rpm_len; + u_int8_t rpm_ordinal; + u_int8_t rpm_matchlen; + u_int8_t rpm_minlen; + u_int8_t rpm_maxlen; + u_int16_t rpm_reserved; + struct in6_addr rpm_prefix; +} __packed; + +#define RPM_PCO_ADD 1 +#define RPM_PCO_CHANGE 2 +#define RPM_PCO_SETGLOBAL 3 +#define RPM_PCO_MAX 4 + +struct rr_pco_use { /* use prefix part */ + u_int8_t rpu_uselen; + u_int8_t rpu_keeplen; + u_int8_t rpu_ramask; + u_int8_t rpu_raflags; + u_int32_t rpu_vltime; + u_int32_t rpu_pltime; + u_int32_t rpu_flags; + struct in6_addr rpu_prefix; +} __packed; +#define ICMP6_RR_PCOUSE_RAFLAGS_ONLINK 0x80 +#define ICMP6_RR_PCOUSE_RAFLAGS_AUTO 0x40 + +#define ICMP6_RR_PCOUSE_FLAGS_DECRVLTIME 0x80 +#define ICMP6_RR_PCOUSE_FLAGS_DECRPLTIME 0x40 + +struct rr_result { /* router renumbering result message */ + u_int16_t rrr_flags; + u_int8_t rrr_ordinal; + u_int8_t rrr_matchedlen; + u_int32_t rrr_ifid; + struct in6_addr rrr_prefix; +} __packed; +#define ICMP6_RR_RESULT_FLAGS_OOB 0x0200 +#define ICMP6_RR_RESULT_FLAGS_FORBIDDEN 0x0100 + +/* + * icmp6 filter structures. + */ + +struct icmp6_filter { + u_int32_t icmp6_filt[8]; +}; + +/* + * BEGIN android-changed + * Linux and *BSD kernels use opposite values to indicate pass/block in ICMPv6 + * filters, and assign a different value to the ICMP6_FILTER sockopt. + */ +#define ICMP6_FILTER 1 + +#define ICMP6_FILTER_SETPASSALL(filterp) \ + (void)memset(filterp, 0x00, sizeof(struct icmp6_filter)) +#define ICMP6_FILTER_SETBLOCKALL(filterp) \ + (void)memset(filterp, 0xff, sizeof(struct icmp6_filter)) +#define ICMP6_FILTER_SETPASS(type, filterp) \ + (((filterp)->icmp6_filt[(type) >> 5]) &= ~(1 << ((type) & 31))) +#define ICMP6_FILTER_SETBLOCK(type, filterp) \ + (((filterp)->icmp6_filt[(type) >> 5]) |= (1 << ((type) & 31))) +#define ICMP6_FILTER_WILLPASS(type, filterp) \ + ((((filterp)->icmp6_filt[(type) >> 5]) & (1 << ((type) & 31))) == 0) +#define ICMP6_FILTER_WILLBLOCK(type, filterp) \ + ((((filterp)->icmp6_filt[(type) >> 5]) & (1 << ((type) & 31))) != 0) +/* + * END android-changed + */ + +#endif /* !_NETINET_ICMP6_H_ */ diff --git a/headers/netinet/if_ether.h b/headers/netinet/if_ether.h new file mode 100644 index 000000000..b1b9ed0fe --- /dev/null +++ b/headers/netinet/if_ether.h @@ -0,0 +1,110 @@ +/* $NetBSD: if_ether.h,v 1.34 2007/12/25 18:33:46 perry Exp $ */ + +/* + * Copyright (c) 1982, 1986, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)if_ether.h 8.3 (Berkeley) 5/2/95 + */ + +#ifndef _NETINET_IF_ETHER_H_ +#define _NETINET_IF_ETHER_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +#if defined(__USE_BSD) + +/* pull in Ethernet-specific definitions and packet structures */ + +#include <linux/if_ether.h> + +/* pull in ARP-specific definitions and packet structures */ + +#include <net/if_arp.h> + +#include <net/ethernet.h> + +/* ... and define some more which we don't need anymore: */ + +/* + * Ethernet Address Resolution Protocol. + * + * See RFC 826 for protocol description. Structure below is not + * used by our kernel!!! Only for userland programs which are externally + * maintained and need it. + */ + +struct ether_arp { + struct arphdr ea_hdr; /* fixed-size header */ + u_int8_t arp_sha[ETHER_ADDR_LEN]; /* sender hardware address */ + u_int8_t arp_spa[4]; /* sender protocol address */ + u_int8_t arp_tha[ETHER_ADDR_LEN]; /* target hardware address */ + u_int8_t arp_tpa[4]; /* target protocol address */ +} __packed; +#define arp_hrd ea_hdr.ar_hrd +#define arp_pro ea_hdr.ar_pro +#define arp_hln ea_hdr.ar_hln +#define arp_pln ea_hdr.ar_pln +#define arp_op ea_hdr.ar_op + +/* + * Macro to map an IP multicast address to an Ethernet multicast address. + * The high-order 25 bits of the Ethernet address are statically assigned, + * and the low-order 23 bits are taken from the low end of the IP address. + */ +#define ETHER_MAP_IP_MULTICAST(ipaddr, enaddr) \ + /* struct in_addr *ipaddr; */ \ + /* u_int8_t enaddr[ETHER_ADDR_LEN]; */ \ +{ \ + (enaddr)[0] = 0x01; \ + (enaddr)[1] = 0x00; \ + (enaddr)[2] = 0x5e; \ + (enaddr)[3] = ((u_int8_t *)ipaddr)[1] & 0x7f; \ + (enaddr)[4] = ((u_int8_t *)ipaddr)[2]; \ + (enaddr)[5] = ((u_int8_t *)ipaddr)[3]; \ +} +/* + * Macro to map an IP6 multicast address to an Ethernet multicast address. + * The high-order 16 bits of the Ethernet address are statically assigned, + * and the low-order 32 bits are taken from the low end of the IP6 address. + */ +#define ETHER_MAP_IPV6_MULTICAST(ip6addr, enaddr) \ + /* struct in6_addr *ip6addr; */ \ + /* u_int8_t enaddr[ETHER_ADDR_LEN]; */ \ +{ \ + (enaddr)[0] = 0x33; \ + (enaddr)[1] = 0x33; \ + (enaddr)[2] = ((u_int8_t *)ip6addr)[12]; \ + (enaddr)[3] = ((u_int8_t *)ip6addr)[13]; \ + (enaddr)[4] = ((u_int8_t *)ip6addr)[14]; \ + (enaddr)[5] = ((u_int8_t *)ip6addr)[15]; \ +} + +#endif /* __USE_BSD */ + +#endif /* !_NET_IF_ETHER_H_ */ diff --git a/headers/netinet/in.h b/headers/netinet/in.h new file mode 100644 index 000000000..10fbafa99 --- /dev/null +++ b/headers/netinet/in.h @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _NETINET_IN_H_ +#define _NETINET_IN_H_ + +#include <endian.h> +#include <netinet/in6.h> +#include <sys/cdefs.h> +#include <sys/socket.h> + +#include <linux/in.h> +#include <linux/in6.h> +#include <linux/ipv6.h> + +__BEGIN_DECLS + +#define INET_ADDRSTRLEN 16 + +typedef uint16_t in_port_t; +typedef uint32_t in_addr_t; + +int bindresvport(int, struct sockaddr_in*); + +#if __ANDROID_API__ >= __ANDROID_API_N__ +extern const struct in6_addr in6addr_any __INTRODUCED_IN(24); +extern const struct in6_addr in6addr_loopback __INTRODUCED_IN(24); +#else +static const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT; +static const struct in6_addr in6addr_loopback = IN6ADDR_LOOPBACK_INIT; +#endif /* __ANDROID_API__ >= __ANDROID_API_N__ */ + +__END_DECLS + +#endif /* _NETINET_IN_H_ */ diff --git a/headers/netinet/in6.h b/headers/netinet/in6.h new file mode 100644 index 000000000..ae20f835c --- /dev/null +++ b/headers/netinet/in6.h @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _NETINET_IN6_H +#define _NETINET_IN6_H + +#include <sys/cdefs.h> + +#include <linux/in6.h> + +#define IN6_IS_ADDR_UNSPECIFIED(a) \ + ((((a)->s6_addr32[0]) == 0) && \ + (((a)->s6_addr32[1]) == 0) && \ + (((a)->s6_addr32[2]) == 0) && \ + (((a)->s6_addr32[3]) == 0)) + +#define IN6_IS_ADDR_LOOPBACK(a) \ + ((((a)->s6_addr32[0]) == 0) && \ + (((a)->s6_addr32[1]) == 0) && \ + (((a)->s6_addr32[2]) == 0) && \ + (((a)->s6_addr32[3]) == ntohl(1))) + +#define IN6_IS_ADDR_V4COMPAT(a) \ + ((((a)->s6_addr32[0]) == 0) && \ + (((a)->s6_addr32[1]) == 0) && \ + (((a)->s6_addr32[2]) == 0) && \ + (((a)->s6_addr32[3]) != 0) && (((a)->s6_addr32[3]) != ntohl(1))) + +#define IN6_IS_ADDR_V4MAPPED(a) \ + ((((a)->s6_addr32[0]) == 0) && \ + (((a)->s6_addr32[1]) == 0) && \ + (((a)->s6_addr32[2]) == ntohl(0x0000ffff))) + +#define __bionic_s6_addr(a) __BIONIC_CAST(reinterpret_cast, const uint8_t*, a) + +#define IN6_IS_ADDR_LINKLOCAL(a) \ + ((__bionic_s6_addr(a)[0] == 0xfe) && ((__bionic_s6_addr(a)[1] & 0xc0) == 0x80)) + +#define IN6_IS_ADDR_SITELOCAL(a) \ + ((__bionic_s6_addr(a)[0] == 0xfe) && ((__bionic_s6_addr(a)[1] & 0xc0) == 0xc0)) + +#define IN6_IS_ADDR_MULTICAST(a) (__bionic_s6_addr(a)[0] == 0xff) + +#define IN6_IS_ADDR_ULA(a) ((__bionic_s6_addr(a)[0] & 0xfe) == 0xfc) + +#define IPV6_ADDR_SCOPE_NODELOCAL 0x01 +#define IPV6_ADDR_SCOPE_INTFACELOCAL 0x01 +#define IPV6_ADDR_SCOPE_LINKLOCAL 0x02 +#define IPV6_ADDR_SCOPE_SITELOCAL 0x05 +#define IPV6_ADDR_SCOPE_ORGLOCAL 0x08 +#define IPV6_ADDR_SCOPE_GLOBAL 0x0e + +#define IPV6_ADDR_MC_SCOPE(a) (__bionic_s6_addr(a)[1] & 0x0f) + +#define IN6_IS_ADDR_MC_NODELOCAL(a) \ + (IN6_IS_ADDR_MULTICAST(a) && (IPV6_ADDR_MC_SCOPE(a) == IPV6_ADDR_SCOPE_NODELOCAL)) +#define IN6_IS_ADDR_MC_LINKLOCAL(a) \ + (IN6_IS_ADDR_MULTICAST(a) && (IPV6_ADDR_MC_SCOPE(a) == IPV6_ADDR_SCOPE_LINKLOCAL)) +#define IN6_IS_ADDR_MC_SITELOCAL(a) \ + (IN6_IS_ADDR_MULTICAST(a) && (IPV6_ADDR_MC_SCOPE(a) == IPV6_ADDR_SCOPE_SITELOCAL)) +#define IN6_IS_ADDR_MC_ORGLOCAL(a) \ + (IN6_IS_ADDR_MULTICAST(a) && (IPV6_ADDR_MC_SCOPE(a) == IPV6_ADDR_SCOPE_ORGLOCAL)) +#define IN6_IS_ADDR_MC_GLOBAL(a) \ + (IN6_IS_ADDR_MULTICAST(a) && (IPV6_ADDR_MC_SCOPE(a) == IPV6_ADDR_SCOPE_GLOBAL)) + +#define IN6_ARE_ADDR_EQUAL(a, b) \ + (memcmp(&(a)->s6_addr[0], &(b)->s6_addr[0], sizeof(struct in6_addr)) == 0) + +#define INET6_ADDRSTRLEN 46 + +#define IPV6_JOIN_GROUP IPV6_ADD_MEMBERSHIP +#define IPV6_LEAVE_GROUP IPV6_DROP_MEMBERSHIP + +#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 ipv6mr_interface ipv6mr_ifindex + +#endif /* _NETINET_IN6_H */ diff --git a/headers/netinet/in_systm.h b/headers/netinet/in_systm.h new file mode 100644 index 000000000..8da19a5d8 --- /dev/null +++ b/headers/netinet/in_systm.h @@ -0,0 +1,58 @@ +/* $NetBSD: in_systm.h,v 1.13 2005/12/10 23:36:23 elad Exp $ */ + +/* + * Copyright (c) 1982, 1986, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)in_systm.h 8.1 (Berkeley) 6/10/93 + */ + +#ifndef _NETINET_IN_SYSTM_H_ +#define _NETINET_IN_SYSTM_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +/* + * Miscellaneous internetwork + * definitions for kernel. + */ + +/* + * Network types. + * + * Internally the system keeps counters in the headers with the bytes + * swapped so that VAX instructions will work on them. It reverses + * the bytes before transmission at each protocol level. The n_ types + * represent the types with the bytes in ``high-ender'' order. + */ +typedef u_int16_t n_short; /* short as received from the net */ +typedef u_int32_t n_long; /* long as received from the net */ + +typedef u_int32_t n_time; /* ms since 00:00 GMT, byte rev */ + +#endif /* !_NETINET_IN_SYSTM_H_ */ diff --git a/headers/netinet/ip.h b/headers/netinet/ip.h new file mode 100644 index 000000000..48219334c --- /dev/null +++ b/headers/netinet/ip.h @@ -0,0 +1,263 @@ +/* $OpenBSD: ip.h,v 1.12 2006/04/27 02:19:32 tedu Exp $ */ +/* $NetBSD: ip.h,v 1.9 1995/05/15 01:22:44 cgd Exp $ */ + +/* + * Copyright (c) 1982, 1986, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)ip.h 8.1 (Berkeley) 6/10/93 + */ + +#ifndef _NETINET_IP_H_ +#define _NETINET_IP_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <endian.h> +#include <netinet/in.h> +#include <netinet/in_systm.h> + +__BEGIN_DECLS + +/* + * Definitions for internet protocol version 4. + * Per RFC 791, September 1981. + */ +#define IPVERSION 4 + +/* + * Structure of an internet header, naked of options. + */ +struct ip { + u_int32_t ip_hl:4, /* header length */ + ip_v:4; /* version */ + u_int8_t ip_tos; /* type of service */ + u_int16_t ip_len; /* total length */ + u_int16_t ip_id; /* identification */ + u_int16_t ip_off; /* fragment offset field */ +#define IP_RF 0x8000 /* reserved fragment flag */ +#define IP_DF 0x4000 /* dont fragment flag */ +#define IP_MF 0x2000 /* more fragments flag */ +#define IP_OFFMASK 0x1fff /* mask for fragmenting bits */ + u_int8_t ip_ttl; /* time to live */ + u_int8_t ip_p; /* protocol */ + u_int16_t ip_sum; /* checksum */ + struct in_addr ip_src, ip_dst; /* source and dest address */ +}; + +#define IP_MAXPACKET 65535 /* maximum packet size */ + +/* + * Definitions for IP type of service (ip_tos) + */ +#define IPTOS_LOWDELAY 0x10 +#define IPTOS_THROUGHPUT 0x08 +#define IPTOS_RELIABILITY 0x04 +#define IPTOS_MINCOST 0x02 +#if 1 +/* ECN RFC3168 obsoletes RFC2481, and these will be deprecated soon. */ +#define IPTOS_CE 0x01 /* congestion experienced */ +#define IPTOS_ECT 0x02 /* ECN-capable transport */ +#endif + +/* + * Definitions for IP precedence (also in ip_tos) (hopefully unused) + */ +#define IPTOS_PREC_NETCONTROL 0xe0 +#define IPTOS_PREC_INTERNETCONTROL 0xc0 +#define IPTOS_PREC_CRITIC_ECP 0xa0 +#define IPTOS_PREC_FLASHOVERRIDE 0x80 +#define IPTOS_PREC_FLASH 0x60 +#define IPTOS_PREC_IMMEDIATE 0x40 +#define IPTOS_PREC_PRIORITY 0x20 +#define IPTOS_PREC_ROUTINE 0x00 + +/* + * ECN (Explicit Congestion Notification) codepoints in RFC3168 + * mapped to the lower 2 bits of the TOS field. + */ +#define IPTOS_ECN_NOTECT 0x00 /* not-ECT */ +#define IPTOS_ECN_ECT1 0x01 /* ECN-capable transport (1) */ +#define IPTOS_ECN_ECT0 0x02 /* ECN-capable transport (0) */ +#define IPTOS_ECN_CE 0x03 /* congestion experienced */ +#define IPTOS_ECN_MASK 0x03 /* ECN field mask */ + +/* + * Definitions for options. + */ +#define IPOPT_COPIED(o) ((o)&0x80) +#define IPOPT_CLASS(o) ((o)&0x60) +#define IPOPT_NUMBER(o) ((o)&0x1f) + +#define IPOPT_CONTROL 0x00 +#define IPOPT_RESERVED1 0x20 +#define IPOPT_DEBMEAS 0x40 +#define IPOPT_RESERVED2 0x60 + +#define IPOPT_EOL 0 /* end of option list */ +#define IPOPT_NOP 1 /* no operation */ + +#define IPOPT_RR 7 /* record packet route */ +#define IPOPT_TS 68 /* timestamp */ +#define IPOPT_SECURITY 130 /* provide s,c,h,tcc */ +#define IPOPT_LSRR 131 /* loose source route */ +#define IPOPT_SATID 136 /* satnet id */ +#define IPOPT_SSRR 137 /* strict source route */ + +/* + * Offsets to fields in options other than EOL and NOP. + */ +#define IPOPT_OPTVAL 0 /* option ID */ +#define IPOPT_OLEN 1 /* option length */ +#define IPOPT_OFFSET 2 /* offset within option */ +#define IPOPT_MINOFF 4 /* min value of above */ + +/* + * Time stamp option structure. + */ +struct ip_timestamp { + u_int8_t ipt_code; /* IPOPT_TS */ + u_int8_t ipt_len; /* size of structure (variable) */ + u_int8_t ipt_ptr; /* index of current entry */ + u_int32_t ipt_flg:4, /* flags, see below */ + ipt_oflw:4; /* overflow counter */ + union ipt_timestamp { + n_time ipt_time[1]; + struct ipt_ta { + struct in_addr ipt_addr; + n_time ipt_time; + } ipt_ta[1]; + } ipt_timestamp; +}; + +/* flag bits for ipt_flg */ +#define IPOPT_TS_TSONLY 0 /* timestamps only */ +#define IPOPT_TS_TSANDADDR 1 /* timestamps and addresses */ +#define IPOPT_TS_PRESPEC 3 /* specified modules only */ + +/* bits for security (not byte swapped) */ +#define IPOPT_SECUR_UNCLASS 0x0000 +#define IPOPT_SECUR_CONFID 0xf135 +#define IPOPT_SECUR_EFTO 0x789a +#define IPOPT_SECUR_MMMM 0xbc4d +#define IPOPT_SECUR_RESTR 0xaf13 +#define IPOPT_SECUR_SECRET 0xd788 +#define IPOPT_SECUR_TOPSECRET 0x6bc5 + +/* + * Internet implementation parameters. + */ +#define MAXTTL 255 /* maximum time to live (seconds) */ +#define IPDEFTTL 64 /* default ttl, from RFC 1340 */ +#define IPFRAGTTL 60 /* time to live for frags, slowhz */ +#define IPTTLDEC 1 /* subtracted when forwarding */ + +#define IP_MSS 576 /* default maximum segment size */ + +/* + * This is the real IPv4 pseudo header, used for computing the TCP and UDP + * checksums. For the Internet checksum, struct ipovly can be used instead. + * For stronger checksums, the real thing must be used. + */ +struct ippseudo { + struct in_addr ippseudo_src; /* source internet address */ + struct in_addr ippseudo_dst; /* destination internet address */ + u_int8_t ippseudo_pad; /* pad, must be zero */ + u_int8_t ippseudo_p; /* protocol */ + u_int16_t ippseudo_len; /* protocol length */ +}; + +/* BIONIC addition: declarations matching the Linux kernel */ +/* some programs expect these... */ + +#define IPOPT_OPTVAL 0 +#define IPOPT_OLEN 1 +#define IPOPT_OFFSET 2 +#define IPOPT_MINOFF 4 +#define MAX_IPOPTLEN 40 + +#define IPOPT_COPY 0x80 +#define IPOPT_CLASS_MASK 0x60 +#define IPOPT_NUMBER_MASK 0x1f + +#define IPOPT_CONTROL 0x00 +#define IPOPT_RESERVED1 0x20 +#define IPOPT_MEASUREMENT 0x40 +#define IPOPT_RESERVED2 0x60 + +#define IPOPT_END (0 |IPOPT_CONTROL) +#define IPOPT_NOOP (1 |IPOPT_CONTROL) +#define IPOPT_SEC (2 |IPOPT_CONTROL|IPOPT_COPY) +#define IPOPT_TIMESTAMP (4 |IPOPT_MEASUREMENT) +#define IPOPT_SID (8 |IPOPT_CONTROL|IPOPT_COPY) +#define IPOPT_RA (20|IPOPT_CONTROL|IPOPT_COPY) + +struct iphdr { +#if defined(__LITTLE_ENDIAN_BITFIELD) + uint8_t ihl :4, + version:4; +#elif defined (__BIG_ENDIAN_BITFIELD) + uint8_t version:4, + ihl :4; +#else +#error "Please fix <asm/byteorder.h>" +#endif + uint8_t tos; + uint16_t tot_len; + uint16_t id; + uint16_t frag_off; + uint8_t ttl; + uint8_t protocol; + uint16_t check; + int32_t saddr; + int32_t daddr; +}; + +struct ip_auth_hdr { + uint8_t nexthdr; + uint8_t hdrlen; + uint16_t reserved; + uint32_t spi; + uint32_t seq_no; + uint8_t auth_data[0]; +}; + +struct ip_esp_hdr { + uint32_t spi; + uint32_t seq_no; + uint8_t enc_data[0]; +}; + +struct ip_comp_hdr { + uint8_t nexthdr; + uint8_t flags; + uint16_t cpi; +}; + +__END_DECLS + +#endif /* _NETINET_IP_H_ */ diff --git a/headers/netinet/ip6.h b/headers/netinet/ip6.h new file mode 100644 index 000000000..b4f6ce600 --- /dev/null +++ b/headers/netinet/ip6.h @@ -0,0 +1,242 @@ +/* $NetBSD: ip6.h,v 1.23 2007/12/25 18:33:46 perry Exp $ */ +/* $KAME: ip6.h,v 1.45 2003/06/05 04:46:38 keiichi Exp $ */ + +/* + * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the project nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * Copyright (c) 1982, 1986, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)ip.h 8.1 (Berkeley) 6/10/93 + */ + +#ifndef _NETINET_IP6_H_ +#define _NETINET_IP6_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <endian.h> + +#include <linux/in6.h> + +/* + * Definition for internet protocol version 6. + * RFC 2460 + */ + +struct ip6_hdr { + union { + struct ip6_hdrctl { + u_int32_t ip6_un1_flow; /* 20 bits of flow-ID */ + u_int16_t ip6_un1_plen; /* payload length */ + u_int8_t ip6_un1_nxt; /* next header */ + u_int8_t ip6_un1_hlim; /* hop limit */ + } ip6_un1; + u_int8_t ip6_un2_vfc; /* 4 bits version, top 4 bits class */ + } ip6_ctlun; + struct in6_addr ip6_src; /* source address */ + struct in6_addr ip6_dst; /* destination address */ +} __packed; + +#define ip6_vfc ip6_ctlun.ip6_un2_vfc +#define ip6_flow ip6_ctlun.ip6_un1.ip6_un1_flow +#define ip6_plen ip6_ctlun.ip6_un1.ip6_un1_plen +#define ip6_nxt ip6_ctlun.ip6_un1.ip6_un1_nxt +#define ip6_hlim ip6_ctlun.ip6_un1.ip6_un1_hlim +#define ip6_hops ip6_ctlun.ip6_un1.ip6_un1_hlim + +#define IPV6_VERSION 0x60 +#define IPV6_VERSION_MASK 0xf0 + +#define IPV6_FLOWINFO_MASK 0xffffff0f /* flow info (28 bits) */ +#define IPV6_FLOWLABEL_MASK 0xffff0f00 /* flow label (20 bits) */ + +#if 1 +/* ECN bits proposed by Sally Floyd */ +#define IP6TOS_CE 0x01 /* congestion experienced */ +#define IP6TOS_ECT 0x02 /* ECN-capable transport */ +#endif + +/* + * Extension Headers + */ + +struct ip6_ext { + u_int8_t ip6e_nxt; + u_int8_t ip6e_len; +} __packed; + +/* Hop-by-Hop options header */ +/* XXX should we pad it to force alignment on an 8-byte boundary? */ +struct ip6_hbh { + u_int8_t ip6h_nxt; /* next header */ + u_int8_t ip6h_len; /* length in units of 8 octets */ + /* followed by options */ +} __packed; + +/* Destination options header */ +/* XXX should we pad it to force alignment on an 8-byte boundary? */ +struct ip6_dest { + u_int8_t ip6d_nxt; /* next header */ + u_int8_t ip6d_len; /* length in units of 8 octets */ + /* followed by options */ +} __packed; + +/* Option types and related macros */ +#define IP6OPT_PAD1 0x00 /* 00 0 00000 */ +#define IP6OPT_PADN 0x01 /* 00 0 00001 */ +#define IP6OPT_JUMBO 0xC2 /* 11 0 00010 = 194 */ +#define IP6OPT_NSAP_ADDR 0xC3 /* 11 0 00011 */ +#define IP6OPT_TUNNEL_LIMIT 0x04 /* 00 0 00100 */ +#define IP6OPT_RTALERT 0x05 /* 00 0 00101 (KAME definition) */ +#define IP6OPT_ROUTER_ALERT 0x05 /* (RFC3542 def, recommended) */ + +#define IP6OPT_RTALERT_LEN 4 +#define IP6OPT_RTALERT_MLD 0 /* Datagram contains an MLD message */ +#define IP6OPT_RTALERT_RSVP 1 /* Datagram contains an RSVP message */ +#define IP6OPT_RTALERT_ACTNET 2 /* contains an Active Networks msg */ +#define IP6OPT_MINLEN 2 + +#define IP6OPT_TYPE(o) ((o) & 0xC0) +#define IP6OPT_TYPE_SKIP 0x00 +#define IP6OPT_TYPE_DISCARD 0x40 +#define IP6OPT_TYPE_FORCEICMP 0x80 +#define IP6OPT_TYPE_ICMP 0xC0 + +#define IP6OPT_MUTABLE 0x20 + +/* IPv6 options: common part */ +struct ip6_opt { + u_int8_t ip6o_type; + u_int8_t ip6o_len; +} __packed; + +/* Jumbo Payload Option */ +struct ip6_opt_jumbo { + u_int8_t ip6oj_type; + u_int8_t ip6oj_len; + u_int8_t ip6oj_jumbo_len[4]; +} __packed; +#define IP6OPT_JUMBO_LEN 6 + +/* NSAP Address Option */ +struct ip6_opt_nsap { + u_int8_t ip6on_type; + u_int8_t ip6on_len; + u_int8_t ip6on_src_nsap_len; + u_int8_t ip6on_dst_nsap_len; + /* followed by source NSAP */ + /* followed by destination NSAP */ +} __packed; + +/* Tunnel Limit Option */ +struct ip6_opt_tunnel { + u_int8_t ip6ot_type; + u_int8_t ip6ot_len; + u_int8_t ip6ot_encap_limit; +} __packed; + +/* Router Alert Option */ +struct ip6_opt_router { + u_int8_t ip6or_type; + u_int8_t ip6or_len; + u_int8_t ip6or_value[2]; +} __packed; +/* Router alert values (in network byte order) */ +#define IP6_ALERT_MLD 0x0000 +#define IP6_ALERT_RSVP 0x0100 +#define IP6_ALERT_AN 0x0200 + +/* Routing header */ +struct ip6_rthdr { + u_int8_t ip6r_nxt; /* next header */ + u_int8_t ip6r_len; /* length in units of 8 octets */ + u_int8_t ip6r_type; /* routing type */ + u_int8_t ip6r_segleft; /* segments left */ + /* followed by routing type specific data */ +} __packed; + +/* Type 0 Routing header */ +struct ip6_rthdr0 { + u_int8_t ip6r0_nxt; /* next header */ + u_int8_t ip6r0_len; /* length in units of 8 octets */ + u_int8_t ip6r0_type; /* always zero */ + u_int8_t ip6r0_segleft; /* segments left */ + u_int32_t ip6r0_reserved; /* reserved field */ +} __packed; + +/* Fragment header */ +struct ip6_frag { + u_int8_t ip6f_nxt; /* next header */ + u_int8_t ip6f_reserved; /* reserved field */ + u_int16_t ip6f_offlg; /* offset, reserved, and flag */ + u_int32_t ip6f_ident; /* identification */ +} __packed; + +#define IP6F_OFF_MASK 0xf8ff /* mask out offset from _offlg */ +#define IP6F_RESERVED_MASK 0x0600 /* reserved bits in ip6f_offlg */ +#define IP6F_MORE_FRAG 0x0100 /* more-fragments flag */ + +/* + * Internet implementation parameters. + */ +#define IPV6_MAXHLIM 255 /* maximum hoplimit */ +#define IPV6_DEFHLIM 64 /* default hlim */ +#define IPV6_FRAGTTL 120 /* ttl for fragment packets, in slowtimo tick */ +#define IPV6_HLIMDEC 1 /* subtracted when forwarding */ + +#define IPV6_MMTU 1280 /* minimal MTU and reassembly. 1024 + 256 */ +#define IPV6_MAXPACKET 65535 /* ip6 max packet size without Jumbo payload*/ + +#endif /* !_NETINET_IP6_H_ */ diff --git a/headers/netinet/ip_icmp.h b/headers/netinet/ip_icmp.h new file mode 100644 index 000000000..75105927f --- /dev/null +++ b/headers/netinet/ip_icmp.h @@ -0,0 +1,214 @@ +/* $OpenBSD: ip_icmp.h,v 1.21 2005/07/31 03:30:55 pascoe Exp $ */ +/* $NetBSD: ip_icmp.h,v 1.10 1996/02/13 23:42:28 christos Exp $ */ + +/* + * Copyright (c) 1982, 1986, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)ip_icmp.h 8.1 (Berkeley) 6/10/93 + */ + +#ifndef _NETINET_IP_ICMP_H_ +#define _NETINET_IP_ICMP_H_ + +#include <netinet/ip.h> +#include <sys/cdefs.h> + +__BEGIN_DECLS + +/* + * Interface Control Message Protocol Definitions. + * Per RFC 792, September 1981. + * RFC 950, August 1985. (Address Mask Request / Reply) + * RFC 1256, September 1991. (Router Advertisement and Solicitation) + * RFC 1108, November 1991. (Param Problem, Missing Req. Option) + * RFC 1393, January 1993. (Traceroute) + * RFC 1475, June 1993. (Datagram Conversion Error) + * RFC 1812, June 1995. (adm prohib, host precedence, precedence cutoff) + * RFC 2002, October 1996. (Mobility changes to Router Advertisement) + */ + +/* + * ICMP Router Advertisement data + */ +struct icmp_ra_addr { + uint32_t ira_addr; + uint32_t ira_preference; +}; + +/* + * Structure of an icmp header. + */ +struct icmp { + uint8_t icmp_type; /* type of message, see below */ + uint8_t icmp_code; /* type sub code */ + uint16_t icmp_cksum; /* ones complement cksum of struct */ + union { + uint8_t ih_pptr; /* ICMP_PARAMPROB */ + struct in_addr ih_gwaddr; /* ICMP_REDIRECT */ + struct ih_idseq { + uint16_t icd_id; + uint16_t icd_seq; + } ih_idseq; + int32_t ih_void; + + /* ICMP_UNREACH_NEEDFRAG -- Path MTU Discovery (RFC1191) */ + struct ih_pmtu { + uint16_t ipm_void; + uint16_t ipm_nextmtu; + } ih_pmtu; + + struct ih_rtradv { + uint8_t irt_num_addrs; + uint8_t irt_wpa; + uint16_t irt_lifetime; + } ih_rtradv; + } icmp_hun; +#define icmp_pptr icmp_hun.ih_pptr +#define icmp_gwaddr icmp_hun.ih_gwaddr +#define icmp_id icmp_hun.ih_idseq.icd_id +#define icmp_seq icmp_hun.ih_idseq.icd_seq +#define icmp_void icmp_hun.ih_void +#define icmp_pmvoid icmp_hun.ih_pmtu.ipm_void +#define icmp_nextmtu icmp_hun.ih_pmtu.ipm_nextmtu +#define icmp_num_addrs icmp_hun.ih_rtradv.irt_num_addrs +#define icmp_wpa icmp_hun.ih_rtradv.irt_wpa +#define icmp_lifetime icmp_hun.ih_rtradv.irt_lifetime + union { + struct id_ts { + uint32_t its_otime; + uint32_t its_rtime; + uint32_t its_ttime; + } id_ts; + struct id_ip { + struct ip idi_ip; + /* options and then 64 bits of data */ + } id_ip; + uint32_t id_mask; + int8_t id_data[1]; + } icmp_dun; +#define icmp_otime icmp_dun.id_ts.its_otime +#define icmp_rtime icmp_dun.id_ts.its_rtime +#define icmp_ttime icmp_dun.id_ts.its_ttime +#define icmp_ip icmp_dun.id_ip.idi_ip +#define icmp_mask icmp_dun.id_mask +#define icmp_data icmp_dun.id_data +}; + +/* + * For IPv6 transition related ICMP errors. + */ +#define ICMP_V6ADVLENMIN (8 + sizeof(struct ip) + 40) +#define ICMP_V6ADVLEN(p) (8 + ((p)->icmp_ip.ip_hl << 2) + 40) + +/* + * Lower bounds on packet lengths for various types. + * For the error advice packets must first insure that the + * packet is large enough to contain the returned ip header. + * Only then can we do the check to see if 64 bits of packet + * data have been returned, since we need to check the returned + * ip header length. + */ +#define ICMP_MINLEN 8 /* abs minimum */ +#define ICMP_TSLEN (8 + 3 * sizeof (n_time)) /* timestamp */ +#define ICMP_MASKLEN 12 /* address mask */ +#define ICMP_ADVLENMIN (8 + sizeof (struct ip) + 8) /* min */ +#define ICMP_ADVLEN(p) (8 + ((p)->icmp_ip.ip_hl << 2) + 8) + /* N.B.: must separately check that ip_hl >= 5 */ + +/* + * Definition of type and code field values. + * http://www.iana.org/assignments/icmp-parameters + */ +#define ICMP_ECHOREPLY 0 /* echo reply */ +#define ICMP_UNREACH 3 /* dest unreachable, codes: */ +#define ICMP_UNREACH_NET 0 /* bad net */ +#define ICMP_UNREACH_HOST 1 /* bad host */ +#define ICMP_UNREACH_PROTOCOL 2 /* bad protocol */ +#define ICMP_UNREACH_PORT 3 /* bad port */ +#define ICMP_UNREACH_NEEDFRAG 4 /* IP_DF caused drop */ +#define ICMP_UNREACH_SRCFAIL 5 /* src route failed */ +#define ICMP_UNREACH_NET_UNKNOWN 6 /* unknown net */ +#define ICMP_UNREACH_HOST_UNKNOWN 7 /* unknown host */ +#define ICMP_UNREACH_ISOLATED 8 /* src host isolated */ +#define ICMP_UNREACH_NET_PROHIB 9 /* for crypto devs */ +#define ICMP_UNREACH_HOST_PROHIB 10 /* ditto */ +#define ICMP_UNREACH_TOSNET 11 /* bad tos for net */ +#define ICMP_UNREACH_TOSHOST 12 /* bad tos for host */ +#define ICMP_UNREACH_FILTER_PROHIB 13 /* prohibited access */ +#define ICMP_UNREACH_HOST_PRECEDENCE 14 /* precedence violat'n*/ +#define ICMP_UNREACH_PRECEDENCE_CUTOFF 15 /* precedence cutoff */ +#define ICMP_SOURCEQUENCH 4 /* packet lost, slow down */ +#define ICMP_REDIRECT 5 /* shorter route, codes: */ +#define ICMP_REDIRECT_NET 0 /* for network */ +#define ICMP_REDIRECT_HOST 1 /* for host */ +#define ICMP_REDIRECT_TOSNET 2 /* for tos and net */ +#define ICMP_REDIRECT_TOSHOST 3 /* for tos and host */ +#define ICMP_ALTHOSTADDR 6 /* alternate host address */ +#define ICMP_ECHO 8 /* echo service */ +#define ICMP_ROUTERADVERT 9 /* router advertisement */ +#define ICMP_ROUTERADVERT_NORMAL 0 /* normal advertisement */ +#define ICMP_ROUTERADVERT_NOROUTE_COMMON 16 /* selective routing */ +#define ICMP_ROUTERSOLICIT 10 /* router solicitation */ +#define ICMP_TIMXCEED 11 /* time exceeded, code: */ +#define ICMP_TIMXCEED_INTRANS 0 /* ttl==0 in transit */ +#define ICMP_TIMXCEED_REASS 1 /* ttl==0 in reass */ +#define ICMP_PARAMPROB 12 /* ip header bad */ +#define ICMP_PARAMPROB_ERRATPTR 0 /* req. opt. absent */ +#define ICMP_PARAMPROB_OPTABSENT 1 /* req. opt. absent */ +#define ICMP_PARAMPROB_LENGTH 2 /* bad length */ +#define ICMP_TSTAMP 13 /* timestamp request */ +#define ICMP_TSTAMPREPLY 14 /* timestamp reply */ +#define ICMP_IREQ 15 /* information request */ +#define ICMP_IREQREPLY 16 /* information reply */ +#define ICMP_MASKREQ 17 /* address mask request */ +#define ICMP_MASKREPLY 18 /* address mask reply */ +#define ICMP_TRACEROUTE 30 /* traceroute */ +#define ICMP_DATACONVERR 31 /* data conversion error */ +#define ICMP_MOBILE_REDIRECT 32 /* mobile host redirect */ +#define ICMP_IPV6_WHEREAREYOU 33 /* IPv6 where-are-you */ +#define ICMP_IPV6_IAMHERE 34 /* IPv6 i-am-here */ +#define ICMP_MOBILE_REGREQUEST 35 /* mobile registration req */ +#define ICMP_MOBILE_REGREPLY 36 /* mobile registration reply */ +#define ICMP_SKIP 39 /* SKIP */ +#define ICMP_PHOTURIS 40 /* Photuris */ +#define ICMP_PHOTURIS_UNKNOWN_INDEX 1 /* unknown sec index */ +#define ICMP_PHOTURIS_AUTH_FAILED 2 /* auth failed */ +#define ICMP_PHOTURIS_DECRYPT_FAILED 3 /* decrypt failed */ + +#define ICMP_MAXTYPE 40 + +#define ICMP_INFOTYPE(type) \ + ((type) == ICMP_ECHOREPLY || (type) == ICMP_ECHO || \ + (type) == ICMP_ROUTERADVERT || (type) == ICMP_ROUTERSOLICIT || \ + (type) == ICMP_TSTAMP || (type) == ICMP_TSTAMPREPLY || \ + (type) == ICMP_IREQ || (type) == ICMP_IREQREPLY || \ + (type) == ICMP_MASKREQ || (type) == ICMP_MASKREPLY) + +__END_DECLS + +#endif /* _NETINET_IP_ICMP_H_ */ diff --git a/headers/netinet/tcp.h b/headers/netinet/tcp.h new file mode 100644 index 000000000..147f6f76d --- /dev/null +++ b/headers/netinet/tcp.h @@ -0,0 +1,114 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _NETINET_TCP_H +#define _NETINET_TCP_H + +#include <sys/cdefs.h> +#include <stdint.h> + +#define tcphdr __kernel_tcphdr +#include <linux/tcp.h> +#undef tcphdr + +__BEGIN_DECLS + +struct tcphdr { + __extension__ union { + struct { + uint16_t th_sport; + uint16_t th_dport; + uint32_t th_seq; + uint32_t th_ack; + uint8_t th_x2:4; + uint8_t th_off:4; + uint8_t th_flags; + uint16_t th_win; + uint16_t th_sum; + uint16_t th_urp; + }; + struct { + uint16_t source; + uint16_t dest; + uint32_t seq; + uint32_t ack_seq; + uint16_t res1:4; + uint16_t doff:4; + uint16_t fin:1; + uint16_t syn:1; + uint16_t rst:1; + uint16_t psh:1; + uint16_t ack:1; + uint16_t urg:1; + uint16_t res2:2; + uint16_t window; + uint16_t check; + uint16_t urg_ptr; + }; + }; +}; + +#define TH_FIN 0x01 +#define TH_SYN 0x02 +#define TH_RST 0x04 +#define TH_PUSH 0x08 +#define TH_ACK 0x10 +#define TH_URG 0x20 + +enum { + TCP_ESTABLISHED = 1, + TCP_SYN_SENT, + TCP_SYN_RECV, + TCP_FIN_WAIT1, + TCP_FIN_WAIT2, + TCP_TIME_WAIT, + TCP_CLOSE, + TCP_CLOSE_WAIT, + TCP_LAST_ACK, + TCP_LISTEN, + TCP_CLOSING +}; + +#define TCPOPT_EOL 0 +#define TCPOPT_NOP 1 +#define TCPOPT_MAXSEG 2 +#define TCPOLEN_MAXSEG 4 +#define TCPOPT_WINDOW 3 +#define TCPOLEN_WINDOW 3 +#define TCPOPT_SACK_PERMITTED 4 +#define TCPOLEN_SACK_PERMITTED 2 +#define TCPOPT_SACK 5 +#define TCPOPT_TIMESTAMP 8 +#define TCPOLEN_TIMESTAMP 10 +#define TCPOLEN_TSTAMP_APPA (TCPOLEN_TIMESTAMP+2) + +#define TCPOPT_TSTAMP_HDR (TCPOPT_NOP<<24|TCPOPT_NOP<<16|TCPOPT_TIMESTAMP<<8|TCPOLEN_TIMESTAMP) + +__END_DECLS + +#endif /* _NETINET_TCP_H */ diff --git a/headers/netinet/udp.h b/headers/netinet/udp.h new file mode 100644 index 000000000..ef517d6c1 --- /dev/null +++ b/headers/netinet/udp.h @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _NETINET_UDP_H +#define _NETINET_UDP_H + +#include <sys/cdefs.h> +#include <sys/types.h> + +#include <linux/udp.h> + +struct udphdr { + __extension__ union { + struct /* BSD names */ { + u_int16_t uh_sport; + u_int16_t uh_dport; + u_int16_t uh_ulen; + u_int16_t uh_sum; + }; + struct /* Linux names */ { + u_int16_t source; + u_int16_t dest; + u_int16_t len; + u_int16_t check; + }; + }; +}; + +#endif /* _NETINET_UDP_H */ diff --git a/headers/netpacket/packet.h b/headers/netpacket/packet.h new file mode 100644 index 000000000..b5e8e0e11 --- /dev/null +++ b/headers/netpacket/packet.h @@ -0,0 +1 @@ +#include <linux/if_packet.h> diff --git a/headers/nl_types.h b/headers/nl_types.h new file mode 100644 index 000000000..1e837c1c2 --- /dev/null +++ b/headers/nl_types.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _NL_TYPES_H_ +#define _NL_TYPES_H_ + +#include <sys/cdefs.h> + +__BEGIN_DECLS + +#define NL_CAT_LOCALE 1 +#define NL_SETD 1 + +typedef void* nl_catd; +typedef int nl_item; + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +nl_catd catopen(const char*, int) __INTRODUCED_IN_FUTURE; +char* catgets(nl_catd, int, int, const char*) __INTRODUCED_IN_FUTURE; +int catclose(nl_catd) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + +__END_DECLS + +#endif diff --git a/headers/paths.h b/headers/paths.h new file mode 100644 index 000000000..b76d0454a --- /dev/null +++ b/headers/paths.h @@ -0,0 +1,46 @@ +/* + * Copyright (c) 1989, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)paths.h 8.1 (Berkeley) 6/2/93 + */ + +#ifndef _PATHS_H_ +#define _PATHS_H_ + +#include <sys/cdefs.h> + +#define _PATH_BSHELL "/system/bin/sh" +#define _PATH_CONSOLE "/dev/console" +#define _PATH_DEFPATH "/sbin:/system/sbin:/system/bin:/system/xbin:/vendor/bin:/vendor/xbin" +#define _PATH_DEV "/dev/" +#define _PATH_DEVNULL "/dev/null" +#define _PATH_KLOG "/proc/kmsg" +#define _PATH_MOUNTED "/proc/mounts" +#define _PATH_TTY "/dev/tty" + +#endif /* !_PATHS_H_ */ diff --git a/headers/poll.h b/headers/poll.h new file mode 100644 index 000000000..88698469e --- /dev/null +++ b/headers/poll.h @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _POLL_H_ +#define _POLL_H_ + +#include <sys/cdefs.h> +#include <linux/poll.h> +#include <signal.h> /* For sigset_t. */ +#include <time.h> /* For timespec. */ + +__BEGIN_DECLS + +typedef unsigned int nfds_t; + +int poll(struct pollfd*, nfds_t, int); + +#if __ANDROID_API__ >= 21 +int ppoll(struct pollfd*, nfds_t, const struct timespec*, const sigset_t*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + + +#if __ANDROID_API__ >= 23 +int __poll_chk(struct pollfd*, nfds_t, int, size_t) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +int __poll_real(struct pollfd*, nfds_t, int) __RENAME(poll); +__errordecl(__poll_too_small_error, "poll: pollfd array smaller than fd count"); + + +#if __ANDROID_API__ >= 23 +int __ppoll_chk(struct pollfd*, nfds_t, const struct timespec*, const sigset_t*, size_t) + __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if __ANDROID_API__ >= 21 +int __ppoll_real(struct pollfd*, nfds_t, const struct timespec*, const sigset_t*) __RENAME(ppoll) + __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +__errordecl(__ppoll_too_small_error, "ppoll: pollfd array smaller than fd count"); + +#if defined(__BIONIC_FORTIFY) + +#if __ANDROID_API__ >= __ANDROID_API_M__ +__BIONIC_FORTIFY_INLINE +int poll(struct pollfd* fds, nfds_t fd_count, int timeout) { +#if defined(__clang__) + return __poll_chk(fds, fd_count, timeout, __bos(fds)); +#else + if (__bos(fds) != __BIONIC_FORTIFY_UNKNOWN_SIZE) { + if (!__builtin_constant_p(fd_count)) { + return __poll_chk(fds, fd_count, timeout, __bos(fds)); + } else if (__bos(fds) / sizeof(*fds) < fd_count) { + __poll_too_small_error(); + } + } + return __poll_real(fds, fd_count, timeout); +#endif +} + +__BIONIC_FORTIFY_INLINE +int ppoll(struct pollfd* fds, nfds_t fd_count, const struct timespec* timeout, const sigset_t* mask) { +#if defined(__clang__) + return __ppoll_chk(fds, fd_count, timeout, mask, __bos(fds)); +#else + if (__bos(fds) != __BIONIC_FORTIFY_UNKNOWN_SIZE) { + if (!__builtin_constant_p(fd_count)) { + return __ppoll_chk(fds, fd_count, timeout, mask, __bos(fds)); + } else if (__bos(fds) / sizeof(*fds) < fd_count) { + __ppoll_too_small_error(); + } + } + return __ppoll_real(fds, fd_count, timeout, mask); +#endif +} +#endif /* __ANDROID_API__ >= __ANDROID_API_M__ */ + +#endif + +__END_DECLS + +#endif /* _POLL_H_ */ diff --git a/headers/pthread.h b/headers/pthread.h new file mode 100644 index 000000000..62ac774db --- /dev/null +++ b/headers/pthread.h @@ -0,0 +1,275 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _PTHREAD_H_ +#define _PTHREAD_H_ + +#include <limits.h> +#include <bits/pthread_types.h> +#include <sched.h> +#include <sys/cdefs.h> +#include <sys/types.h> +#include <time.h> + +__BEGIN_DECLS + +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wnullability-completeness" +#endif + +enum { + PTHREAD_MUTEX_NORMAL = 0, + PTHREAD_MUTEX_RECURSIVE = 1, + PTHREAD_MUTEX_ERRORCHECK = 2, + + PTHREAD_MUTEX_ERRORCHECK_NP = PTHREAD_MUTEX_ERRORCHECK, + PTHREAD_MUTEX_RECURSIVE_NP = PTHREAD_MUTEX_RECURSIVE, + + PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL +}; + +#define PTHREAD_MUTEX_INITIALIZER { { ((PTHREAD_MUTEX_NORMAL & 3) << 14) } } +#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP { { ((PTHREAD_MUTEX_RECURSIVE & 3) << 14) } } +#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP { { ((PTHREAD_MUTEX_ERRORCHECK & 3) << 14) } } + +#define PTHREAD_COND_INITIALIZER { { 0 } } + +#define PTHREAD_RWLOCK_INITIALIZER { { 0 } } + +enum { + PTHREAD_RWLOCK_PREFER_READER_NP = 0, + PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP = 1, +}; + +#define PTHREAD_ONCE_INIT 0 + +#define PTHREAD_BARRIER_SERIAL_THREAD -1 + +#if defined(__LP64__) +#define PTHREAD_STACK_MIN (4 * PAGE_SIZE) +#else +#define PTHREAD_STACK_MIN (2 * PAGE_SIZE) +#endif + +#define PTHREAD_CREATE_DETACHED 0x00000001 +#define PTHREAD_CREATE_JOINABLE 0x00000000 + +#define PTHREAD_PROCESS_PRIVATE 0 +#define PTHREAD_PROCESS_SHARED 1 + +#define PTHREAD_SCOPE_SYSTEM 0 +#define PTHREAD_SCOPE_PROCESS 1 + + +#if __ANDROID_API__ >= 12 +int pthread_atfork(void (*)(void), void (*)(void), void (*)(void)) __INTRODUCED_IN(12); +#endif /* __ANDROID_API__ >= 12 */ + + +int pthread_attr_destroy(pthread_attr_t* _Nonnull); +int pthread_attr_getdetachstate(const pthread_attr_t* _Nonnull, int* _Nonnull); +int pthread_attr_getguardsize(const pthread_attr_t* _Nonnull, size_t* _Nonnull); +int pthread_attr_getschedparam(const pthread_attr_t* _Nonnull, struct sched_param* _Nonnull); +int pthread_attr_getschedpolicy(const pthread_attr_t* _Nonnull, int* _Nonnull); +int pthread_attr_getscope(const pthread_attr_t* _Nonnull, int* _Nonnull); +int pthread_attr_getstack(const pthread_attr_t* _Nonnull, void** _Nonnull, size_t* _Nonnull); +int pthread_attr_getstacksize(const pthread_attr_t* _Nonnull, size_t* _Nonnull); +int pthread_attr_init(pthread_attr_t* _Nonnull); +int pthread_attr_setdetachstate(pthread_attr_t* _Nonnull, int); +int pthread_attr_setguardsize(pthread_attr_t* _Nonnull, size_t); +int pthread_attr_setschedparam(pthread_attr_t* _Nonnull, const struct sched_param* _Nonnull); +int pthread_attr_setschedpolicy(pthread_attr_t* _Nonnull, int); +int pthread_attr_setscope(pthread_attr_t* _Nonnull, int); +int pthread_attr_setstack(pthread_attr_t* _Nonnull, void*, size_t); +int pthread_attr_setstacksize(pthread_attr_t* _Nonnull, size_t); + +int pthread_condattr_destroy(pthread_condattr_t* _Nonnull); + +#if __ANDROID_API__ >= 21 +int pthread_condattr_getclock(const pthread_condattr_t* _Nonnull, clockid_t* _Nonnull) + __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int pthread_condattr_getpshared(const pthread_condattr_t* _Nonnull, int* _Nonnull); +int pthread_condattr_init(pthread_condattr_t* _Nonnull); + +#if __ANDROID_API__ >= 21 +int pthread_condattr_setclock(pthread_condattr_t* _Nonnull, clockid_t) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int pthread_condattr_setpshared(pthread_condattr_t* _Nonnull, int); + +int pthread_cond_broadcast(pthread_cond_t* _Nonnull); +int pthread_cond_destroy(pthread_cond_t* _Nonnull); +int pthread_cond_init(pthread_cond_t* _Nonnull, const pthread_condattr_t*); +int pthread_cond_signal(pthread_cond_t* _Nonnull); +int pthread_cond_timedwait(pthread_cond_t* _Nonnull, pthread_mutex_t* _Nonnull, + const struct timespec* _Nonnull); +int pthread_cond_wait(pthread_cond_t* _Nonnull, pthread_mutex_t* _Nonnull); + +int pthread_create(pthread_t* _Nonnull, pthread_attr_t const*, + void* (* _Nonnull start_routine)(void*), void*); +int pthread_detach(pthread_t); +void pthread_exit(void*) __noreturn; + +int pthread_equal(pthread_t, pthread_t); + +int pthread_getattr_np(pthread_t, pthread_attr_t* _Nonnull); + +int pthread_getcpuclockid(pthread_t, clockid_t* _Nonnull); + +int pthread_getschedparam(pthread_t, int* _Nonnull, struct sched_param* _Nonnull); + +void* pthread_getspecific(pthread_key_t); + + +#if __ANDROID_API__ >= 21 +pid_t pthread_gettid_np(pthread_t) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +int pthread_join(pthread_t, void**); + +int pthread_key_create(pthread_key_t* _Nonnull, void (*)(void*)); +int pthread_key_delete(pthread_key_t); + +int pthread_mutexattr_destroy(pthread_mutexattr_t* _Nonnull); +int pthread_mutexattr_getpshared(const pthread_mutexattr_t* _Nonnull, int* _Nonnull); +int pthread_mutexattr_gettype(const pthread_mutexattr_t* _Nonnull, int* _Nonnull); +int pthread_mutexattr_init(pthread_mutexattr_t* _Nonnull); +int pthread_mutexattr_setpshared(pthread_mutexattr_t* _Nonnull, int); +int pthread_mutexattr_settype(pthread_mutexattr_t* _Nonnull, int); + +int pthread_mutex_destroy(pthread_mutex_t* _Nonnull); +int pthread_mutex_init(pthread_mutex_t* _Nonnull, const pthread_mutexattr_t*); +int pthread_mutex_lock(pthread_mutex_t* _Nonnull); + +#if __ANDROID_API__ >= 21 +int pthread_mutex_timedlock(pthread_mutex_t* _Nonnull, const struct timespec* _Nonnull) + __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int pthread_mutex_trylock(pthread_mutex_t* _Nonnull); +int pthread_mutex_unlock(pthread_mutex_t* _Nonnull); + +int pthread_once(pthread_once_t* _Nonnull, void (* _Nonnull init_routine)(void)); + +int pthread_rwlockattr_init(pthread_rwlockattr_t* _Nonnull); +int pthread_rwlockattr_destroy(pthread_rwlockattr_t* _Nonnull); +int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t* _Nonnull, int* _Nonnull); +int pthread_rwlockattr_setpshared(pthread_rwlockattr_t* _Nonnull, int); + +#if __ANDROID_API__ >= 23 +int pthread_rwlockattr_getkind_np(const pthread_rwlockattr_t* _Nonnull, int* _Nonnull) + __INTRODUCED_IN(23); +int pthread_rwlockattr_setkind_np(pthread_rwlockattr_t* _Nonnull, int) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +int pthread_rwlock_destroy(pthread_rwlock_t* _Nonnull); +int pthread_rwlock_init(pthread_rwlock_t* _Nonnull, const pthread_rwlockattr_t*); +int pthread_rwlock_rdlock(pthread_rwlock_t* _Nonnull); +int pthread_rwlock_timedrdlock(pthread_rwlock_t* _Nonnull, const struct timespec* _Nonnull); +int pthread_rwlock_timedwrlock(pthread_rwlock_t* _Nonnull, const struct timespec* _Nonnull); +int pthread_rwlock_tryrdlock(pthread_rwlock_t* _Nonnull); +int pthread_rwlock_trywrlock(pthread_rwlock_t* _Nonnull); +int pthread_rwlock_unlock(pthread_rwlock_t* _Nonnull); +int pthread_rwlock_wrlock(pthread_rwlock_t* _Nonnull); + + +#if __ANDROID_API__ >= 24 +int pthread_barrierattr_init(pthread_barrierattr_t* _Nonnull attr) __INTRODUCED_IN(24); +int pthread_barrierattr_destroy(pthread_barrierattr_t* _Nonnull attr) __INTRODUCED_IN(24); +int pthread_barrierattr_getpshared(const pthread_barrierattr_t* _Nonnull attr, + int* _Nonnull pshared) __INTRODUCED_IN(24); +int pthread_barrierattr_setpshared(pthread_barrierattr_t* _Nonnull attr, int pshared) + __INTRODUCED_IN(24); + +int pthread_barrier_init(pthread_barrier_t* _Nonnull, const pthread_barrierattr_t*, unsigned) + __INTRODUCED_IN(24); +int pthread_barrier_destroy(pthread_barrier_t* _Nonnull) __INTRODUCED_IN(24); +int pthread_barrier_wait(pthread_barrier_t* _Nonnull) __INTRODUCED_IN(24); + +int pthread_spin_destroy(pthread_spinlock_t* _Nonnull) __INTRODUCED_IN(24); +int pthread_spin_init(pthread_spinlock_t* _Nonnull, int) __INTRODUCED_IN(24); +int pthread_spin_lock(pthread_spinlock_t* _Nonnull) __INTRODUCED_IN(24); +int pthread_spin_trylock(pthread_spinlock_t* _Nonnull) __INTRODUCED_IN(24); +int pthread_spin_unlock(pthread_spinlock_t* _Nonnull) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + + +pthread_t pthread_self(void) __attribute_const__; + +#if defined(__USE_GNU) + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +int pthread_getname_np(pthread_t, char* _Nonnull, size_t) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + +#endif +/* TODO: this should be __USE_GNU too. */ +int pthread_setname_np(pthread_t, const char* _Nonnull); + +int pthread_setschedparam(pthread_t, int, const struct sched_param* _Nonnull); + +int pthread_setspecific(pthread_key_t, const void*); + +typedef void (*__pthread_cleanup_func_t)(void*); + +typedef struct __pthread_cleanup_t { + struct __pthread_cleanup_t* __cleanup_prev; + __pthread_cleanup_func_t __cleanup_routine; + void* __cleanup_arg; +} __pthread_cleanup_t; + +void __pthread_cleanup_push(__pthread_cleanup_t* c, __pthread_cleanup_func_t, void*); +void __pthread_cleanup_pop(__pthread_cleanup_t*, int); + +/* Believe or not, the definitions of pthread_cleanup_push and + * pthread_cleanup_pop below are correct. Posix states that these + * can be implemented as macros that might introduce opening and + * closing braces, and that using setjmp/longjmp/return/break/continue + * between them results in undefined behavior. + */ +#define pthread_cleanup_push(routine, arg) \ + do { \ + __pthread_cleanup_t __cleanup; \ + __pthread_cleanup_push( &__cleanup, (routine), (arg) ); \ + +#define pthread_cleanup_pop(execute) \ + __pthread_cleanup_pop( &__cleanup, (execute)); \ + } while (0); \ + +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + +__END_DECLS + +#endif /* _PTHREAD_H_ */ diff --git a/headers/pty.h b/headers/pty.h new file mode 100644 index 000000000..6142c7c15 --- /dev/null +++ b/headers/pty.h @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _PTY_H +#define _PTY_H + +#include <sys/cdefs.h> + +#include <termios.h> +#include <sys/ioctl.h> + +__BEGIN_DECLS + + +#if __ANDROID_API__ >= 23 +int openpty(int*, int*, char*, const struct termios*, const struct winsize*) __INTRODUCED_IN(23); +int forkpty(int*, char*, const struct termios*, const struct winsize*) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +__END_DECLS + +#endif /* _PTY_H */ diff --git a/headers/pwd.h b/headers/pwd.h new file mode 100644 index 000000000..61c05016c --- /dev/null +++ b/headers/pwd.h @@ -0,0 +1,105 @@ +/*- + * Copyright (c) 1989, 1993 + * The Regents of the University of California. All rights reserved. + * (c) UNIX System Laboratories, Inc. + * All or some portions of this file are derived from material licensed + * to the University of California by American Telephone and Telegraph + * Co. or Unix System Laboratories, Inc. and are reproduced herein with + * the permission of UNIX System Laboratories, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/*- + * Portions Copyright(C) 1995, Jason Downs. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _PWD_H_ +#define _PWD_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +__BEGIN_DECLS + +struct passwd { + char* pw_name; + char* pw_passwd; + uid_t pw_uid; + gid_t pw_gid; +#ifdef __LP64__ + char* pw_gecos; +#else + /* Note: On LP32, we define pw_gecos to pw_passwd since they're both NULL. */ +# define pw_gecos pw_passwd +#endif + char* pw_dir; + char* pw_shell; +}; + +struct passwd* getpwnam(const char*); +struct passwd* getpwuid(uid_t); + +/* Note: Android has thousands and thousands of ids to iterate through */ + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +struct passwd* getpwent(void) __INTRODUCED_IN_FUTURE; + +void setpwent(void) __INTRODUCED_IN_FUTURE; +void endpwent(void) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + + +#if __ANDROID_API__ >= 12 +int getpwnam_r(const char*, struct passwd*, char*, size_t, struct passwd**) __INTRODUCED_IN(12); +int getpwuid_r(uid_t, struct passwd*, char*, size_t, struct passwd**) __INTRODUCED_IN(12); +#endif /* __ANDROID_API__ >= 12 */ + + +__END_DECLS + +#endif diff --git a/headers/regex.h b/headers/regex.h new file mode 100644 index 000000000..b06a515b4 --- /dev/null +++ b/headers/regex.h @@ -0,0 +1,106 @@ +/* $OpenBSD: regex.h,v 1.6 2003/06/02 19:34:12 millert Exp $ */ +/* $NetBSD: regex.h,v 1.4.6.1 1996/06/10 18:57:07 explorer Exp $ */ + +/*- + * Copyright (c) 1992 Henry Spencer. + * Copyright (c) 1992, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Henry Spencer of the University of Toronto. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)regex.h 8.1 (Berkeley) 6/2/93 + */ + +#ifndef _REGEX_H_ +#define _REGEX_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +/* POSIX says regoff_t is at least as large as the larger of ptrdiff_t and + * ssize_t. BSD uses off_t, but that interacts badly with _FILE_OFFSET_BITS. */ +typedef ssize_t regoff_t; + +typedef struct { + int re_magic; + size_t re_nsub; /* number of parenthesized subexpressions */ + const char *re_endp; /* end pointer for REG_PEND */ + struct re_guts *re_g; /* none of your business :-) */ +} regex_t; + +typedef struct { + regoff_t rm_so; /* start of match */ + regoff_t rm_eo; /* end of match */ +} regmatch_t; + +/* regcomp() flags */ +#define REG_BASIC 0000 +#define REG_EXTENDED 0001 +#define REG_ICASE 0002 +#define REG_NOSUB 0004 +#define REG_NEWLINE 0010 +#define REG_NOSPEC 0020 +#define REG_PEND 0040 +#define REG_DUMP 0200 + +/* regerror() flags */ +#define REG_NOMATCH 1 +#define REG_BADPAT 2 +#define REG_ECOLLATE 3 +#define REG_ECTYPE 4 +#define REG_EESCAPE 5 +#define REG_ESUBREG 6 +#define REG_EBRACK 7 +#define REG_EPAREN 8 +#define REG_EBRACE 9 +#define REG_BADBR 10 +#define REG_ERANGE 11 +#define REG_ESPACE 12 +#define REG_BADRPT 13 +#define REG_EMPTY 14 +#define REG_ASSERT 15 +#define REG_INVARG 16 +#define REG_ATOI 255 /* convert name to number (!) */ +#define REG_ITOA 0400 /* convert number to name (!) */ + +/* regexec() flags */ +#define REG_NOTBOL 00001 +#define REG_NOTEOL 00002 +#define REG_STARTEND 00004 +#define REG_TRACE 00400 /* tracing of execution */ +#define REG_LARGE 01000 /* force large representation */ +#define REG_BACKR 02000 /* force use of backref code */ + +__BEGIN_DECLS +int regcomp(regex_t *, const char *, int); +size_t regerror(int, const regex_t *, char *, size_t); +int regexec(const regex_t *, const char *, size_t, regmatch_t [], int); +void regfree(regex_t *); +__END_DECLS + +#endif /* !_REGEX_H_ */ diff --git a/headers/resolv.h b/headers/resolv.h new file mode 100644 index 000000000..2c1281949 --- /dev/null +++ b/headers/resolv.h @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _RESOLV_H_ +#define _RESOLV_H_ + +#include <sys/param.h> +#include <sys/types.h> +#include <sys/cdefs.h> +#include <sys/socket.h> +#include <stdio.h> +#include <arpa/nameser.h> +#include <netinet/in.h> + +__BEGIN_DECLS + +#define b64_ntop __b64_ntop +int b64_ntop(u_char const*, size_t, char*, size_t); +#define b64_pton __b64_pton +int b64_pton(char const*, u_char*, size_t); + +#define dn_comp __dn_comp +int dn_comp(const char*, u_char*, int, u_char**, u_char**); + +int dn_expand(const u_char*, const u_char*, const u_char*, char*, int); + +#define p_class __p_class +const char* p_class(int); +#define p_type __p_type +const char* p_type(int); + +int res_init(void); +int res_mkquery(int, const char*, int, int, const u_char*, int, const u_char*, u_char*, int); +int res_query(const char*, int, int, u_char*, int); +int res_search(const char*, int, int, u_char*, int); + +__END_DECLS + +#endif /* _RESOLV_H_ */ diff --git a/headers/sched.h b/headers/sched.h new file mode 100644 index 000000000..fe94a7ee6 --- /dev/null +++ b/headers/sched.h @@ -0,0 +1,179 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef _SCHED_H_ +#define _SCHED_H_ + +#include <bits/timespec.h> +#include <linux/sched.h> +#include <sys/cdefs.h> + +__BEGIN_DECLS + +/* This name is used by glibc, but not by the kernel. */ +#define SCHED_OTHER SCHED_NORMAL + +struct sched_param { + int sched_priority; +}; + +int sched_setscheduler(pid_t, int, const struct sched_param*); +int sched_getscheduler(pid_t); +int sched_yield(void); +int sched_get_priority_max(int); +int sched_get_priority_min(int); +int sched_setparam(pid_t, const struct sched_param*); +int sched_getparam(pid_t, struct sched_param*); +int sched_rr_get_interval(pid_t, struct timespec*); + +#if defined(__USE_GNU) + + +#if (defined(__LP64__)) || (defined(__arm__)) || (defined(__mips__) && !defined(__LP64__) && __ANDROID_API__ >= 12) || (defined(__i386__) && __ANDROID_API__ >= 17) +int clone(int (*)(void*), void*, int, void*, ...) __INTRODUCED_IN_ARM(9) + __INTRODUCED_IN_MIPS(12) __INTRODUCED_IN_X86(17); +#endif /* (defined(__LP64__)) || (defined(__arm__)) || (defined(__mips__) && !defined(__LP64__) && __ANDROID_API__ >= 12) || (defined(__i386__) && __ANDROID_API__ >= 17) */ + + +#if __ANDROID_API__ >= 17 +int unshare(int) __INTRODUCED_IN(17); +#endif /* __ANDROID_API__ >= 17 */ + + +#if __ANDROID_API__ >= 12 +int sched_getcpu(void) __INTRODUCED_IN(12); +#endif /* __ANDROID_API__ >= 12 */ + + +#if __ANDROID_API__ >= 21 +int setns(int, int) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +#ifdef __LP64__ +#define CPU_SETSIZE 1024 +#else +#define CPU_SETSIZE 32 +#endif + +#define __CPU_BITTYPE unsigned long int /* mandated by the kernel */ +#define __CPU_BITS (8 * sizeof(__CPU_BITTYPE)) +#define __CPU_ELT(x) ((x) / __CPU_BITS) +#define __CPU_MASK(x) ((__CPU_BITTYPE)1 << ((x) & (__CPU_BITS - 1))) + +typedef struct { + __CPU_BITTYPE __bits[ CPU_SETSIZE / __CPU_BITS ]; +} cpu_set_t; + + +#if __ANDROID_API__ >= 12 +int sched_setaffinity(pid_t pid, size_t setsize, const cpu_set_t* set) __INTRODUCED_IN(12); +int sched_getaffinity(pid_t pid, size_t setsize, cpu_set_t* set) __INTRODUCED_IN(12); +#endif /* __ANDROID_API__ >= 12 */ + + +#define CPU_ZERO(set) CPU_ZERO_S(sizeof(cpu_set_t), set) +#define CPU_SET(cpu, set) CPU_SET_S(cpu, sizeof(cpu_set_t), set) +#define CPU_CLR(cpu, set) CPU_CLR_S(cpu, sizeof(cpu_set_t), set) +#define CPU_ISSET(cpu, set) CPU_ISSET_S(cpu, sizeof(cpu_set_t), set) +#define CPU_COUNT(set) CPU_COUNT_S(sizeof(cpu_set_t), set) +#define CPU_EQUAL(set1, set2) CPU_EQUAL_S(sizeof(cpu_set_t), set1, set2) + +#define CPU_AND(dst, set1, set2) __CPU_OP(dst, set1, set2, &) +#define CPU_OR(dst, set1, set2) __CPU_OP(dst, set1, set2, |) +#define CPU_XOR(dst, set1, set2) __CPU_OP(dst, set1, set2, ^) + +#define __CPU_OP(dst, set1, set2, op) __CPU_OP_S(sizeof(cpu_set_t), dst, set1, set2, op) + +/* Support for dynamically-allocated cpu_set_t */ + +#define CPU_ALLOC_SIZE(count) \ + __CPU_ELT((count) + (__CPU_BITS - 1)) * sizeof(__CPU_BITTYPE) + +#define CPU_ALLOC(count) __sched_cpualloc((count)) +#define CPU_FREE(set) __sched_cpufree((set)) + + +#if __ANDROID_API__ >= 12 +cpu_set_t* __sched_cpualloc(size_t count) __INTRODUCED_IN(12); +void __sched_cpufree(cpu_set_t* set) __INTRODUCED_IN(12); +#endif /* __ANDROID_API__ >= 12 */ + + +#define CPU_ZERO_S(setsize, set) __builtin_memset(set, 0, setsize) + +#define CPU_SET_S(cpu, setsize, set) \ + do { \ + size_t __cpu = (cpu); \ + if (__cpu < 8 * (setsize)) \ + (set)->__bits[__CPU_ELT(__cpu)] |= __CPU_MASK(__cpu); \ + } while (0) + +#define CPU_CLR_S(cpu, setsize, set) \ + do { \ + size_t __cpu = (cpu); \ + if (__cpu < 8 * (setsize)) \ + (set)->__bits[__CPU_ELT(__cpu)] &= ~__CPU_MASK(__cpu); \ + } while (0) + +#define CPU_ISSET_S(cpu, setsize, set) \ + (__extension__ ({ \ + size_t __cpu = (cpu); \ + (__cpu < 8 * (setsize)) \ + ? ((set)->__bits[__CPU_ELT(__cpu)] & __CPU_MASK(__cpu)) != 0 \ + : 0; \ + })) + +#define CPU_EQUAL_S(setsize, set1, set2) (__builtin_memcmp(set1, set2, setsize) == 0) + +#define CPU_AND_S(setsize, dst, set1, set2) __CPU_OP_S(setsize, dst, set1, set2, &) +#define CPU_OR_S(setsize, dst, set1, set2) __CPU_OP_S(setsize, dst, set1, set2, |) +#define CPU_XOR_S(setsize, dst, set1, set2) __CPU_OP_S(setsize, dst, set1, set2, ^) + +#define __CPU_OP_S(setsize, dstset, srcset1, srcset2, op) \ + do { \ + cpu_set_t* __dst = (dstset); \ + const __CPU_BITTYPE* __src1 = (srcset1)->__bits; \ + const __CPU_BITTYPE* __src2 = (srcset2)->__bits; \ + size_t __nn = 0, __nn_max = (setsize)/sizeof(__CPU_BITTYPE); \ + for (; __nn < __nn_max; __nn++) \ + (__dst)->__bits[__nn] = __src1[__nn] op __src2[__nn]; \ + } while (0) + +#define CPU_COUNT_S(setsize, set) __sched_cpucount((setsize), (set)) + + +#if __ANDROID_API__ >= 12 +int __sched_cpucount(size_t setsize, cpu_set_t* set) __INTRODUCED_IN(12); +#endif /* __ANDROID_API__ >= 12 */ + + +#endif /* __USE_GNU */ + +__END_DECLS + +#endif /* _SCHED_H_ */ diff --git a/headers/search.h b/headers/search.h new file mode 100644 index 000000000..985e2c46d --- /dev/null +++ b/headers/search.h @@ -0,0 +1,61 @@ +/*- + * Written by J.T. Conklin <jtc@netbsd.org> + * Public domain. + * + * $NetBSD: search.h,v 1.12 1999/02/22 10:34:28 christos Exp $ + * $FreeBSD: release/9.0.0/include/search.h 105250 2002-10-16 14:29:23Z robert $ + */ + +#ifndef _SEARCH_H_ +#define _SEARCH_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +typedef enum { + preorder, + postorder, + endorder, + leaf +} VISIT; + +#ifdef _SEARCH_PRIVATE +typedef struct node { + char* key; + struct node* llink; + struct node* rlink; +} node_t; +#endif + +__BEGIN_DECLS + + +#if __ANDROID_API__ >= 21 +void insque(void*, void*) __INTRODUCED_IN(21); +void remque(void*) __INTRODUCED_IN(21); + +void* lfind(const void*, const void*, size_t*, size_t, int (*)(const void*, const void*)) + __INTRODUCED_IN(21); +void* lsearch(const void*, void*, size_t*, size_t, int (*)(const void*, const void*)) + __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + + +#if __ANDROID_API__ >= 16 +void* tdelete(const void* __restrict, void** __restrict, int (*)(const void*, const void*)) + __INTRODUCED_IN(16); +void tdestroy(void*, void (*)(void*)) __INTRODUCED_IN(16); +void* tfind(const void*, void* const*, int (*)(const void*, const void*)) __INTRODUCED_IN(16); +void* tsearch(const void*, void**, int (*)(const void*, const void*)) __INTRODUCED_IN(16); +#endif /* __ANDROID_API__ >= 16 */ + + +#if __ANDROID_API__ >= 21 +void twalk(const void*, void (*)(const void*, VISIT, int)) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +__END_DECLS + +#endif /* !_SEARCH_H_ */ diff --git a/headers/semaphore.h b/headers/semaphore.h new file mode 100644 index 000000000..218f22a39 --- /dev/null +++ b/headers/semaphore.h @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SEMAPHORE_H +#define _SEMAPHORE_H + +#include <sys/cdefs.h> + +__BEGIN_DECLS + +struct timespec; + +typedef struct { + unsigned int count; +#ifdef __LP64__ + int __reserved[3]; +#endif +} sem_t; + +#define SEM_FAILED __BIONIC_CAST(reinterpret_cast, sem_t*, 0) + +int sem_destroy(sem_t*); +int sem_getvalue(sem_t*, int*); +int sem_init(sem_t*, int, unsigned int); +int sem_post(sem_t*); +int sem_timedwait(sem_t*, const struct timespec*); +int sem_trywait(sem_t*); +int sem_wait(sem_t*); + +/* These aren't actually implemented. */ +sem_t* sem_open(const char*, int, ...); +int sem_close(sem_t*); +int sem_unlink(const char*); + +__END_DECLS + +#endif /* _SEMAPHORE_H */ diff --git a/headers/setjmp.h b/headers/setjmp.h new file mode 100644 index 000000000..7e38e1c96 --- /dev/null +++ b/headers/setjmp.h @@ -0,0 +1,68 @@ +/* $OpenBSD: setjmp.h,v 1.5 2005/12/13 00:35:22 millert Exp $ */ +/* $NetBSD: setjmp.h,v 1.11 1994/12/20 10:35:44 cgd Exp $ */ + +/*- + * Copyright (c) 1990, 1993 + * The Regents of the University of California. All rights reserved. + * (c) UNIX System Laboratories, Inc. + * All or some portions of this file are derived from material licensed + * to the University of California by American Telephone and Telegraph + * Co. or Unix System Laboratories, Inc. and are reproduced herein with + * the permission of UNIX System Laboratories, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)setjmp.h 8.2 (Berkeley) 1/21/94 + */ + +#ifndef _SETJMP_H_ +#define _SETJMP_H_ + +#include <sys/cdefs.h> +#include <machine/setjmp.h> + +typedef long sigjmp_buf[_JBLEN + 1]; +typedef long jmp_buf[_JBLEN]; + +__BEGIN_DECLS + +int _setjmp(jmp_buf); +void _longjmp(jmp_buf, int); + +int setjmp(jmp_buf); +void longjmp(jmp_buf, int); + + +#if (defined(__LP64__)) || (defined(__arm__)) || (defined(__mips__) && !defined(__LP64__) && __ANDROID_API__ >= 12) || (defined(__i386__) && __ANDROID_API__ >= 12) +int sigsetjmp(sigjmp_buf, int) __INTRODUCED_IN_ARM(9) __INTRODUCED_IN_MIPS(12) + __INTRODUCED_IN_X86(12); +void siglongjmp(sigjmp_buf, int) __INTRODUCED_IN_ARM(9) __INTRODUCED_IN_MIPS(12) + __INTRODUCED_IN_X86(12); +#endif /* (defined(__LP64__)) || (defined(__arm__)) || (defined(__mips__) && !defined(__LP64__) && __ANDROID_API__ >= 12) || (defined(__i386__) && __ANDROID_API__ >= 12) */ + + +__END_DECLS + +#endif /* !_SETJMP_H_ */ diff --git a/headers/signal.h b/headers/signal.h new file mode 100644 index 000000000..be65211c7 --- /dev/null +++ b/headers/signal.h @@ -0,0 +1,195 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SIGNAL_H_ +#define _SIGNAL_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +#include <asm/sigcontext.h> +#include <bits/pthread_types.h> +#include <bits/timespec.h> +#include <limits.h> + +#if defined(__LP64__) || defined(__mips__) +/* For 64-bit (and mips), the kernel's struct sigaction doesn't match the POSIX one, + * so we need to expose our own and translate behind the scenes. */ +# define sigaction __kernel_sigaction +# include <linux/signal.h> +# undef sigaction +#else +/* For 32-bit, we're stuck with the definitions we already shipped, + * even though they contain a sigset_t that's too small. */ +# include <linux/signal.h> +#endif + +#include <sys/ucontext.h> +#define __BIONIC_HAVE_UCONTEXT_T + +__BEGIN_DECLS + +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wnullability-completeness" +#endif + +typedef int sig_atomic_t; + +/* The arm and x86 kernel header files don't define _NSIG. */ +#ifndef _KERNEL__NSIG +#define _KERNEL__NSIG 64 +#endif + +/* Userspace's NSIG is the kernel's _NSIG + 1. */ +#define _NSIG (_KERNEL__NSIG + 1) +#define NSIG _NSIG + +/* The kernel headers define SIG_DFL (0) and SIG_IGN (1) but not SIG_HOLD, since + * SIG_HOLD is only used by the deprecated SysV signal API. + */ +#define SIG_HOLD __BIONIC_CAST(reinterpret_cast, sighandler_t, 2) + +/* We take a few real-time signals for ourselves. May as well use the same names as glibc. */ +#define SIGRTMIN (__libc_current_sigrtmin()) +#define SIGRTMAX (__libc_current_sigrtmax()) + +#if __ANDROID_API__ >= 21 +int __libc_current_sigrtmin(void) __INTRODUCED_IN(21); +int __libc_current_sigrtmax(void) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +extern const char* const sys_siglist[_NSIG]; +extern const char* const sys_signame[_NSIG]; /* BSD compatibility. */ + +typedef __sighandler_t sig_t; /* BSD compatibility. */ +typedef __sighandler_t sighandler_t; /* glibc compatibility. */ + +#define si_timerid si_tid /* glibc compatibility. */ + +#if defined(__LP64__) + +struct sigaction { + unsigned int sa_flags; + union { + sighandler_t sa_handler; + void (*sa_sigaction)(int, struct siginfo*, void*); + }; + sigset_t sa_mask; + void (*sa_restorer)(void); +}; + +#elif defined(__mips__) + +struct sigaction { + unsigned int sa_flags; + union { + sighandler_t sa_handler; + void (*sa_sigaction) (int, struct siginfo*, void*); + }; + sigset_t sa_mask; +}; + +#endif + +int sigaction(int, const struct sigaction*, struct sigaction*); + +int siginterrupt(int, int); + +#if __ANDROID_API__ >= __ANDROID_API_L__ +sighandler_t signal(int, sighandler_t) __INTRODUCED_IN(21); +int sigaddset(sigset_t*, int) __INTRODUCED_IN(21); +int sigdelset(sigset_t*, int) __INTRODUCED_IN(21); +int sigemptyset(sigset_t*) __INTRODUCED_IN(21); +int sigfillset(sigset_t*) __INTRODUCED_IN(21); +int sigismember(const sigset_t*, int) __INTRODUCED_IN(21); +#else +// Implemented as static inlines before 21. +#endif + +int sigpending(sigset_t* _Nonnull); +int sigprocmask(int, const sigset_t*, sigset_t*); +int sigsuspend(const sigset_t* _Nonnull); +int sigwait(const sigset_t* _Nonnull, int* _Nonnull); + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +int sighold(int) + __attribute__((deprecated("use sigprocmask() or pthread_sigmask() instead"))) + __INTRODUCED_IN_FUTURE; +int sigignore(int) + __attribute__((deprecated("use sigaction() instead"))) __INTRODUCED_IN_FUTURE; +int sigpause(int) + __attribute__((deprecated("use sigsuspend() instead"))) __INTRODUCED_IN_FUTURE; +int sigrelse(int) + __attribute__((deprecated("use sigprocmask() or pthread_sigmask() instead"))) + __INTRODUCED_IN_FUTURE; +sighandler_t sigset(int, sighandler_t) + __attribute__((deprecated("use sigaction() instead"))) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + +int raise(int); +int kill(pid_t, int); +int killpg(int, int); + +#if (!defined(__LP64__) && __ANDROID_API__ >= 16) || (defined(__LP64__)) +int tgkill(int tgid, int tid, int sig) __INTRODUCED_IN_32(16); +#endif /* (!defined(__LP64__) && __ANDROID_API__ >= 16) || (defined(__LP64__)) */ + + +int sigaltstack(const stack_t*, stack_t*); + + +#if __ANDROID_API__ >= 17 +void psiginfo(const siginfo_t*, const char*) __INTRODUCED_IN(17); +void psignal(int, const char*) __INTRODUCED_IN(17); +#endif /* __ANDROID_API__ >= 17 */ + + +int pthread_kill(pthread_t, int); +int pthread_sigmask(int, const sigset_t*, sigset_t*); + + +#if __ANDROID_API__ >= 23 +int sigqueue(pid_t, int, const union sigval) __INTRODUCED_IN(23); +int sigtimedwait(const sigset_t* _Nonnull, siginfo_t*, const struct timespec*) __INTRODUCED_IN(23); +int sigwaitinfo(const sigset_t* _Nonnull, siginfo_t*) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + +__END_DECLS + +#include <android/legacy_signal_inlines.h> + +#endif /* _SIGNAL_H_ */ diff --git a/headers/stdatomic.h b/headers/stdatomic.h new file mode 100644 index 000000000..8d573b263 --- /dev/null +++ b/headers/stdatomic.h @@ -0,0 +1,546 @@ +/*- + * Copyright (c) 2011 Ed Schouten <ed@FreeBSD.org> + * David Chisnall <theraven@FreeBSD.org> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +#ifndef _STDATOMIC_H_ +#define _STDATOMIC_H_ + +#include <sys/cdefs.h> + +#if defined(__cplusplus) && __cplusplus >= 201103L && defined(_USING_LIBCXX) +# ifdef __clang__ +# if __has_feature(cxx_atomic) +# define _STDATOMIC_HAVE_ATOMIC +# endif +# else /* gcc */ +# define _STDATOMIC_HAVE_ATOMIC +# endif +#endif + +#ifdef _STDATOMIC_HAVE_ATOMIC + +/* We have a usable C++ <atomic>; use it instead. */ + +#include <atomic> + +#undef _Atomic + /* Also defined by <atomic> for gcc. But not used in macros. */ + /* Also a clang intrinsic. */ + /* Should not be used by client code before this file is */ + /* included. The definitions in <atomic> themselves see */ + /* the old definition, as they should. */ + /* Client code sees the following definition. */ + +#define _Atomic(t) std::atomic<t> + +using std::atomic_is_lock_free; +using std::atomic_init; +using std::atomic_store; +using std::atomic_store_explicit; +using std::atomic_load; +using std::atomic_load_explicit; +using std::atomic_exchange; +using std::atomic_exchange_explicit; +using std::atomic_compare_exchange_strong; +using std::atomic_compare_exchange_strong_explicit; +using std::atomic_compare_exchange_weak; +using std::atomic_compare_exchange_weak_explicit; +using std::atomic_fetch_add; +using std::atomic_fetch_add_explicit; +using std::atomic_fetch_sub; +using std::atomic_fetch_sub_explicit; +using std::atomic_fetch_or; +using std::atomic_fetch_or_explicit; +using std::atomic_fetch_xor; +using std::atomic_fetch_xor_explicit; +using std::atomic_fetch_and; +using std::atomic_fetch_and_explicit; +using std::atomic_thread_fence; +using std::atomic_signal_fence; + +using std::memory_order; +using std::memory_order_relaxed; +using std::memory_order_consume; +using std::memory_order_acquire; +using std::memory_order_release; +using std::memory_order_acq_rel; +using std::memory_order_seq_cst; + +using std::atomic_bool; +using std::atomic_char; +using std::atomic_schar; +using std::atomic_uchar; +using std::atomic_short; +using std::atomic_ushort; +using std::atomic_int; +using std::atomic_uint; +using std::atomic_long; +using std::atomic_ulong; +using std::atomic_llong; +using std::atomic_ullong; +using std::atomic_char16_t; +using std::atomic_char32_t; +using std::atomic_wchar_t; +using std::atomic_int_least8_t; +using std::atomic_uint_least8_t; +using std::atomic_int_least16_t; +using std::atomic_uint_least16_t; +using std::atomic_int_least32_t; +using std::atomic_uint_least32_t; +using std::atomic_int_least64_t; +using std::atomic_uint_least64_t; +using std::atomic_int_fast8_t; +using std::atomic_uint_fast8_t; +using std::atomic_int_fast16_t; +using std::atomic_uint_fast16_t; +using std::atomic_int_fast32_t; +using std::atomic_uint_fast32_t; +using std::atomic_int_fast64_t; +using std::atomic_uint_fast64_t; +using std::atomic_intptr_t; +using std::atomic_uintptr_t; +using std::atomic_size_t; +using std::atomic_ptrdiff_t; +using std::atomic_intmax_t; +using std::atomic_uintmax_t; + +#else /* <atomic> unavailable, possibly because this is C, not C++ */ + +#include <sys/types.h> +#include <stdbool.h> + +/* + * C: Do it ourselves. + * Note that the runtime representation defined here should be compatible + * with the C++ one, i.e. an _Atomic(T) needs to contain the same + * bits as a T. + */ + +#include <stddef.h> /* For ptrdiff_t. */ +#include <stdint.h> /* TODO: don't drag in all the macros, just the types. */ +// Include uchar.h only when needed. Bionic's stdatomic.h is also used for the +// host (via a copy in prebuilts/clang) and uchar.h is not available in the +// glibc used for the host. +#if __STDC_VERSION__ >= 201112L +# include <uchar.h> /* For char16_t and char32_t. */ +#endif + + +#ifdef __clang__ +# if __has_extension(c_atomic) || __has_extension(cxx_atomic) +# define __CLANG_ATOMICS +# else +# error "stdatomic.h does not support your compiler" +# endif +# if __has_builtin(__sync_swap) +# define __HAS_BUILTIN_SYNC_SWAP +# endif +#else +# define __GNUC_ATOMICS +#endif + +/* + * 7.17.1 Atomic lock-free macros. + */ + +#ifdef __GCC_ATOMIC_BOOL_LOCK_FREE +#define ATOMIC_BOOL_LOCK_FREE __GCC_ATOMIC_BOOL_LOCK_FREE +#endif +#ifdef __GCC_ATOMIC_CHAR_LOCK_FREE +#define ATOMIC_CHAR_LOCK_FREE __GCC_ATOMIC_CHAR_LOCK_FREE +#endif +#ifdef __GCC_ATOMIC_CHAR16_T_LOCK_FREE +#define ATOMIC_CHAR16_T_LOCK_FREE __GCC_ATOMIC_CHAR16_T_LOCK_FREE +#endif +#ifdef __GCC_ATOMIC_CHAR32_T_LOCK_FREE +#define ATOMIC_CHAR32_T_LOCK_FREE __GCC_ATOMIC_CHAR32_T_LOCK_FREE +#endif +#ifdef __GCC_ATOMIC_WCHAR_T_LOCK_FREE +#define ATOMIC_WCHAR_T_LOCK_FREE __GCC_ATOMIC_WCHAR_T_LOCK_FREE +#endif +#ifdef __GCC_ATOMIC_SHORT_LOCK_FREE +#define ATOMIC_SHORT_LOCK_FREE __GCC_ATOMIC_SHORT_LOCK_FREE +#endif +#ifdef __GCC_ATOMIC_INT_LOCK_FREE +#define ATOMIC_INT_LOCK_FREE __GCC_ATOMIC_INT_LOCK_FREE +#endif +#ifdef __GCC_ATOMIC_LONG_LOCK_FREE +#define ATOMIC_LONG_LOCK_FREE __GCC_ATOMIC_LONG_LOCK_FREE +#endif +#ifdef __GCC_ATOMIC_LLONG_LOCK_FREE +#define ATOMIC_LLONG_LOCK_FREE __GCC_ATOMIC_LLONG_LOCK_FREE +#endif +#ifdef __GCC_ATOMIC_POINTER_LOCK_FREE +#define ATOMIC_POINTER_LOCK_FREE __GCC_ATOMIC_POINTER_LOCK_FREE +#endif + +/* + * 7.17.2 Initialization. + */ + +#if defined(__CLANG_ATOMICS) +#define ATOMIC_VAR_INIT(value) (value) +#define atomic_init(obj, value) __c11_atomic_init(obj, value) +#else +#define ATOMIC_VAR_INIT(value) { .__val = (value) } +#define atomic_init(obj, value) ((void)((obj)->__val = (value))) +#endif + +/* + * Clang and recent GCC both provide predefined macros for the memory + * orderings. If we are using a compiler that doesn't define them, use the + * clang values - these will be ignored in the fallback path. + */ + +#ifndef __ATOMIC_RELAXED +#define __ATOMIC_RELAXED 0 +#endif +#ifndef __ATOMIC_CONSUME +#define __ATOMIC_CONSUME 1 +#endif +#ifndef __ATOMIC_ACQUIRE +#define __ATOMIC_ACQUIRE 2 +#endif +#ifndef __ATOMIC_RELEASE +#define __ATOMIC_RELEASE 3 +#endif +#ifndef __ATOMIC_ACQ_REL +#define __ATOMIC_ACQ_REL 4 +#endif +#ifndef __ATOMIC_SEQ_CST +#define __ATOMIC_SEQ_CST 5 +#endif + +/* + * 7.17.3 Order and consistency. + * + * The memory_order_* constants that denote the barrier behaviour of the + * atomic operations. + * The enum values must be identical to those used by the + * C++ <atomic> header. + */ + +typedef enum { + memory_order_relaxed = __ATOMIC_RELAXED, + memory_order_consume = __ATOMIC_CONSUME, + memory_order_acquire = __ATOMIC_ACQUIRE, + memory_order_release = __ATOMIC_RELEASE, + memory_order_acq_rel = __ATOMIC_ACQ_REL, + memory_order_seq_cst = __ATOMIC_SEQ_CST +} memory_order; + +/* + * 7.17.4 Fences. + */ + +static __inline void +atomic_thread_fence(memory_order __order __attribute__((unused))) +{ + +#ifdef __CLANG_ATOMICS + __c11_atomic_thread_fence(__order); +#elif defined(__GNUC_ATOMICS) + __atomic_thread_fence(__order); +#else + __sync_synchronize(); +#endif +} + +static __inline void +atomic_signal_fence(memory_order __order __attribute__((unused))) +{ + +#ifdef __CLANG_ATOMICS + __c11_atomic_signal_fence(__order); +#elif defined(__GNUC_ATOMICS) + __atomic_signal_fence(__order); +#else + __asm volatile ("" ::: "memory"); +#endif +} + +/* + * 7.17.5 Lock-free property. + */ + +#if defined(_KERNEL) +/* Atomics in kernelspace are always lock-free. */ +#define atomic_is_lock_free(obj) \ + ((void)(obj), (_Bool)1) +#elif defined(__CLANG_ATOMICS) +#define atomic_is_lock_free(obj) \ + __c11_atomic_is_lock_free(sizeof(*(obj))) +#elif defined(__GNUC_ATOMICS) +#define atomic_is_lock_free(obj) \ + __atomic_is_lock_free(sizeof((obj)->__val), &(obj)->__val) +#else +#define atomic_is_lock_free(obj) \ + ((void)(obj), sizeof((obj)->__val) <= sizeof(void *)) +#endif + +/* + * 7.17.6 Atomic integer types. + */ + +#ifndef __CLANG_ATOMICS +/* + * No native support for _Atomic(). Place object in structure to prevent + * most forms of direct non-atomic access. + */ +#define _Atomic(T) struct { T volatile __val; } +#endif + +typedef _Atomic(bool) atomic_bool; +typedef _Atomic(char) atomic_char; +typedef _Atomic(signed char) atomic_schar; +typedef _Atomic(unsigned char) atomic_uchar; +typedef _Atomic(short) atomic_short; +typedef _Atomic(unsigned short) atomic_ushort; +typedef _Atomic(int) atomic_int; +typedef _Atomic(unsigned int) atomic_uint; +typedef _Atomic(long) atomic_long; +typedef _Atomic(unsigned long) atomic_ulong; +typedef _Atomic(long long) atomic_llong; +typedef _Atomic(unsigned long long) atomic_ullong; +#if __STDC_VERSION__ >= 201112L || __cplusplus >= 201103L + typedef _Atomic(char16_t) atomic_char16_t; + typedef _Atomic(char32_t) atomic_char32_t; +#endif +typedef _Atomic(wchar_t) atomic_wchar_t; +typedef _Atomic(int_least8_t) atomic_int_least8_t; +typedef _Atomic(uint_least8_t) atomic_uint_least8_t; +typedef _Atomic(int_least16_t) atomic_int_least16_t; +typedef _Atomic(uint_least16_t) atomic_uint_least16_t; +typedef _Atomic(int_least32_t) atomic_int_least32_t; +typedef _Atomic(uint_least32_t) atomic_uint_least32_t; +typedef _Atomic(int_least64_t) atomic_int_least64_t; +typedef _Atomic(uint_least64_t) atomic_uint_least64_t; +typedef _Atomic(int_fast8_t) atomic_int_fast8_t; +typedef _Atomic(uint_fast8_t) atomic_uint_fast8_t; +typedef _Atomic(int_fast16_t) atomic_int_fast16_t; +typedef _Atomic(uint_fast16_t) atomic_uint_fast16_t; +typedef _Atomic(int_fast32_t) atomic_int_fast32_t; +typedef _Atomic(uint_fast32_t) atomic_uint_fast32_t; +typedef _Atomic(int_fast64_t) atomic_int_fast64_t; +typedef _Atomic(uint_fast64_t) atomic_uint_fast64_t; +typedef _Atomic(intptr_t) atomic_intptr_t; +typedef _Atomic(uintptr_t) atomic_uintptr_t; +typedef _Atomic(size_t) atomic_size_t; +typedef _Atomic(ptrdiff_t) atomic_ptrdiff_t; +typedef _Atomic(intmax_t) atomic_intmax_t; +typedef _Atomic(uintmax_t) atomic_uintmax_t; + +/* + * 7.17.7 Operations on atomic types. + */ + +/* + * Compiler-specific operations. + */ + +#if defined(__CLANG_ATOMICS) +#define atomic_compare_exchange_strong_explicit(object, expected, \ + desired, success, failure) \ + __c11_atomic_compare_exchange_strong(object, expected, desired, \ + success, failure) +#define atomic_compare_exchange_weak_explicit(object, expected, \ + desired, success, failure) \ + __c11_atomic_compare_exchange_weak(object, expected, desired, \ + success, failure) +#define atomic_exchange_explicit(object, desired, order) \ + __c11_atomic_exchange(object, desired, order) +#define atomic_fetch_add_explicit(object, operand, order) \ + __c11_atomic_fetch_add(object, operand, order) +#define atomic_fetch_and_explicit(object, operand, order) \ + __c11_atomic_fetch_and(object, operand, order) +#define atomic_fetch_or_explicit(object, operand, order) \ + __c11_atomic_fetch_or(object, operand, order) +#define atomic_fetch_sub_explicit(object, operand, order) \ + __c11_atomic_fetch_sub(object, operand, order) +#define atomic_fetch_xor_explicit(object, operand, order) \ + __c11_atomic_fetch_xor(object, operand, order) +#define atomic_load_explicit(object, order) \ + __c11_atomic_load(object, order) +#define atomic_store_explicit(object, desired, order) \ + __c11_atomic_store(object, desired, order) +#elif defined(__GNUC_ATOMICS) +#define atomic_compare_exchange_strong_explicit(object, expected, \ + desired, success, failure) \ + __atomic_compare_exchange_n(&(object)->__val, expected, \ + desired, 0, success, failure) +#define atomic_compare_exchange_weak_explicit(object, expected, \ + desired, success, failure) \ + __atomic_compare_exchange_n(&(object)->__val, expected, \ + desired, 1, success, failure) +#define atomic_exchange_explicit(object, desired, order) \ + __atomic_exchange_n(&(object)->__val, desired, order) +#define atomic_fetch_add_explicit(object, operand, order) \ + __atomic_fetch_add(&(object)->__val, operand, order) +#define atomic_fetch_and_explicit(object, operand, order) \ + __atomic_fetch_and(&(object)->__val, operand, order) +#define atomic_fetch_or_explicit(object, operand, order) \ + __atomic_fetch_or(&(object)->__val, operand, order) +#define atomic_fetch_sub_explicit(object, operand, order) \ + __atomic_fetch_sub(&(object)->__val, operand, order) +#define atomic_fetch_xor_explicit(object, operand, order) \ + __atomic_fetch_xor(&(object)->__val, operand, order) +#define atomic_load_explicit(object, order) \ + __atomic_load_n(&(object)->__val, order) +#define atomic_store_explicit(object, desired, order) \ + __atomic_store_n(&(object)->__val, desired, order) +#else +#define __atomic_apply_stride(object, operand) \ + (((__typeof__((object)->__val))0) + (operand)) +#define atomic_compare_exchange_strong_explicit(object, expected, \ + desired, success, failure) __extension__ ({ \ + __typeof__(expected) __ep = (expected); \ + __typeof__(*__ep) __e = *__ep; \ + (void)(success); (void)(failure); \ + (bool)((*__ep = __sync_val_compare_and_swap(&(object)->__val, \ + __e, desired)) == __e); \ +}) +#define atomic_compare_exchange_weak_explicit(object, expected, \ + desired, success, failure) \ + atomic_compare_exchange_strong_explicit(object, expected, \ + desired, success, failure) +#ifdef __HAS_BUILTIN_SYNC_SWAP +/* Clang provides a full-barrier atomic exchange - use it if available. */ +#define atomic_exchange_explicit(object, desired, order) \ + ((void)(order), __sync_swap(&(object)->__val, desired)) +#else +/* + * __sync_lock_test_and_set() is only an acquire barrier in theory (although in + * practice it is usually a full barrier) so we need an explicit barrier before + * it. + */ +#define atomic_exchange_explicit(object, desired, order) \ +__extension__ ({ \ + __typeof__(object) __o = (object); \ + __typeof__(desired) __d = (desired); \ + (void)(order); \ + __sync_synchronize(); \ + __sync_lock_test_and_set(&(__o)->__val, __d); \ +}) +#endif +#define atomic_fetch_add_explicit(object, operand, order) \ + ((void)(order), __sync_fetch_and_add(&(object)->__val, \ + __atomic_apply_stride(object, operand))) +#define atomic_fetch_and_explicit(object, operand, order) \ + ((void)(order), __sync_fetch_and_and(&(object)->__val, operand)) +#define atomic_fetch_or_explicit(object, operand, order) \ + ((void)(order), __sync_fetch_and_or(&(object)->__val, operand)) +#define atomic_fetch_sub_explicit(object, operand, order) \ + ((void)(order), __sync_fetch_and_sub(&(object)->__val, \ + __atomic_apply_stride(object, operand))) +#define atomic_fetch_xor_explicit(object, operand, order) \ + ((void)(order), __sync_fetch_and_xor(&(object)->__val, operand)) +#define atomic_load_explicit(object, order) \ + ((void)(order), __sync_fetch_and_add(&(object)->__val, 0)) +#define atomic_store_explicit(object, desired, order) \ + ((void)atomic_exchange_explicit(object, desired, order)) +#endif + +/* + * Convenience functions. + * + * Don't provide these in kernel space. In kernel space, we should be + * disciplined enough to always provide explicit barriers. + */ + +#ifndef _KERNEL +#define atomic_compare_exchange_strong(object, expected, desired) \ + atomic_compare_exchange_strong_explicit(object, expected, \ + desired, memory_order_seq_cst, memory_order_seq_cst) +#define atomic_compare_exchange_weak(object, expected, desired) \ + atomic_compare_exchange_weak_explicit(object, expected, \ + desired, memory_order_seq_cst, memory_order_seq_cst) +#define atomic_exchange(object, desired) \ + atomic_exchange_explicit(object, desired, memory_order_seq_cst) +#define atomic_fetch_add(object, operand) \ + atomic_fetch_add_explicit(object, operand, memory_order_seq_cst) +#define atomic_fetch_and(object, operand) \ + atomic_fetch_and_explicit(object, operand, memory_order_seq_cst) +#define atomic_fetch_or(object, operand) \ + atomic_fetch_or_explicit(object, operand, memory_order_seq_cst) +#define atomic_fetch_sub(object, operand) \ + atomic_fetch_sub_explicit(object, operand, memory_order_seq_cst) +#define atomic_fetch_xor(object, operand) \ + atomic_fetch_xor_explicit(object, operand, memory_order_seq_cst) +#define atomic_load(object) \ + atomic_load_explicit(object, memory_order_seq_cst) +#define atomic_store(object, desired) \ + atomic_store_explicit(object, desired, memory_order_seq_cst) +#endif /* !_KERNEL */ + +/* + * 7.17.8 Atomic flag type and operations. + * + * XXX: Assume atomic_bool can be used as an atomic_flag. Is there some + * kind of compiler built-in type we could use? + */ + +typedef struct { + atomic_bool __flag; +} atomic_flag; + +#define ATOMIC_FLAG_INIT { ATOMIC_VAR_INIT(false) } + +static __inline bool +atomic_flag_test_and_set_explicit(volatile atomic_flag *__object, + memory_order __order) +{ + return (atomic_exchange_explicit(&__object->__flag, 1, __order)); +} + +static __inline void +atomic_flag_clear_explicit(volatile atomic_flag *__object, memory_order __order) +{ + + atomic_store_explicit(&__object->__flag, 0, __order); +} + +#ifndef _KERNEL +static __inline bool +atomic_flag_test_and_set(volatile atomic_flag *__object) +{ + + return (atomic_flag_test_and_set_explicit(__object, + memory_order_seq_cst)); +} + +static __inline void +atomic_flag_clear(volatile atomic_flag *__object) +{ + + atomic_flag_clear_explicit(__object, memory_order_seq_cst); +} +#endif /* !_KERNEL */ + +#endif /* <atomic> unavailable */ + +#endif /* !_STDATOMIC_H_ */ diff --git a/headers/stdint.h b/headers/stdint.h new file mode 100644 index 000000000..322a81ce1 --- /dev/null +++ b/headers/stdint.h @@ -0,0 +1,229 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _STDINT_H +#define _STDINT_H + +#include <bits/wchar_limits.h> +#include <stddef.h> +#include <sys/cdefs.h> + +typedef signed char __int8_t; +typedef unsigned char __uint8_t; +typedef short __int16_t; +typedef unsigned short __uint16_t; +typedef int __int32_t; +typedef unsigned int __uint32_t; +#if defined(__LP64__) +typedef long __int64_t; +typedef unsigned long __uint64_t; +#else +typedef long long __int64_t; +typedef unsigned long long __uint64_t; +#endif + +#if defined(__LP64__) +typedef long __intptr_t; +typedef unsigned long __uintptr_t; +#else +typedef int __intptr_t; +typedef unsigned int __uintptr_t; +#endif + +typedef __int8_t int8_t; +typedef __uint8_t uint8_t; + +typedef __int16_t int16_t; +typedef __uint16_t uint16_t; + +typedef __int32_t int32_t; +typedef __uint32_t uint32_t; + +typedef __int64_t int64_t; +typedef __uint64_t uint64_t; + +typedef __intptr_t intptr_t; +typedef __uintptr_t uintptr_t; + +typedef int8_t int_least8_t; +typedef uint8_t uint_least8_t; + +typedef int16_t int_least16_t; +typedef uint16_t uint_least16_t; + +typedef int32_t int_least32_t; +typedef uint32_t uint_least32_t; + +typedef int64_t int_least64_t; +typedef uint64_t uint_least64_t; + +typedef int8_t int_fast8_t; +typedef uint8_t uint_fast8_t; + +typedef int64_t int_fast64_t; +typedef uint64_t uint_fast64_t; + +#if defined(__LP64__) +typedef int64_t int_fast16_t; +typedef uint64_t uint_fast16_t; +typedef int64_t int_fast32_t; +typedef uint64_t uint_fast32_t; +#else +typedef int32_t int_fast16_t; +typedef uint32_t uint_fast16_t; +typedef int32_t int_fast32_t; +typedef uint32_t uint_fast32_t; +#endif + +typedef uint64_t uintmax_t; +typedef int64_t intmax_t; + +/* Keep the kernel from trying to define these types... */ +#define __BIT_TYPES_DEFINED__ + +#define INT8_C(c) c +#define INT_LEAST8_C(c) INT8_C(c) +#define INT_FAST8_C(c) INT8_C(c) + +#define UINT8_C(c) c +#define UINT_LEAST8_C(c) UINT8_C(c) +#define UINT_FAST8_C(c) UINT8_C(c) + +#define INT16_C(c) c +#define INT_LEAST16_C(c) INT16_C(c) +#define INT_FAST16_C(c) INT32_C(c) + +#define UINT16_C(c) c +#define UINT_LEAST16_C(c) UINT16_C(c) +#define UINT_FAST16_C(c) UINT32_C(c) +#define INT32_C(c) c +#define INT_LEAST32_C(c) INT32_C(c) +#define INT_FAST32_C(c) INT32_C(c) + +#define UINT32_C(c) c ## U +#define UINT_LEAST32_C(c) UINT32_C(c) +#define UINT_FAST32_C(c) UINT32_C(c) +#define INT_LEAST64_C(c) INT64_C(c) +#define INT_FAST64_C(c) INT64_C(c) + +#define UINT_LEAST64_C(c) UINT64_C(c) +#define UINT_FAST64_C(c) UINT64_C(c) + +#define INTMAX_C(c) INT64_C(c) +#define UINTMAX_C(c) UINT64_C(c) + +#if defined(__LP64__) +# define INT64_C(c) c ## L +# define UINT64_C(c) c ## UL +# define INTPTR_C(c) INT64_C(c) +# define UINTPTR_C(c) UINT64_C(c) +# define PTRDIFF_C(c) INT64_C(c) +#else +# define INT64_C(c) c ## LL +# define UINT64_C(c) c ## ULL +# define INTPTR_C(c) INT32_C(c) +# define UINTPTR_C(c) UINT32_C(c) +# define PTRDIFF_C(c) INT32_C(c) +#endif + +#define INT8_MIN (-128) +#define INT8_MAX (127) +#define INT_LEAST8_MIN INT8_MIN +#define INT_LEAST8_MAX INT8_MAX +#define INT_FAST8_MIN INT8_MIN +#define INT_FAST8_MAX INT8_MAX + +#define UINT8_MAX (255) +#define UINT_LEAST8_MAX UINT8_MAX +#define UINT_FAST8_MAX UINT8_MAX + +#define INT16_MIN (-32768) +#define INT16_MAX (32767) +#define INT_LEAST16_MIN INT16_MIN +#define INT_LEAST16_MAX INT16_MAX +#define INT_FAST16_MIN INT32_MIN +#define INT_FAST16_MAX INT32_MAX + +#define UINT16_MAX (65535) +#define UINT_LEAST16_MAX UINT16_MAX +#define UINT_FAST16_MAX UINT32_MAX + +#define INT32_MIN (-2147483647-1) +#define INT32_MAX (2147483647) +#define INT_LEAST32_MIN INT32_MIN +#define INT_LEAST32_MAX INT32_MAX +#define INT_FAST32_MIN INT32_MIN +#define INT_FAST32_MAX INT32_MAX + +#define UINT32_MAX (4294967295U) +#define UINT_LEAST32_MAX UINT32_MAX +#define UINT_FAST32_MAX UINT32_MAX + +#define INT64_MIN (INT64_C(-9223372036854775807)-1) +#define INT64_MAX (INT64_C(9223372036854775807)) +#define INT_LEAST64_MIN INT64_MIN +#define INT_LEAST64_MAX INT64_MAX +#define INT_FAST64_MIN INT64_MIN +#define INT_FAST64_MAX INT64_MAX +#define UINT64_MAX (UINT64_C(18446744073709551615)) + +#define UINT_LEAST64_MAX UINT64_MAX +#define UINT_FAST64_MAX UINT64_MAX + +#define INTMAX_MIN INT64_MIN +#define INTMAX_MAX INT64_MAX +#define UINTMAX_MAX UINT64_MAX + +#define SIG_ATOMIC_MAX INT32_MAX +#define SIG_ATOMIC_MIN INT32_MIN + +#if defined(__WINT_UNSIGNED__) +# define WINT_MAX UINT32_MAX +# define WINT_MIN 0 +#else +# define WINT_MAX INT32_MAX +# define WINT_MIN INT32_MIN +#endif + +#if defined(__LP64__) +# define INTPTR_MIN INT64_MIN +# define INTPTR_MAX INT64_MAX +# define UINTPTR_MAX UINT64_MAX +# define PTRDIFF_MIN INT64_MIN +# define PTRDIFF_MAX INT64_MAX +# define SIZE_MAX UINT64_MAX +#else +# define INTPTR_MIN INT32_MIN +# define INTPTR_MAX INT32_MAX +# define UINTPTR_MAX UINT32_MAX +# define PTRDIFF_MIN INT32_MIN +# define PTRDIFF_MAX INT32_MAX +# define SIZE_MAX UINT32_MAX +#endif + +#endif /* _STDINT_H */ diff --git a/headers/stdio.h b/headers/stdio.h new file mode 100644 index 000000000..70b89a996 --- /dev/null +++ b/headers/stdio.h @@ -0,0 +1,459 @@ +/* $OpenBSD: stdio.h,v 1.35 2006/01/13 18:10:09 miod Exp $ */ +/* $NetBSD: stdio.h,v 1.18 1996/04/25 18:29:21 jtc Exp $ */ + +/*- + * Copyright (c) 1990 The Regents of the University of California. + * All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)stdio.h 5.17 (Berkeley) 6/3/91 + */ + +#ifndef _STDIO_H_ +#define _STDIO_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +#include <stdarg.h> +#include <stddef.h> + +#define __need_NULL +#include <stddef.h> + +#include <bits/seek_constants.h> + +#if __ANDROID_API__ < __ANDROID_API_N__ +#include <bits/struct_file.h> +#endif + +__BEGIN_DECLS + +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wnullability-completeness" +#endif + +typedef off_t fpos_t; +typedef off64_t fpos64_t; + +struct __sFILE; +typedef struct __sFILE FILE; + +#if __ANDROID_API__ >= __ANDROID_API_M__ +extern FILE* stdin __INTRODUCED_IN(23); +extern FILE* stdout __INTRODUCED_IN(23); +extern FILE* stderr __INTRODUCED_IN(23); + +/* C99 and earlier plus current C++ standards say these must be macros. */ +#define stdin stdin +#define stdout stdout +#define stderr stderr +#else +/* Before M the actual symbols for stdin and friends had different names. */ +extern FILE __sF[] __REMOVED_IN(23); + +#define stdin (&__sF[0]) +#define stdout (&__sF[1]) +#define stderr (&__sF[2]) +#endif + +/* + * The following three definitions are for ANSI C, which took them + * from System V, which brilliantly took internal interface macros and + * made them official arguments to setvbuf(), without renaming them. + * Hence, these ugly _IOxxx names are *supposed* to appear in user code. + * + * Although numbered as their counterparts above, the implementation + * does not rely on this. + */ +#define _IOFBF 0 /* setvbuf should set fully buffered */ +#define _IOLBF 1 /* setvbuf should set line buffered */ +#define _IONBF 2 /* setvbuf should set unbuffered */ + +#define BUFSIZ 1024 /* size of buffer used by setbuf */ +#define EOF (-1) + +/* + * FOPEN_MAX is a minimum maximum, and is the number of streams that + * stdio can provide without attempting to allocate further resources + * (which could fail). Do not use this for anything. + */ + +#define FOPEN_MAX 20 /* must be <= OPEN_MAX <sys/syslimits.h> */ +#define FILENAME_MAX 1024 /* must be <= PATH_MAX <sys/syslimits.h> */ + +#define L_tmpnam 1024 /* XXX must be == PATH_MAX */ +#define TMP_MAX 308915776 + +/* + * Functions defined in ANSI C standard. + */ +void clearerr(FILE *); +int fclose(FILE *); +int feof(FILE *); +int ferror(FILE *); +int fflush(FILE *); +int fgetc(FILE *); +char *fgets(char * __restrict, int, FILE * __restrict); +int fprintf(FILE * __restrict , const char * __restrict _Nonnull, ...) __printflike(2, 3); +int fputc(int, FILE *); +int fputs(const char * __restrict, FILE * __restrict); +size_t fread(void * __restrict, size_t, size_t, FILE * __restrict); +int fscanf(FILE * __restrict, const char * __restrict _Nonnull, ...) __scanflike(2, 3); +size_t fwrite(const void * __restrict, size_t, size_t, FILE * __restrict); +int getc(FILE *); +int getchar(void); + +#if __ANDROID_API__ >= 18 +ssize_t getdelim(char** __restrict, size_t* __restrict, int, FILE* __restrict) __INTRODUCED_IN(18); +ssize_t getline(char** __restrict, size_t* __restrict, FILE* __restrict) __INTRODUCED_IN(18); +#endif /* __ANDROID_API__ >= 18 */ + + +void perror(const char *); +int printf(const char * __restrict _Nonnull, ...) __printflike(1, 2); +int putc(int, FILE *); +int putchar(int); +int puts(const char *); +int remove(const char *); +void rewind(FILE *); +int scanf(const char * __restrict _Nonnull, ...) __scanflike(1, 2); +void setbuf(FILE * __restrict, char * __restrict); +int setvbuf(FILE * __restrict, char * __restrict, int, size_t); +int sscanf(const char * __restrict, const char * __restrict _Nonnull, ...) __scanflike(2, 3); +int ungetc(int, FILE *); +int vfprintf(FILE * __restrict, const char * __restrict _Nonnull, __va_list) __printflike(2, 0); +int vprintf(const char * __restrict _Nonnull, __va_list) __printflike(1, 0); + + +#if __ANDROID_API__ >= 21 +int dprintf(int, const char* __restrict _Nonnull, ...) __printflike(2, 3) __INTRODUCED_IN(21); +int vdprintf(int, const char* __restrict _Nonnull, __va_list) __printflike(2, 0) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +#if (defined(__STDC_VERSION__) && __STDC_VERSION__ < 201112L) || \ + (defined(__cplusplus) && __cplusplus <= 201103L) +char* gets(char*) __attribute__((deprecated("gets is unsafe, use fgets instead"))); +#endif +int sprintf(char* __restrict, const char* __restrict _Nonnull, ...) __printflike(2, 3); +int vsprintf(char* __restrict, const char* __restrict _Nonnull, __va_list) __printflike(2, 0); +char* tmpnam(char*) __attribute__((deprecated("tmpnam is unsafe, use mkstemp or tmpfile instead"))); +#define P_tmpdir "/tmp/" /* deprecated */ +char* tempnam(const char*, const char*) + __attribute__((deprecated("tempnam is unsafe, use mkstemp or tmpfile instead"))); + +int rename(const char*, const char*); +int renameat(int, const char*, int, const char*); + +int fseek(FILE*, long, int); +long ftell(FILE*); + +#if defined(__USE_FILE_OFFSET64) +int fgetpos(FILE*, fpos_t*) __RENAME(fgetpos64); +int fsetpos(FILE*, const fpos_t*) __RENAME(fsetpos64); +int fseeko(FILE*, off_t, int) __RENAME(fseeko64); +off_t ftello(FILE*) __RENAME(ftello64); +# if defined(__USE_BSD) +FILE* funopen(const void*, + int (*)(void*, char*, int), + int (*)(void*, const char*, int), + fpos_t (*)(void*, fpos_t, int), + int (*)(void*)) __RENAME(funopen64); +# endif +#else +int fgetpos(FILE*, fpos_t*); +int fsetpos(FILE*, const fpos_t*); +int fseeko(FILE*, off_t, int); +off_t ftello(FILE*); +# if defined(__USE_BSD) +FILE* funopen(const void*, + int (*)(void*, char*, int), + int (*)(void*, const char*, int), + fpos_t (*)(void*, fpos_t, int), + int (*)(void*)); +# endif +#endif + +#if __ANDROID_API__ >= 24 +int fgetpos64(FILE*, fpos64_t*) __INTRODUCED_IN(24); +int fsetpos64(FILE*, const fpos64_t*) __INTRODUCED_IN(24); +int fseeko64(FILE*, off64_t, int) __INTRODUCED_IN(24); +off64_t ftello64(FILE*) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + +#if defined(__USE_BSD) + +#if __ANDROID_API__ >= 24 +FILE* funopen64(const void*, int (*)(void*, char*, int), int (*)(void*, const char*, int), + fpos64_t (*)(void*, fpos64_t, int), int (*)(void*)) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + +#endif + +FILE* fopen(const char* __restrict, const char* __restrict); + +#if __ANDROID_API__ >= 24 +FILE* fopen64(const char* __restrict, const char* __restrict) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + +FILE* freopen(const char* __restrict, const char* __restrict, FILE* __restrict); + +#if __ANDROID_API__ >= 24 +FILE* freopen64(const char* __restrict, const char* __restrict, FILE* __restrict) + __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + +FILE* tmpfile(void); + +#if __ANDROID_API__ >= 24 +FILE* tmpfile64(void) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + + +int snprintf(char* __restrict, size_t, const char* __restrict _Nonnull, ...) __printflike(3, 4); +int vfscanf(FILE* __restrict, const char* __restrict _Nonnull, __va_list) __scanflike(2, 0); +int vscanf(const char* _Nonnull , __va_list) __scanflike(1, 0); +int vsnprintf(char* __restrict, size_t, const char* __restrict _Nonnull, __va_list) __printflike(3, 0); +int vsscanf(const char* __restrict _Nonnull, const char* __restrict _Nonnull, __va_list) __scanflike(2, 0); + +#define L_ctermid 1024 /* size for ctermid() */ + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +char* ctermid(char*) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + +FILE* fdopen(int, const char*); +int fileno(FILE*); +int pclose(FILE*); +FILE* popen(const char*, const char*); +void flockfile(FILE*); +int ftrylockfile(FILE*); +void funlockfile(FILE*); +int getc_unlocked(FILE*); +int getchar_unlocked(void); +int putc_unlocked(int, FILE*); +int putchar_unlocked(int); + + +#if __ANDROID_API__ >= 23 +FILE* fmemopen(void*, size_t, const char*) __INTRODUCED_IN(23); +FILE* open_memstream(char**, size_t*) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if defined(__USE_BSD) || defined(__BIONIC__) /* Historically bionic exposed these. */ +int asprintf(char** __restrict, const char* __restrict _Nonnull, ...) __printflike(2, 3); +char* fgetln(FILE* __restrict, size_t* __restrict); +int fpurge(FILE*); +void setbuffer(FILE*, char*, int); +int setlinebuf(FILE*); +int vasprintf(char** __restrict, const char* __restrict _Nonnull, __va_list) __printflike(2, 0); + +#if __ANDROID_API__ >= 23 +void clearerr_unlocked(FILE*) __INTRODUCED_IN(23); +int feof_unlocked(FILE*) __INTRODUCED_IN(23); +int ferror_unlocked(FILE*) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if __ANDROID_API__ >= 24 +int fileno_unlocked(FILE*) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + +#define fropen(cookie, fn) funopen(cookie, fn, 0, 0, 0) +#define fwopen(cookie, fn) funopen(cookie, 0, fn, 0, 0) +#endif /* __USE_BSD */ + + +#if __ANDROID_API__ >= 17 +char* __fgets_chk(char*, int, FILE*, size_t) __INTRODUCED_IN(17); +#endif /* __ANDROID_API__ >= 17 */ + +char* __fgets_real(char*, int, FILE*) __RENAME(fgets); +__errordecl(__fgets_too_big_error, "fgets called with size bigger than buffer"); +__errordecl(__fgets_too_small_error, "fgets called with size less than zero"); + + +#if __ANDROID_API__ >= 24 +size_t __fread_chk(void* __restrict, size_t, size_t, FILE* __restrict, size_t) + __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + +size_t __fread_real(void * __restrict, size_t, size_t, FILE * __restrict) __RENAME(fread); +__errordecl(__fread_too_big_error, "fread called with size * count bigger than buffer"); +__errordecl(__fread_overflow, "fread called with overflowing size * count"); + + +#if __ANDROID_API__ >= 24 +size_t __fwrite_chk(const void* __restrict, size_t, size_t, FILE* __restrict, size_t) + __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + +size_t __fwrite_real(const void * __restrict, size_t, size_t, FILE * __restrict) __RENAME(fwrite); +__errordecl(__fwrite_too_big_error, "fwrite called with size * count bigger than buffer"); +__errordecl(__fwrite_overflow, "fwrite called with overflowing size * count"); + +#if defined(__BIONIC_FORTIFY) && !defined(__BIONIC_NO_STDIO_FORTIFY) + +#if __ANDROID_API__ >= __ANDROID_API_J_MR1__ +__BIONIC_FORTIFY_INLINE +__printflike(3, 0) int vsnprintf(char* dest, size_t size, const char* _Nonnull format, __va_list ap) { + return __builtin___vsnprintf_chk(dest, size, 0, __bos(dest), format, ap); +} + +__BIONIC_FORTIFY_INLINE +__printflike(2, 0) int vsprintf(char* dest, const char* _Nonnull format, __va_list ap) { + return __builtin___vsprintf_chk(dest, 0, __bos(dest), format, ap); +} + +#if defined(__clang__) + #if !defined(snprintf) + #define __wrap_snprintf(dest, size, ...) __builtin___snprintf_chk(dest, size, 0, __bos(dest), __VA_ARGS__) + #define snprintf(...) __wrap_snprintf(__VA_ARGS__) + #endif +#else +__BIONIC_FORTIFY_INLINE +__printflike(3, 4) int snprintf(char* dest, size_t size, const char* _Nonnull format, ...) { + return __builtin___snprintf_chk(dest, size, 0, __bos(dest), format, __builtin_va_arg_pack()); +} +#endif + +#if defined(__clang__) + #if !defined(sprintf) + #define __wrap_sprintf(dest, ...) __builtin___sprintf_chk(dest, 0, __bos(dest), __VA_ARGS__) + #define sprintf(...) __wrap_sprintf(__VA_ARGS__) + #endif +#else +__BIONIC_FORTIFY_INLINE +__printflike(2, 3) int sprintf(char* dest, const char* _Nonnull format, ...) { + return __builtin___sprintf_chk(dest, 0, __bos(dest), format, __builtin_va_arg_pack()); +} +#endif +#endif /* __ANDROID_API__ >= __ANDROID_API_J_MR1__ */ + +#if __ANDROID_API__ >= __ANDROID_API_N__ +__BIONIC_FORTIFY_INLINE +size_t fread(void * __restrict buf, size_t size, size_t count, FILE * __restrict stream) { + size_t bos = __bos0(buf); + +#if !defined(__clang__) + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __fread_real(buf, size, count, stream); + } + + if (__builtin_constant_p(size) && __builtin_constant_p(count)) { + size_t total; + if (__size_mul_overflow(size, count, &total)) { + __fread_overflow(); + } + + if (total > bos) { + __fread_too_big_error(); + } + + return __fread_real(buf, size, count, stream); + } +#endif + + return __fread_chk(buf, size, count, stream, bos); +} + +__BIONIC_FORTIFY_INLINE +size_t fwrite(const void * __restrict buf, size_t size, size_t count, FILE * __restrict stream) { + size_t bos = __bos0(buf); + +#if !defined(__clang__) + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __fwrite_real(buf, size, count, stream); + } + + if (__builtin_constant_p(size) && __builtin_constant_p(count)) { + size_t total; + if (__size_mul_overflow(size, count, &total)) { + __fwrite_overflow(); + } + + if (total > bos) { + __fwrite_too_big_error(); + } + + return __fwrite_real(buf, size, count, stream); + } +#endif + + return __fwrite_chk(buf, size, count, stream, bos); +} +#endif /* __ANDROID_API__ >= __ANDROID_API_N__ */ + +#if !defined(__clang__) + +__BIONIC_FORTIFY_INLINE +char *fgets(char* dest, int size, FILE* stream) { + size_t bos = __bos(dest); + + // Compiler can prove, at compile time, that the passed in size + // is always negative. Force a compiler error. + if (__builtin_constant_p(size) && (size < 0)) { + __fgets_too_small_error(); + } + + // Compiler doesn't know destination size. Don't call __fgets_chk + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __fgets_real(dest, size, stream); + } + + // Compiler can prove, at compile time, that the passed in size + // is always <= the actual object size. Don't call __fgets_chk + if (__builtin_constant_p(size) && (size <= (int) bos)) { + return __fgets_real(dest, size, stream); + } + + // Compiler can prove, at compile time, that the passed in size + // is always > the actual object size. Force a compiler error. + if (__builtin_constant_p(size) && (size > (int) bos)) { + __fgets_too_big_error(); + } + + return __fgets_chk(dest, size, stream, bos); +} + +#endif /* !defined(__clang__) */ + +#endif /* defined(__BIONIC_FORTIFY) */ + +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + +__END_DECLS + +#endif /* _STDIO_H_ */ diff --git a/headers/stdio_ext.h b/headers/stdio_ext.h new file mode 100644 index 000000000..3f9e8b675 --- /dev/null +++ b/headers/stdio_ext.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _STDIO_EXT_H +#define _STDIO_EXT_H + +#include <sys/cdefs.h> +#include <stdio.h> + +#define FSETLOCKING_QUERY 0 +#define FSETLOCKING_INTERNAL 1 +#define FSETLOCKING_BYCALLER 2 + +__BEGIN_DECLS + + +#if __ANDROID_API__ >= 23 +size_t __fbufsize(FILE*) __INTRODUCED_IN(23); +int __freadable(FILE*) __INTRODUCED_IN(23); +int __fwritable(FILE*) __INTRODUCED_IN(23); +int __flbf(FILE*) __INTRODUCED_IN(23); +void __fpurge(FILE*) __INTRODUCED_IN(23); +size_t __fpending(FILE*) __INTRODUCED_IN(23); +void _flushlbf(void) __INTRODUCED_IN(23); +int __fsetlocking(FILE*, int) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +__END_DECLS + +#endif /* _STDIO_EXT_H */ diff --git a/headers/stdlib.h b/headers/stdlib.h new file mode 100644 index 000000000..8f444093d --- /dev/null +++ b/headers/stdlib.h @@ -0,0 +1,274 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _STDLIB_H +#define _STDLIB_H + +#include <sys/cdefs.h> +#include <xlocale.h> + +#include <alloca.h> +#include <malloc.h> +#include <stddef.h> + +__BEGIN_DECLS + +#define EXIT_FAILURE 1 +#define EXIT_SUCCESS 0 + +__noreturn void abort(void); +__noreturn void exit(int); + +#if __ANDROID_API__ >= 21 +__noreturn void _Exit(int) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int atexit(void (*)(void)); + + +#if __ANDROID_API__ >= 21 +int at_quick_exit(void (*)(void)) __INTRODUCED_IN(21); +void quick_exit(int) __noreturn __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +char* getenv(const char*); +int putenv(char*); +int setenv(const char*, const char*, int); +int unsetenv(const char*); +int clearenv(void); + +char* mkdtemp(char*); +char* mktemp(char*) __attribute__((deprecated("mktemp is unsafe, use mkstemp or tmpfile instead"))); + + +#if __ANDROID_API__ >= 23 +int mkostemp64(char*, int) __INTRODUCED_IN(23); +int mkostemp(char*, int) __INTRODUCED_IN(23); +int mkostemps64(char*, int, int) __INTRODUCED_IN(23); +int mkostemps(char*, int, int) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +#if __ANDROID_API__ >= 21 +int mkstemp64(char*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int mkstemp(char*); + +#if __ANDROID_API__ >= 23 +int mkstemps64(char*, int) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +int mkstemps(char*, int); + +long strtol(const char *, char **, int); +long long strtoll(const char *, char **, int); +unsigned long strtoul(const char *, char **, int); +unsigned long long strtoull(const char *, char **, int); + + +#if __ANDROID_API__ >= 16 +int posix_memalign(void** memptr, size_t alignment, size_t size) __INTRODUCED_IN(16); +#endif /* __ANDROID_API__ >= 16 */ + + +double strtod(const char*, char**); + +#if __ANDROID_API__ >= 21 +long double strtold(const char*, char**) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +unsigned long strtoul_l(const char*, char**, int, locale_t) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + +int atoi(const char*) __attribute_pure__; +long atol(const char*) __attribute_pure__; +long long atoll(const char*) __attribute_pure__; + +char* realpath(const char* path, char* resolved); +int system(const char* string); + +void* bsearch(const void* key, const void* base0, size_t nmemb, size_t size, + int (*compar)(const void*, const void*)); + +void qsort(void*, size_t, size_t, int (*)(const void*, const void*)); + +uint32_t arc4random(void); +uint32_t arc4random_uniform(uint32_t); +void arc4random_buf(void*, size_t); + +#define RAND_MAX 0x7fffffff + + +#if __ANDROID_API__ >= 21 +int rand_r(unsigned int*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +double drand48(void); +double erand48(unsigned short[3]); +long jrand48(unsigned short[3]); + +#if __ANDROID_API__ >= 23 +void lcong48(unsigned short[7]) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +long lrand48(void); +long mrand48(void); +long nrand48(unsigned short[3]); +unsigned short* seed48(unsigned short[3]); +void srand48(long); + + +#if __ANDROID_API__ >= 21 +char* initstate(unsigned int, char*, size_t) __INTRODUCED_IN(21); +char* setstate(char*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +int getpt(void); + +#if __ANDROID_API__ >= 21 +int posix_openpt(int) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +char* ptsname(int); +int ptsname_r(int, char*, size_t); +int unlockpt(int); + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +int getsubopt(char**, char* const*, char**) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + +typedef struct { + int quot; + int rem; +} div_t; + +div_t div(int, int) __attribute_const__; + +typedef struct { + long int quot; + long int rem; +} ldiv_t; + +ldiv_t ldiv(long, long) __attribute_const__; + +typedef struct { + long long int quot; + long long int rem; +} lldiv_t; + +lldiv_t lldiv(long long, long long) __attribute_const__; + +/* BSD compatibility. */ + +#if __ANDROID_API__ >= 21 +const char* getprogname(void) __INTRODUCED_IN(21); +void setprogname(const char*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +int mblen(const char*, size_t) __INTRODUCED_IN_FUTURE __VERSIONER_NO_GUARD; +size_t mbstowcs(wchar_t*, const char*, size_t); +int mbtowc(wchar_t*, const char*, size_t) __INTRODUCED_IN(21) __VERSIONER_NO_GUARD; +int wctomb(char*, wchar_t) __INTRODUCED_IN(21) __VERSIONER_NO_GUARD; + +size_t wcstombs(char*, const wchar_t*, size_t); + +#if __ANDROID_API__ >= __ANDROID_API_L__ +size_t __ctype_get_mb_cur_max(void) __INTRODUCED_IN(21); +#define MB_CUR_MAX __ctype_get_mb_cur_max() +#else +/* + * 4 is only true for UTF-8 locales, but that's what we default to. We'll need + * the NDK compatibility library to fix this properly. + */ +#define MB_CUR_MAX 4 +#endif + +#if defined(__BIONIC_FORTIFY) + +char* __realpath_real(const char*, char*) __RENAME(realpath); +__errordecl(__realpath_size_error, "realpath output parameter must be NULL or a >= PATH_MAX bytes buffer"); + +#if !defined(__clang__) +__BIONIC_FORTIFY_INLINE +char* realpath(const char* path, char* resolved) { + size_t bos = __bos(resolved); + + /* PATH_MAX is unavailable without polluting the namespace, but it's always 4096 on Linux */ + if (bos != __BIONIC_FORTIFY_UNKNOWN_SIZE && bos < 4096) { + __realpath_size_error(); + } + + return __realpath_real(path, resolved); +} +#endif + +#endif /* defined(__BIONIC_FORTIFY) */ + +#if __ANDROID_API__ >= __ANDROID_API_L__ +float strtof(const char*, char**) __INTRODUCED_IN(21); +double atof(const char*) __attribute_pure__ __INTRODUCED_IN(21); +int abs(int) __attribute_const__ __INTRODUCED_IN(21); +long labs(long) __attribute_const__ __INTRODUCED_IN(21); +long long llabs(long long) __attribute_const__ __INTRODUCED_IN(21); +int rand(void) __INTRODUCED_IN(21); +void srand(unsigned int) __INTRODUCED_IN(21); +long random(void) __INTRODUCED_IN(21); +void srandom(unsigned int) __INTRODUCED_IN(21); +int grantpt(int) __INTRODUCED_IN(21); + +long long strtoll_l(const char*, char**, int, locale_t) __INTRODUCED_IN(21); +unsigned long long strtoull_l(const char*, char**, int, locale_t) __INTRODUCED_IN(21); +long double strtold_l(const char*, char**, locale_t) __INTRODUCED_IN(21); +#else +// Implemented as static inlines before 21. +#endif + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +double strtod_l(const char*, char**, locale_t) __INTRODUCED_IN_FUTURE; +float strtof_l(const char*, char**, locale_t) __INTRODUCED_IN_FUTURE; +long strtol_l(const char*, char**, int, locale_t) __INTRODUCED_IN_FUTURE; +#else +// Implemented as static inlines. +#endif + +__END_DECLS + +#include <android/legacy_stdlib_inlines.h> + +#endif /* _STDLIB_H */ diff --git a/headers/string.h b/headers/string.h new file mode 100644 index 000000000..0b957d2b9 --- /dev/null +++ b/headers/string.h @@ -0,0 +1,454 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _STRING_H +#define _STRING_H + +#include <sys/cdefs.h> +#include <stddef.h> +#include <xlocale.h> + +#include <bits/strcasecmp.h> + +__BEGIN_DECLS + +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wnullability-completeness" +#endif + +#if defined(__USE_BSD) +#include <strings.h> +#endif + +void* memccpy(void* _Nonnull __restrict, const void* _Nonnull __restrict, int, size_t); +void* memchr(const void* _Nonnull, int, size_t) __attribute_pure__; +void* memrchr(const void* _Nonnull, int, size_t) __attribute_pure__; +int memcmp(const void* _Nonnull, const void* _Nonnull, size_t) __attribute_pure__; +void* memcpy(void* _Nonnull __restrict, const void* _Nonnull __restrict, size_t); +#if defined(__USE_GNU) + +#if __ANDROID_API__ >= 23 +void* mempcpy(void* _Nonnull __restrict, const void* _Nonnull __restrict, size_t) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +#endif +void* memmove(void* _Nonnull, const void* _Nonnull, size_t); +void* memset(void* _Nonnull, int, size_t); +void* memmem(const void* _Nonnull, size_t, const void* _Nonnull, size_t) __attribute_pure__; + +char* strchr(const char* _Nonnull, int) __attribute_pure__; + +#if __ANDROID_API__ >= 18 +char* __strchr_chk(const char* _Nonnull, int, size_t) __INTRODUCED_IN(18); +#endif /* __ANDROID_API__ >= 18 */ + +#if defined(__USE_GNU) +#if defined(__cplusplus) +extern "C++" char* strchrnul(char* _Nonnull, int) __RENAME(strchrnul) __attribute_pure__; +extern "C++" const char* strchrnul(const char* _Nonnull, int) __RENAME(strchrnul) __attribute_pure__; +#else + +#if __ANDROID_API__ >= 24 +char* strchrnul(const char* _Nonnull, int) __attribute_pure__ __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + +#endif +#endif + +char* strrchr(const char* _Nonnull, int) __attribute_pure__; + +#if __ANDROID_API__ >= 18 +char* __strrchr_chk(const char* _Nonnull, int, size_t) __INTRODUCED_IN(18); +#endif /* __ANDROID_API__ >= 18 */ + + +size_t strlen(const char* _Nonnull) __attribute_pure__; + +#if __ANDROID_API__ >= 17 +size_t __strlen_chk(const char* _Nonnull, size_t) __INTRODUCED_IN(17); +#endif /* __ANDROID_API__ >= 17 */ + +int strcmp(const char* _Nonnull, const char* _Nonnull) __attribute_pure__; + +#if __ANDROID_API__ >= 21 +char* stpcpy(char* _Nonnull __restrict, const char* _Nonnull__restrict) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +char* strcpy(char* _Nonnull __restrict, const char* _Nonnull __restrict); +char* strcat(char* _Nonnull __restrict, const char* _Nonnull __restrict); + +char* strdup(const char* _Nonnull); + +char* strstr(const char* _Nonnull, const char* _Nonnull) __attribute_pure__; +char* strcasestr(const char* _Nonnull, const char* _Nonnull) __attribute_pure__; +char* strtok(char* __restrict, const char* _Nonnull __restrict); +char* strtok_r(char* __restrict, const char* _Nonnull __restrict, char** _Nonnull __restrict); + +char* strerror(int); + +#if __ANDROID_API__ >= 23 +char* strerror_l(int, locale_t) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +#if defined(__USE_GNU) + +#if __ANDROID_API__ >= 23 +char* strerror_r(int, char*, size_t) __RENAME(__gnu_strerror_r) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +#else /* POSIX */ +int strerror_r(int, char*, size_t); +#endif + +size_t strnlen(const char* _Nonnull, size_t) __attribute_pure__; +char* strncat(char* _Nonnull __restrict, const char* _Nonnull __restrict, size_t); +char* strndup(const char* _Nonnull, size_t); +int strncmp(const char* _Nonnull, const char* _Nonnull, size_t) __attribute_pure__; + +#if __ANDROID_API__ >= 21 +char* stpncpy(char* _Nonnull __restrict, const char* _Nonnull __restrict, size_t) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +char* strncpy(char* _Nonnull __restrict, const char* _Nonnull __restrict, size_t); + +size_t strlcat(char* _Nonnull __restrict, const char* _Nonnull __restrict, size_t); +size_t strlcpy(char* _Nonnull __restrict, const char* _Nonnull __restrict, size_t); + +size_t strcspn(const char* _Nonnull, const char* _Nonnull) __attribute_pure__; +char* strpbrk(const char* _Nonnull, const char* _Nonnull) __attribute_pure__; +char* strsep(char** _Nonnull __restrict, const char* _Nonnull __restrict); +size_t strspn(const char* _Nonnull, const char* _Nonnull); + +char* strsignal(int); + +int strcoll(const char* _Nonnull, const char* _Nonnull) __attribute_pure__; +size_t strxfrm(char* __restrict, const char* _Nonnull __restrict, size_t); + +#if __ANDROID_API__ >= __ANDROID_API_L__ +int strcoll_l(const char* _Nonnull, const char* _Nonnull, locale_t) __attribute_pure__ __INTRODUCED_IN(21); +size_t strxfrm_l(char* __restrict, const char* _Nonnull __restrict, size_t, locale_t) __INTRODUCED_IN(21); +#else +// Implemented as static inlines before 21. +#endif + +#if defined(__USE_GNU) && !defined(basename) +/* + * glibc has a basename in <string.h> that's different to the POSIX one in <libgen.h>. + * It doesn't modify its argument, and in C++ it's const-correct. + */ +#if defined(__cplusplus) +extern "C++" char* basename(char* _Nonnull) __RENAME(__gnu_basename); +extern "C++" const char* basename(const char* _Nonnull) __RENAME(__gnu_basename); +#else + +#if __ANDROID_API__ >= 23 +char* basename(const char* _Nonnull) __RENAME(__gnu_basename) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +#endif +#endif + + +#if __ANDROID_API__ >= 23 +void* __memchr_chk(const void* _Nonnull, int, size_t, size_t) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +__errordecl(__memchr_buf_size_error, "memchr called with size bigger than buffer"); + + +#if __ANDROID_API__ >= 23 +void* __memrchr_chk(const void* _Nonnull, int, size_t, size_t) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +__errordecl(__memrchr_buf_size_error, "memrchr called with size bigger than buffer"); +void* __memrchr_real(const void* _Nonnull, int, size_t) __RENAME(memrchr); + + +#if __ANDROID_API__ >= 21 +char* __stpncpy_chk2(char* _Nonnull __restrict, const char* _Nonnull __restrict, size_t, size_t, size_t) + __INTRODUCED_IN(21); +char* __strncpy_chk2(char* _Nonnull __restrict, const char* _Nonnull __restrict, size_t, size_t, size_t) + __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +size_t __strlcpy_real(char* _Nonnull __restrict, const char* _Nonnull __restrict, size_t) __RENAME(strlcpy); + +#if __ANDROID_API__ >= 17 +size_t __strlcpy_chk(char* _Nonnull __restrict, const char* _Nonnull __restrict, size_t, size_t) __INTRODUCED_IN(17); +#endif /* __ANDROID_API__ >= 17 */ + +size_t __strlcat_real(char* _Nonnull __restrict, const char* _Nonnull __restrict, size_t) __RENAME(strlcat); + +#if __ANDROID_API__ >= 17 +size_t __strlcat_chk(char* _Nonnull __restrict, const char* _Nonnull __restrict, size_t, size_t) __INTRODUCED_IN(17); +#endif /* __ANDROID_API__ >= 17 */ + + +#if defined(__BIONIC_FORTIFY) + +#if __ANDROID_API__ >= __ANDROID_API_M__ +__BIONIC_FORTIFY_INLINE +void* memchr(const void* s, int c, size_t n) { + size_t bos = __bos(s); + +#if !defined(__clang__) + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __builtin_memchr(s, c, n); + } + + if (__builtin_constant_p(n) && (n > bos)) { + __memchr_buf_size_error(); + } + + if (__builtin_constant_p(n) && (n <= bos)) { + return __builtin_memchr(s, c, n); + } +#endif + + return __memchr_chk(s, c, n, bos); +} + +__BIONIC_FORTIFY_INLINE +void* memrchr(const void* s, int c, size_t n) { + size_t bos = __bos(s); + +#if !defined(__clang__) + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __memrchr_real(s, c, n); + } + + if (__builtin_constant_p(n) && (n > bos)) { + __memrchr_buf_size_error(); + } + + if (__builtin_constant_p(n) && (n <= bos)) { + return __memrchr_real(s, c, n); + } +#endif + + return __memrchr_chk(s, c, n, bos); +} +#endif /* __ANDROID_API__ >= __ANDROID_API_M__ */ + +#if __ANDROID_API__ >= __ANDROID_API_J_MR1__ +__BIONIC_FORTIFY_INLINE +void* memcpy(void* _Nonnull __restrict dst, const void* _Nonnull __restrict src, size_t copy_amount) { + return __builtin___memcpy_chk(dst, src, copy_amount, __bos0(dst)); +} + +__BIONIC_FORTIFY_INLINE +void* memmove(void* _Nonnull dst, const void* _Nonnull src, size_t len) { + return __builtin___memmove_chk(dst, src, len, __bos0(dst)); +} +#endif /* __ANDROID_API__ >= __ANDROID_API_J_MR1__ */ + +#if __ANDROID_API__ >= __ANDROID_API_L__ +__BIONIC_FORTIFY_INLINE +char* stpcpy(char* _Nonnull __restrict dst, const char* _Nonnull __restrict src) { + return __builtin___stpcpy_chk(dst, src, __bos(dst)); +} +#endif /* __ANDROID_API__ >= __ANDROID_API_L__ */ + +#if __ANDROID_API__ >= __ANDROID_API_J_MR1__ +__BIONIC_FORTIFY_INLINE +char* strcpy(char* _Nonnull __restrict dst, const char* _Nonnull __restrict src) { + return __builtin___strcpy_chk(dst, src, __bos(dst)); +} +#endif /* __ANDROID_API__ >= __ANDROID_API_J_MR1__ */ + +#if __ANDROID_API__ >= __ANDROID_API_L__ +__BIONIC_FORTIFY_INLINE +char* stpncpy(char* _Nonnull __restrict dst, const char* _Nonnull __restrict src, size_t n) { + size_t bos_dst = __bos(dst); + size_t bos_src = __bos(src); + + if (bos_src == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __builtin___stpncpy_chk(dst, src, n, bos_dst); + } + + if (__builtin_constant_p(n) && (n <= bos_src)) { + return __builtin___stpncpy_chk(dst, src, n, bos_dst); + } + + size_t slen = __builtin_strlen(src); + if (__builtin_constant_p(slen)) { + return __builtin___stpncpy_chk(dst, src, n, bos_dst); + } + + return __stpncpy_chk2(dst, src, n, bos_dst, bos_src); +} + +__BIONIC_FORTIFY_INLINE +char* strncpy(char* _Nonnull __restrict dst, const char* _Nonnull __restrict src, size_t n) { + size_t bos_dst = __bos(dst); + size_t bos_src = __bos(src); + + if (bos_src == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __builtin___strncpy_chk(dst, src, n, bos_dst); + } + + if (__builtin_constant_p(n) && (n <= bos_src)) { + return __builtin___strncpy_chk(dst, src, n, bos_dst); + } + + size_t slen = __builtin_strlen(src); + if (__builtin_constant_p(slen)) { + return __builtin___strncpy_chk(dst, src, n, bos_dst); + } + + return __strncpy_chk2(dst, src, n, bos_dst, bos_src); +} +#endif /* __ANDROID_API__ >= __ANDROID_API_L__ */ + +#if __ANDROID_API__ >= __ANDROID_API_J_MR1__ +__BIONIC_FORTIFY_INLINE +char* strcat(char* _Nonnull __restrict dst, const char* _Nonnull __restrict src) { + return __builtin___strcat_chk(dst, src, __bos(dst)); +} + +__BIONIC_FORTIFY_INLINE +char *strncat(char* _Nonnull __restrict dst, const char* _Nonnull __restrict src, size_t n) { + return __builtin___strncat_chk(dst, src, n, __bos(dst)); +} + +__BIONIC_FORTIFY_INLINE +void* memset(void* _Nonnull s, int c, size_t n) { + return __builtin___memset_chk(s, c, n, __bos0(s)); +} + +__BIONIC_FORTIFY_INLINE +size_t strlcpy(char* _Nonnull __restrict dst, const char* _Nonnull __restrict src, size_t size) { + size_t bos = __bos(dst); + +#if !defined(__clang__) + // Compiler doesn't know destination size. Don't call __strlcpy_chk + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __strlcpy_real(dst, src, size); + } + + // Compiler can prove, at compile time, that the passed in size + // is always <= the actual object size. Don't call __strlcpy_chk + if (__builtin_constant_p(size) && (size <= bos)) { + return __strlcpy_real(dst, src, size); + } +#endif /* !defined(__clang__) */ + + return __strlcpy_chk(dst, src, size, bos); +} + + +__BIONIC_FORTIFY_INLINE +size_t strlcat(char* _Nonnull __restrict dst, const char* _Nonnull __restrict src, size_t size) { + size_t bos = __bos(dst); + +#if !defined(__clang__) + // Compiler doesn't know destination size. Don't call __strlcat_chk + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __strlcat_real(dst, src, size); + } + + // Compiler can prove, at compile time, that the passed in size + // is always <= the actual object size. Don't call __strlcat_chk + if (__builtin_constant_p(size) && (size <= bos)) { + return __strlcat_real(dst, src, size); + } +#endif /* !defined(__clang__) */ + + return __strlcat_chk(dst, src, size, bos); +} + +__BIONIC_FORTIFY_INLINE +size_t strlen(const char* _Nonnull s) { + size_t bos = __bos(s); + +#if !defined(__clang__) + // Compiler doesn't know destination size. Don't call __strlen_chk + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __builtin_strlen(s); + } + + size_t slen = __builtin_strlen(s); + if (__builtin_constant_p(slen)) { + return slen; + } +#endif /* !defined(__clang__) */ + + return __strlen_chk(s, bos); +} +#endif /* __ANDROID_API__ >= __ANDROID_API_J_MR1__ */ + +#if __ANDROID_API__ >= __ANDROID_API_J_MR2__ +__BIONIC_FORTIFY_INLINE +char* strchr(const char* _Nonnull s, int c) { + size_t bos = __bos(s); + +#if !defined(__clang__) + // Compiler doesn't know destination size. Don't call __strchr_chk + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __builtin_strchr(s, c); + } + + size_t slen = __builtin_strlen(s); + if (__builtin_constant_p(slen) && (slen < bos)) { + return __builtin_strchr(s, c); + } +#endif /* !defined(__clang__) */ + + return __strchr_chk(s, c, bos); +} + +__BIONIC_FORTIFY_INLINE +char* strrchr(const char* _Nonnull s, int c) { + size_t bos = __bos(s); + +#if !defined(__clang__) + // Compiler doesn't know destination size. Don't call __strrchr_chk + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __builtin_strrchr(s, c); + } + + size_t slen = __builtin_strlen(s); + if (__builtin_constant_p(slen) && (slen < bos)) { + return __builtin_strrchr(s, c); + } +#endif /* !defined(__clang__) */ + + return __strrchr_chk(s, c, bos); +} +#endif /* __ANDROID_API__ >= __ANDROID_API_J_MR2__ */ + +#endif /* defined(__BIONIC_FORTIFY) */ + +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + +__END_DECLS + +#endif /* _STRING_H */ diff --git a/headers/strings.h b/headers/strings.h new file mode 100644 index 000000000..47070e51d --- /dev/null +++ b/headers/strings.h @@ -0,0 +1,65 @@ +/* $NetBSD: strings.h,v 1.10 2005/02/03 04:39:32 perry Exp $ */ + +/*- + * Copyright (c) 1998 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by Klaus Klein. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the NetBSD + * Foundation, Inc. and its contributors. + * 4. Neither the name of The NetBSD Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _STRINGS_H_ +#define _STRINGS_H_ + +#include <sys/types.h> +#include <sys/cdefs.h> +#include <xlocale.h> + +#include <bits/strcasecmp.h> + +__BEGIN_DECLS +#if defined(__BIONIC_FORTIFY) +#define bcopy(b1, b2, len) (void)(__builtin___memmove_chk((b2), (b1), (len), __bos0(b2))) +#define bzero(b, len) (void)(__builtin___memset_chk((b), '\0', (len), __bos0(b))) +#else +#define bcopy(b1, b2, len) (void)(__builtin_memmove((b2), (b1), (len))) +#define bzero(b, len) (void)(__builtin_memset((b), '\0', (len))) +#endif + + +#if (defined(__LP64__)) || (defined(__mips__)) || (defined(__arm__)) || (defined(__i386__) && __ANDROID_API__ >= 18) +int ffs(int) __INTRODUCED_IN_X86(18); +#endif /* (defined(__LP64__)) || (defined(__mips__)) || (defined(__arm__)) || (defined(__i386__) && __ANDROID_API__ >= 18) */ + + +__END_DECLS + +#endif /* !defined(_STRINGS_H_) */ diff --git a/headers/sys/_system_properties.h b/headers/sys/_system_properties.h new file mode 100644 index 000000000..ffa6d2e73 --- /dev/null +++ b/headers/sys/_system_properties.h @@ -0,0 +1,138 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _INCLUDE_SYS__SYSTEM_PROPERTIES_H +#define _INCLUDE_SYS__SYSTEM_PROPERTIES_H + +#include <sys/cdefs.h> + +#ifndef _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_ +#error you should #include <sys/system_properties.h> instead +#endif + +#include <sys/system_properties.h> + +__BEGIN_DECLS + +#define PROP_SERVICE_NAME "property_service" +#define PROP_FILENAME "/dev/__properties__" + +#define PROP_MSG_SETPROP 1 +#define PROP_MSG_SETPROP2 0x00020001 + +#define PROP_SUCCESS 0 +#define PROP_ERROR_READ_CMD 0x0004 +#define PROP_ERROR_READ_DATA 0x0008 +#define PROP_ERROR_READ_ONLY_PROPERTY 0x000B +#define PROP_ERROR_INVALID_NAME 0x0010 +#define PROP_ERROR_INVALID_VALUE 0x0014 +#define PROP_ERROR_PERMISSION_DENIED 0x0018 +#define PROP_ERROR_INVALID_CMD 0x001B +#define PROP_ERROR_HANDLE_CONTROL_MESSAGE 0x0020 +#define PROP_ERROR_SET_FAILED 0x0024 + +/* +** Map the property area from the specified filename. This +** method is for testing only. +*/ +int __system_property_set_filename(const char *filename); + +/* +** Initialize the area to be used to store properties. Can +** only be done by a single process that has write access to +** the property area. +*/ +int __system_property_area_init(); + +/* Read the global serial number of the system properties +** +** Called to predict if a series of cached __system_property_find +** objects will have seen __system_property_serial values change. +** But also aids the converse, as changes in the global serial can +** also be used to predict if a failed __system_property_find +** could in-turn now find a new object; thus preventing the +** cycles of effort to poll __system_property_find. +** +** Typically called at beginning of a cache cycle to signal if _any_ possible +** changes have occurred since last. If there is, one may check each individual +** __system_property_serial to confirm dirty, or __system_property_find +** to check if the property now exists. If a call to __system_property_add +** or __system_property_update has completed between two calls to +** __system_property_area_serial then the second call will return a larger +** value than the first call. Beware of race conditions as changes to the +** properties are not atomic, the main value of this call is to determine +** whether the expensive __system_property_find is worth retrying to see if +** a property now exists. +** +** Returns the serial number on success, -1 on error. +*/ +unsigned int __system_property_area_serial(); + +/* Add a new system property. Can only be done by a single +** process that has write access to the property area, and +** that process must handle sequencing to ensure the property +** does not already exist and that only one property is added +** or updated at a time. +** +** Returns 0 on success, -1 if the property area is full. +*/ +int __system_property_add(const char *name, unsigned int namelen, const char *value, unsigned int valuelen); + +/* Update the value of a system property returned by +** __system_property_find. Can only be done by a single process +** that has write access to the property area, and that process +** must handle sequencing to ensure that only one property is +** updated at a time. +** +** Returns 0 on success, -1 if the parameters are incorrect. +*/ +int __system_property_update(prop_info *pi, const char *value, unsigned int len); + +/* Read the serial number of a system property returned by +** __system_property_find. +** +** Returns the serial number on success, -1 on error. +*/ +unsigned int __system_property_serial(const prop_info *pi); + +/* Wait for any system property to be updated. Caller must pass +** in 0 the first time, and the previous return value on each +** successive call. */ +unsigned int __system_property_wait_any(unsigned int serial); + +/* Initialize the system properties area in read only mode. + * Should be done by all processes that need to read system + * properties. + * + * Returns 0 on success, -1 otherwise. + */ +int __system_properties_init(); + +__END_DECLS + +#endif diff --git a/headers/sys/auxv.h b/headers/sys/auxv.h new file mode 100644 index 000000000..0d2ea9033 --- /dev/null +++ b/headers/sys/auxv.h @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef _SYS_AUXV_H_ +#define _SYS_AUXV_H_ + +#include <linux/auxvec.h> +#include <sys/cdefs.h> + +__BEGIN_DECLS + + +#if __ANDROID_API__ >= 18 +unsigned long int getauxval(unsigned long int type) __INTRODUCED_IN(18); +#endif /* __ANDROID_API__ >= 18 */ + + +__END_DECLS + +#endif /* _SYS_AUXV_H_ */ diff --git a/headers/sys/cachectl.h b/headers/sys/cachectl.h new file mode 100644 index 000000000..5b20c1918 --- /dev/null +++ b/headers/sys/cachectl.h @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_CACHECTL_H +#define _SYS_CACHECTL_H 1 + +#include <sys/cdefs.h> +#ifdef __mips__ +#include <asm/cachectl.h> +#endif + +#endif /* sys/cachectl.h */ diff --git a/headers/sys/capability.h b/headers/sys/capability.h new file mode 100644 index 000000000..b9a40b3b4 --- /dev/null +++ b/headers/sys/capability.h @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _BIONIC_SYS_CAPABILITY_H +#define _BIONIC_SYS_CAPABILITY_H + +#include <sys/cdefs.h> +#include <linux/capability.h> + +__BEGIN_DECLS + +int capget(cap_user_header_t hdrp, cap_user_data_t datap); +int capset(cap_user_header_t hdrp, const cap_user_data_t datap); + +__END_DECLS + +#endif /* _BIONIC_SYS_CAPABILITY_H */ diff --git a/headers/sys/cdefs.h b/headers/sys/cdefs.h new file mode 100644 index 000000000..63e782efd --- /dev/null +++ b/headers/sys/cdefs.h @@ -0,0 +1,307 @@ +/* $NetBSD: cdefs.h,v 1.58 2004/12/11 05:59:00 christos Exp $ */ + +/* + * Copyright (c) 1991, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Berkeley Software Design, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)cdefs.h 8.8 (Berkeley) 1/9/95 + */ + +#ifndef _SYS_CDEFS_H_ +#define _SYS_CDEFS_H_ + +/* + * Testing against Clang-specific extensions. + */ +#ifndef __has_extension +#define __has_extension __has_feature +#endif +#ifndef __has_feature +#define __has_feature(x) 0 +#endif +#ifndef __has_include +#define __has_include(x) 0 +#endif +#ifndef __has_builtin +#define __has_builtin(x) 0 +#endif +#ifndef __has_attribute +#define __has_attribute(x) 0 +#endif + +#define __strong_alias(alias, sym) \ + __asm__(".global " #alias "\n" \ + #alias " = " #sym); + +#if defined(__cplusplus) +#define __BEGIN_DECLS extern "C" { +#define __END_DECLS } +#else +#define __BEGIN_DECLS +#define __END_DECLS +#endif + +#if defined(__cplusplus) +#define __BIONIC_CAST(_k,_t,_v) (_k<_t>(_v)) +#else +#define __BIONIC_CAST(_k,_t,_v) ((_t) (_v)) +#endif + +/* + * The __CONCAT macro is used to concatenate parts of symbol names, e.g. + * with "#define OLD(foo) __CONCAT(old,foo)", OLD(foo) produces oldfoo. + * The __CONCAT macro is a bit tricky -- make sure you don't put spaces + * in between its arguments. __CONCAT can also concatenate double-quoted + * strings produced by the __STRING macro, but this only works with ANSI C. + */ + +#define ___STRING(x) __STRING(x) +#define ___CONCAT(x,y) __CONCAT(x,y) + +#if defined(__STDC__) || defined(__cplusplus) +#define __P(protos) protos /* full-blown ANSI C */ +#define __CONCAT(x,y) x ## y +#define __STRING(x) #x + +#if defined(__cplusplus) +#define __inline inline /* convert to C++ keyword */ +#endif /* !__cplusplus */ + +#else /* !(__STDC__ || __cplusplus) */ +#define __P(protos) () /* traditional C preprocessor */ +#define __CONCAT(x,y) x/**/y +#define __STRING(x) "x" + +#endif /* !(__STDC__ || __cplusplus) */ + +#define __always_inline __attribute__((__always_inline__)) +#define __attribute_const__ __attribute__((__const__)) +#define __attribute_pure__ __attribute__((__pure__)) +#define __dead __attribute__((__noreturn__)) +#define __noreturn __attribute__((__noreturn__)) +#define __mallocfunc __attribute__((__malloc__)) +#define __packed __attribute__((__packed__)) +#define __unused __attribute__((__unused__)) +#define __used __attribute__((__used__)) + +/* + * _Nonnull is similar to the nonnull attribute in that it will instruct + * compilers to warn the user if it can prove that a null argument is being + * passed. Unlike the nonnull attribute, this annotation indicated that a value + * *should not* be null, not that it *cannot* be null, or even that the behavior + * is undefined. The important distinction is that the optimizer will perform + * surprising optimizations like the following: + * + * void foo(void*) __attribute__(nonnull, 1); + * + * int bar(int* p) { + * foo(p); + * + * // The following null check will be elided because nonnull attribute + * // means that, since we call foo with p, p can be assumed to not be + * // null. Thus this will crash if we are called with a null pointer. + * if (p != NULL) { + * return *p; + * } + * return 0; + * } + * + * int main() { + * return bar(NULL); + * } + * + * http://clang.llvm.org/docs/AttributeReference.html#nonnull + */ +#if !(defined(__clang__) && __has_feature(nullability)) +#define _Nonnull +#define _Nullable +#endif + +#define __printflike(x, y) __attribute__((__format__(printf, x, y))) +#define __scanflike(x, y) __attribute__((__format__(scanf, x, y))) + +/* + * GNU C version 2.96 added explicit branch prediction so that + * the CPU back-end can hint the processor and also so that + * code blocks can be reordered such that the predicted path + * sees a more linear flow, thus improving cache behavior, etc. + * + * The following two macros provide us with a way to use this + * compiler feature. Use __predict_true() if you expect the expression + * to evaluate to true, and __predict_false() if you expect the + * expression to evaluate to false. + * + * A few notes about usage: + * + * * Generally, __predict_false() error condition checks (unless + * you have some _strong_ reason to do otherwise, in which case + * document it), and/or __predict_true() `no-error' condition + * checks, assuming you want to optimize for the no-error case. + * + * * Other than that, if you don't know the likelihood of a test + * succeeding from empirical or other `hard' evidence, don't + * make predictions. + * + * * These are meant to be used in places that are run `a lot'. + * It is wasteful to make predictions in code that is run + * seldomly (e.g. at subsystem initialization time) as the + * basic block reordering that this affects can often generate + * larger code. + */ +#define __predict_true(exp) __builtin_expect((exp) != 0, 1) +#define __predict_false(exp) __builtin_expect((exp) != 0, 0) + +#define __wur __attribute__((__warn_unused_result__)) + +#ifdef __clang__ +#define __errorattr(msg) __attribute__((unavailable(msg))) +#else +#define __errorattr(msg) __attribute__((__error__(msg))) +#endif + +#define __errordecl(name, msg) extern void name(void) __errorattr(msg) + +/* + * Some BSD source needs these macros. + * Originally they embedded the rcs versions of each source file + * in the generated binary. We strip strings during build anyway,. + */ +#define __IDSTRING(_prefix,_s) /* nothing */ +#define __COPYRIGHT(_s) /* nothing */ +#define __FBSDID(_s) /* nothing */ +#define __RCSID(_s) /* nothing */ +#define __SCCSID(_s) /* nothing */ + +/* + * With bionic, you always get all C and POSIX API. + * + * If you want BSD and/or GNU extensions, _BSD_SOURCE and/or _GNU_SOURCE are + * expected to be defined by callers before *any* standard header file is + * included. + * + * In our header files we test against __USE_BSD and __USE_GNU. + */ +#if defined(_GNU_SOURCE) +# define __USE_BSD 1 +# define __USE_GNU 1 +#endif + +#if defined(_BSD_SOURCE) +# define __USE_BSD 1 +#endif + +/* _FILE_OFFSET_BITS 64 support. */ +#if !defined(__LP64__) && defined(_FILE_OFFSET_BITS) +#if _FILE_OFFSET_BITS == 64 +#define __USE_FILE_OFFSET64 1 +#endif +#endif + +#define __BIONIC__ 1 +#include <android/api-level.h> + +/* glibc compatibility. */ +#if defined(__LP64__) +#define __WORDSIZE 64 +#else +#define __WORDSIZE 32 +#endif + +/* + * When _FORTIFY_SOURCE is defined, automatic bounds checking is + * added to commonly used libc functions. If a buffer overrun is + * detected, the program is safely aborted. + * + * See + * http://gcc.gnu.org/onlinedocs/gcc/Object-Size-Checking.html for details. + */ +#if defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE > 0 && defined(__OPTIMIZE__) && __OPTIMIZE__ > 0 +# define __BIONIC_FORTIFY 1 +# if _FORTIFY_SOURCE == 2 +# define __bos(s) __builtin_object_size((s), 1) +# else +# define __bos(s) __builtin_object_size((s), 0) +# endif +# define __bos0(s) __builtin_object_size((s), 0) +# if defined(__clang__) +# define __BIONIC_FORTIFY_INLINE extern __inline__ __always_inline __attribute__((gnu_inline)) +# else +# define __BIONIC_FORTIFY_INLINE extern __inline__ __always_inline __attribute__((gnu_inline)) __attribute__((__artificial__)) +# endif +#endif +#define __BIONIC_FORTIFY_UNKNOWN_SIZE __BIONIC_CAST(static_cast, size_t, -1) + +/* Used to tag non-static symbols that are private and never exposed by the shared library. */ +#define __LIBC_HIDDEN__ __attribute__((visibility("hidden"))) + +/* + * Used to tag symbols that should be hidden for 64-bit, + * but visible to preserve binary compatibility for LP32. + */ +#ifdef __LP64__ +#define __LIBC32_LEGACY_PUBLIC__ __attribute__((visibility("hidden"))) +#else +#define __LIBC32_LEGACY_PUBLIC__ __attribute__((visibility("default"))) +#endif + +/* Used to rename functions so that the compiler emits a call to 'x' rather than the function this was applied to. */ +#define __RENAME(x) __asm__(#x) + +#include <android/versioning.h> + +#if __has_builtin(__builtin_umul_overflow) || __GNUC__ >= 5 +#if defined(__LP64__) +#define __size_mul_overflow(a, b, result) __builtin_umull_overflow(a, b, result) +#else +#define __size_mul_overflow(a, b, result) __builtin_umul_overflow(a, b, result) +#endif +#else +extern __inline__ __always_inline __attribute__((gnu_inline)) +int __size_mul_overflow(__SIZE_TYPE__ a, __SIZE_TYPE__ b, __SIZE_TYPE__ *result) { + *result = a * b; + static const __SIZE_TYPE__ mul_no_overflow = 1UL << (sizeof(__SIZE_TYPE__) * 4); + return (a >= mul_no_overflow || b >= mul_no_overflow) && a > 0 && (__SIZE_TYPE__)-1 / a < b; +} +#endif + +/* + * TODO(danalbert): Remove this once we've moved entirely off prebuilts/ndk. + * + * The NDK used to have a __NDK_FPABI__ that was defined to empty for most cases + * but `__attribute__((pcs("aapcs")))` for the now defunct armeabi-v7a-hard ABI. + * + * During the transition from prebuilts/ndk to ndk_headers, we'll have some + * headers that still use __NDK_FPABI__ while the libc headers have stopped + * defining it. In the interim, just provide an empty definition to keep the + * build working. + */ +#define __NDK_FPABI__ + +#endif /* !_SYS_CDEFS_H_ */ diff --git a/headers/sys/endian.h b/headers/sys/endian.h new file mode 100644 index 000000000..e8b7022c7 --- /dev/null +++ b/headers/sys/endian.h @@ -0,0 +1,110 @@ +/*- + * Copyright (c) 1997 Niklas Hallqvist. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _SYS_ENDIAN_H_ +#define _SYS_ENDIAN_H_ + +#include <sys/cdefs.h> + +#include <stdint.h> + +#define _LITTLE_ENDIAN 1234 +#define _BIG_ENDIAN 4321 +#define _PDP_ENDIAN 3412 +#define _BYTE_ORDER _LITTLE_ENDIAN +#define __LITTLE_ENDIAN_BITFIELD + +#ifndef __LITTLE_ENDIAN +#define __LITTLE_ENDIAN _LITTLE_ENDIAN +#endif +#ifndef __BIG_ENDIAN +#define __BIG_ENDIAN _BIG_ENDIAN +#endif +#define __BYTE_ORDER _BYTE_ORDER + +#define __swap16 __builtin_bswap16 +#define __swap32 __builtin_bswap32 +#define __swap64 __builtin_bswap64 + +/* glibc compatibility. */ +__BEGIN_DECLS + +#if __ANDROID_API__ >= 21 +uint32_t htonl(uint32_t) __attribute_const__ __INTRODUCED_IN(21); +uint16_t htons(uint16_t) __attribute_const__ __INTRODUCED_IN(21); +uint32_t ntohl(uint32_t) __attribute_const__ __INTRODUCED_IN(21); +uint16_t ntohs(uint16_t) __attribute_const__ __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +__END_DECLS + +#define htonl(x) __swap32(x) +#define htons(x) __swap16(x) +#define ntohl(x) __swap32(x) +#define ntohs(x) __swap16(x) + +/* Bionic additions */ +#define htonq(x) __swap64(x) +#define ntohq(x) __swap64(x) + +#if defined(__USE_BSD) || defined(__BIONIC__) /* Historically bionic exposed these. */ +#define LITTLE_ENDIAN _LITTLE_ENDIAN +#define BIG_ENDIAN _BIG_ENDIAN +#define PDP_ENDIAN _PDP_ENDIAN +#define BYTE_ORDER _BYTE_ORDER + +#define NTOHL(x) (x) = ntohl((u_int32_t)(x)) +#define NTOHS(x) (x) = ntohs((u_int16_t)(x)) +#define HTONL(x) (x) = htonl((u_int32_t)(x)) +#define HTONS(x) (x) = htons((u_int16_t)(x)) + +#define htobe16 __swap16 +#define htobe32 __swap32 +#define htobe64 __swap64 +#define betoh16 __swap16 +#define betoh32 __swap32 +#define betoh64 __swap64 + +#define htole16(x) (x) +#define htole32(x) (x) +#define htole64(x) (x) +#define letoh16(x) (x) +#define letoh32(x) (x) +#define letoh64(x) (x) + +/* + * glibc-compatible beXXtoh/leXXtoh synonyms for htobeXX/htoleXX. + * The BSDs export both sets of names, bionic historically only + * exported the ones above (or on the rhs here), and glibc only + * exports these names (on the lhs). + */ +#define be16toh(x) htobe16(x) +#define be32toh(x) htobe32(x) +#define be64toh(x) htobe64(x) +#define le16toh(x) htole16(x) +#define le32toh(x) htole32(x) +#define le64toh(x) htole64(x) +#endif /* __USE_BSD */ + +#endif /* _SYS_ENDIAN_H_ */ diff --git a/headers/sys/epoll.h b/headers/sys/epoll.h new file mode 100644 index 000000000..a11d286cb --- /dev/null +++ b/headers/sys/epoll.h @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_EPOLL_H_ +#define _SYS_EPOLL_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <fcntl.h> /* For O_CLOEXEC. */ +#include <signal.h> /* For sigset_t. */ + +__BEGIN_DECLS + +#define EPOLLIN 0x00000001 +#define EPOLLPRI 0x00000002 +#define EPOLLOUT 0x00000004 +#define EPOLLERR 0x00000008 +#define EPOLLHUP 0x00000010 +#define EPOLLRDNORM 0x00000040 +#define EPOLLRDBAND 0x00000080 +#define EPOLLWRNORM 0x00000100 +#define EPOLLWRBAND 0x00000200 +#define EPOLLMSG 0x00000400 +#define EPOLLRDHUP 0x00002000 +#define EPOLLWAKEUP 0x20000000 +#define EPOLLONESHOT 0x40000000 +#define EPOLLET 0x80000000 + +#define EPOLL_CTL_ADD 1 +#define EPOLL_CTL_DEL 2 +#define EPOLL_CTL_MOD 3 + +#define EPOLL_CLOEXEC O_CLOEXEC + +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; +} +#ifdef __x86_64__ +__packed +#endif +; + +int epoll_create(int); + +#if __ANDROID_API__ >= 21 +int epoll_create1(int) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int epoll_ctl(int, int, int, struct epoll_event*); +int epoll_wait(int, struct epoll_event*, int, int); + +#if __ANDROID_API__ >= 21 +int epoll_pwait(int, struct epoll_event*, int, int, const sigset_t*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +__END_DECLS + +#endif /* _SYS_EPOLL_H_ */ diff --git a/headers/sys/errno.h b/headers/sys/errno.h new file mode 100644 index 000000000..339f4fc10 --- /dev/null +++ b/headers/sys/errno.h @@ -0,0 +1 @@ +#include <errno.h> diff --git a/headers/sys/eventfd.h b/headers/sys/eventfd.h new file mode 100644 index 000000000..6b9749a11 --- /dev/null +++ b/headers/sys/eventfd.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_EVENTFD_H +#define _SYS_EVENTFD_H + +#include <sys/cdefs.h> +#include <fcntl.h> + +__BEGIN_DECLS + +#define EFD_CLOEXEC O_CLOEXEC +#define EFD_NONBLOCK O_NONBLOCK + +/* type of event counter */ +typedef uint64_t eventfd_t; + +int eventfd(unsigned int initial_value, int flags); + +int eventfd_read(int fd, eventfd_t* value); +int eventfd_write(int fd, eventfd_t value); + +__END_DECLS + +#endif /* _SYS_EVENTFD_H */ diff --git a/headers/sys/fcntl.h b/headers/sys/fcntl.h new file mode 100644 index 000000000..cd304557e --- /dev/null +++ b/headers/sys/fcntl.h @@ -0,0 +1 @@ +#include <fcntl.h> diff --git a/headers/sys/file.h b/headers/sys/file.h new file mode 100644 index 000000000..f414d34aa --- /dev/null +++ b/headers/sys/file.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_FILE_H_ +#define _SYS_FILE_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +#include <fcntl.h> + +__BEGIN_DECLS + +int flock(int, int); + +__END_DECLS + +#endif /* _SYS_FILE_H_ */ diff --git a/headers/sys/fsuid.h b/headers/sys/fsuid.h new file mode 100644 index 000000000..1e6cf6cc4 --- /dev/null +++ b/headers/sys/fsuid.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_FSUID_H_ +#define _SYS_FSUID_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +__BEGIN_DECLS + + +#if __ANDROID_API__ >= 21 +int setfsuid(uid_t) __INTRODUCED_IN(21); +int setfsgid(gid_t) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +__END_DECLS + +#endif /* _SYS_FSUID_H_ */ diff --git a/headers/sys/inotify.h b/headers/sys/inotify.h new file mode 100644 index 000000000..4a1e2691a --- /dev/null +++ b/headers/sys/inotify.h @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_INOTIFY_H_ +#define _SYS_INOTIFY_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <stdint.h> +#include <linux/inotify.h> +#include <asm/fcntl.h> /* For O_CLOEXEC and O_NONBLOCK. */ + +__BEGIN_DECLS + +#define IN_CLOEXEC O_CLOEXEC +#define IN_NONBLOCK O_NONBLOCK + +int inotify_init(void); + +#if __ANDROID_API__ >= 21 +int inotify_init1(int) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int inotify_add_watch(int, const char*, uint32_t); +int inotify_rm_watch(int, uint32_t); + +__END_DECLS + +#endif /* _SYS_INOTIFY_H_ */ diff --git a/headers/sys/ioctl.h b/headers/sys/ioctl.h new file mode 100644 index 000000000..efbcb0c5a --- /dev/null +++ b/headers/sys/ioctl.h @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef _SYS_IOCTL_H_ +#define _SYS_IOCTL_H_ + +#include <sys/cdefs.h> +#include <linux/ioctl.h> +/* + * NetBSD and glibc's <sys/ioctl.h> provide some of the + * terminal-related ioctl data structures such as struct winsize. + */ +#include <linux/termios.h> +#include <asm/ioctls.h> +#include <asm/termbits.h> +#include <linux/tty.h> + +#include <bits/ioctl.h> + +#endif /* _SYS_IOCTL_H_ */ diff --git a/headers/sys/ipc.h b/headers/sys/ipc.h new file mode 100644 index 000000000..3d6c45f60 --- /dev/null +++ b/headers/sys/ipc.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_IPC_H +#define _SYS_IPC_H + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <linux/ipc.h> + +#if defined(__USE_GNU) +#define __key key +#define __seq seq +#endif + +#define ipc_perm ipc64_perm + +__BEGIN_DECLS + +key_t ftok(const char* path, int id); + +__END_DECLS + +#endif /* _SYS_IPC_H */ diff --git a/headers/sys/klog.h b/headers/sys/klog.h new file mode 100644 index 000000000..47eb3a4cf --- /dev/null +++ b/headers/sys/klog.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_KLOG_H_ +#define _SYS_KLOG_H_ + +#include <sys/cdefs.h> + +__BEGIN_DECLS + +/* These correspond to the kernel's SYSLOG_ACTION_whatever constants. */ +#define KLOG_CLOSE 0 +#define KLOG_OPEN 1 +#define KLOG_READ 2 +#define KLOG_READ_ALL 3 +#define KLOG_READ_CLEAR 4 +#define KLOG_CLEAR 5 +#define KLOG_CONSOLE_OFF 6 +#define KLOG_CONSOLE_ON 7 +#define KLOG_CONSOLE_LEVEL 8 +#define KLOG_SIZE_UNREAD 9 +#define KLOG_SIZE_BUFFER 10 + +int klogctl(int, char *, int); + +__END_DECLS + +#endif /* _SYS_KLOG_H_ */ diff --git a/headers/sys/limits.h b/headers/sys/limits.h new file mode 100644 index 000000000..1e189a16e --- /dev/null +++ b/headers/sys/limits.h @@ -0,0 +1 @@ +#include <limits.h> diff --git a/headers/sys/mman.h b/headers/sys/mman.h new file mode 100644 index 000000000..36aff7a13 --- /dev/null +++ b/headers/sys/mman.h @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef _SYS_MMAN_H_ +#define _SYS_MMAN_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <asm/mman.h> + +__BEGIN_DECLS + +#ifndef MAP_ANON +#define MAP_ANON MAP_ANONYMOUS +#endif + +#define MAP_FAILED __BIONIC_CAST(reinterpret_cast, void*, -1) + +#define MREMAP_MAYMOVE 1 +#define MREMAP_FIXED 2 + +#define POSIX_MADV_NORMAL MADV_NORMAL +#define POSIX_MADV_RANDOM MADV_RANDOM +#define POSIX_MADV_SEQUENTIAL MADV_SEQUENTIAL +#define POSIX_MADV_WILLNEED MADV_WILLNEED +#define POSIX_MADV_DONTNEED MADV_DONTNEED + +#if defined(__USE_FILE_OFFSET64) + +#if __ANDROID_API__ >= 21 +void* mmap(void*, size_t, int, int, int, off_t) __RENAME(mmap64) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +#else +void* mmap(void*, size_t, int, int, int, off_t); +#endif + +#if __ANDROID_API__ >= 21 +void* mmap64(void*, size_t, int, int, int, off64_t) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +int munmap(void*, size_t); +int msync(void*, size_t, int); +int mprotect(void*, size_t, int); +void* mremap(void*, size_t, size_t, int, ...); + + +#if __ANDROID_API__ >= 17 +int mlockall(int) __INTRODUCED_IN(17); +int munlockall(void) __INTRODUCED_IN(17); +#endif /* __ANDROID_API__ >= 17 */ + +int mlock(const void*, size_t); +int munlock(const void*, size_t); + +int mincore(void*, size_t, unsigned char*); + +int madvise(void*, size_t, int); + +#if __ANDROID_API__ >= 23 +int posix_madvise(void*, size_t, int) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +__END_DECLS + +#endif /* _SYS_MMAN_H_ */ diff --git a/headers/sys/mount.h b/headers/sys/mount.h new file mode 100644 index 000000000..26c0e0f5b --- /dev/null +++ b/headers/sys/mount.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_MOUNT_H +#define _SYS_MOUNT_H + +#include <sys/cdefs.h> +#include <sys/ioctl.h> +#include <linux/fs.h> + +__BEGIN_DECLS + +/* umount2 flags. */ +#define MNT_FORCE 1 +#define MNT_DETACH 2 +#define MNT_EXPIRE 4 +#define UMOUNT_NOFOLLOW 8 + +int mount(const char*, const char*, const char*, unsigned long, const void*); +int umount(const char*); +int umount2(const char*, int); + +__END_DECLS + +#endif /* _SYS_MOUNT_H */ diff --git a/headers/sys/msg.h b/headers/sys/msg.h new file mode 100644 index 000000000..341c0b0f2 --- /dev/null +++ b/headers/sys/msg.h @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_MSG_H_ +#define _SYS_MSG_H_ + +#include <sys/cdefs.h> +#include <sys/ipc.h> + +#include <linux/msg.h> + +#define msqid_ds msqid64_ds + +__BEGIN_DECLS + +typedef __kernel_ulong_t msgqnum_t; +typedef __kernel_ulong_t msglen_t; + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +int msgctl(int, int, struct msqid_ds*) __INTRODUCED_IN_FUTURE; +int msgget(key_t, int) __INTRODUCED_IN_FUTURE; +ssize_t msgrcv(int, void*, size_t, long, int) __INTRODUCED_IN_FUTURE; +int msgsnd(int, const void*, size_t, int) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + +__END_DECLS + +#endif /* _SYS_MSG_H_ */ diff --git a/headers/sys/param.h b/headers/sys/param.h new file mode 100644 index 000000000..d3686e096 --- /dev/null +++ b/headers/sys/param.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_PARAM_H_ +#define _SYS_PARAM_H_ + +#include <limits.h> +#include <linux/param.h> +#include <sys/cdefs.h> + +#define DEV_BSIZE 512 + +#define MAXPATHLEN PATH_MAX +#define MAXSYMLINKS 8 + +/* Macros for counting and rounding. */ +#ifndef howmany +#define howmany(x, y) (((x)+((y)-1))/(y)) +#endif +#define roundup(x, y) ((((x)+((y)-1))/(y))*(y)) +#define powerof2(x) ((((x)-1)&(x))==0) + +/* Macros for min/max. */ +#define MIN(a,b) (((a)<(b))?(a):(b)) +#define MAX(a,b) (((a)>(b))?(a):(b)) + +#endif /* _SYS_PARAM_H_ */ diff --git a/headers/sys/personality.h b/headers/sys/personality.h new file mode 100644 index 000000000..84520866d --- /dev/null +++ b/headers/sys/personality.h @@ -0,0 +1,45 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_PERSONALITY_H_ +#define _SYS_PERSONALITY_H_ + +#include <sys/cdefs.h> +#include <linux/personality.h> + +__BEGIN_DECLS + + +#if __ANDROID_API__ >= 15 +int personality(unsigned int persona) __INTRODUCED_IN(15); +#endif /* __ANDROID_API__ >= 15 */ + + +__END_DECLS + +#endif /* _SYS_PERSONALITY_H_ */ diff --git a/headers/sys/poll.h b/headers/sys/poll.h new file mode 100644 index 000000000..779ec774f --- /dev/null +++ b/headers/sys/poll.h @@ -0,0 +1 @@ +#include <poll.h> diff --git a/headers/sys/prctl.h b/headers/sys/prctl.h new file mode 100644 index 000000000..742ed57af --- /dev/null +++ b/headers/sys/prctl.h @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_PRCTL_H +#define _SYS_PRCTL_H + +#include <sys/cdefs.h> + +#include <linux/prctl.h> + +__BEGIN_DECLS + +int prctl(int option, ...); + +__END_DECLS + +#endif /* _SYS_PRCTL_H */ diff --git a/headers/sys/procfs.h b/headers/sys/procfs.h new file mode 100644 index 000000000..7ef5023ab --- /dev/null +++ b/headers/sys/procfs.h @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_PROCFS_H_ +#define _SYS_PROCFS_H_ + +#include <sys/cdefs.h> +#include <sys/ucontext.h> + +__BEGIN_DECLS + +typedef unsigned long elf_greg_t; +typedef elf_greg_t elf_gregset_t[NGREG]; + +typedef fpregset_t elf_fpregset_t; + +#if defined(__i386__) +typedef struct user_fpxregs_struct elf_fpxregset_t; +#endif + +typedef elf_gregset_t prgregset_t; +typedef elf_fpregset_t prfpregset_t; + +typedef pid_t lwpid_t; +typedef void* psaddr_t; + +__END_DECLS + +#endif /* _SYS_PROCFS_H_ */ diff --git a/headers/sys/ptrace.h b/headers/sys/ptrace.h new file mode 100644 index 000000000..4b881e743 --- /dev/null +++ b/headers/sys/ptrace.h @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef _SYS_PTRACE_H_ +#define _SYS_PTRACE_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <linux/ptrace.h> + +__BEGIN_DECLS + +/* glibc uses different PTRACE_ names from the kernel for these two... */ +#define PTRACE_POKEUSER PTRACE_POKEUSR +#define PTRACE_PEEKUSER PTRACE_PEEKUSR + +/* glibc exports a different set of PT_ names too... */ +#define PT_TRACE_ME PTRACE_TRACEME +#define PT_READ_I PTRACE_PEEKTEXT +#define PT_READ_D PTRACE_PEEKDATA +#define PT_READ_U PTRACE_PEEKUSR +#define PT_WRITE_I PTRACE_POKETEXT +#define PT_WRITE_D PTRACE_POKEDATA +#define PT_WRITE_U PTRACE_POKEUSR +#define PT_CONT PTRACE_CONT +#define PT_KILL PTRACE_KILL +#define PT_STEP PTRACE_SINGLESTEP +#define PT_GETFPREGS PTRACE_GETFPREGS +#define PT_ATTACH PTRACE_ATTACH +#define PT_DETACH PTRACE_DETACH +#define PT_SYSCALL PTRACE_SYSCALL +#define PT_SETOPTIONS PTRACE_SETOPTIONS +#define PT_GETEVENTMSG PTRACE_GETEVENTMSG +#define PT_GETSIGINFO PTRACE_GETSIGINFO +#define PT_SETSIGINFO PTRACE_SETSIGINFO + +long ptrace(int, ...); + +__END_DECLS + +#endif /* _SYS_PTRACE_H_ */ diff --git a/headers/sys/queue.h b/headers/sys/queue.h new file mode 100644 index 000000000..089083850 --- /dev/null +++ b/headers/sys/queue.h @@ -0,0 +1,559 @@ +/* + * Copyright (c) 1991, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)queue.h 8.5 (Berkeley) 8/20/94 + */ + +#ifndef _SYS_QUEUE_H_ +#define _SYS_QUEUE_H_ + +#include <sys/cdefs.h> + +/* + * This file defines five types of data structures: singly-linked lists, + * lists, simple queues, tail queues, and circular queues. + * + * A singly-linked list is headed by a single forward pointer. The + * elements are singly linked for minimum space and pointer manipulation + * overhead at the expense of O(n) removal for arbitrary elements. New + * elements can be added to the list after an existing element or at the + * head of the list. Elements being removed from the head of the list + * should use the explicit macro for this purpose for optimum + * efficiency. A singly-linked list may only be traversed in the forward + * direction. Singly-linked lists are ideal for applications with large + * datasets and few or no removals or for implementing a LIFO queue. + * + * A list is headed by a single forward pointer (or an array of forward + * pointers for a hash table header). The elements are doubly linked + * so that an arbitrary element can be removed without a need to + * traverse the list. New elements can be added to the list before + * or after an existing element or at the head of the list. A list + * may only be traversed in the forward direction. + * + * A simple queue is headed by a pair of pointers, one the head of the + * list and the other to the tail of the list. The elements are singly + * linked to save space, so elements can only be removed from the + * head of the list. New elements can be added to the list after + * an existing element, at the head of the list, or at the end of the + * list. A simple queue may only be traversed in the forward direction. + * + * A tail queue is headed by a pair of pointers, one to the head of the + * list and the other to the tail of the list. The elements are doubly + * linked so that an arbitrary element can be removed without a need to + * traverse the list. New elements can be added to the list before or + * after an existing element, at the head of the list, or at the end of + * the list. A tail queue may be traversed in either direction. + * + * A circle queue is headed by a pair of pointers, one to the head of the + * list and the other to the tail of the list. The elements are doubly + * linked so that an arbitrary element can be removed without a need to + * traverse the list. New elements can be added to the list before or after + * an existing element, at the head of the list, or at the end of the list. + * A circle queue may be traversed in either direction, but has a more + * complex end of list detection. + * + * For details on the use of these macros, see the queue(3) manual page. + */ + +/* + * List definitions. + */ +#define LIST_HEAD(name, type) \ +struct name { \ + struct type *lh_first; /* first element */ \ +} + +#define LIST_HEAD_INITIALIZER(head) \ + { NULL } + +#define LIST_ENTRY(type) \ +struct { \ + struct type *le_next; /* next element */ \ + struct type **le_prev; /* address of previous next element */ \ +} + +/* + * List functions. + */ +#define LIST_INIT(head) do { \ + (head)->lh_first = NULL; \ +} while (/*CONSTCOND*/0) + +#define LIST_INSERT_AFTER(listelm, elm, field) do { \ + if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \ + (listelm)->field.le_next->field.le_prev = \ + &(elm)->field.le_next; \ + (listelm)->field.le_next = (elm); \ + (elm)->field.le_prev = &(listelm)->field.le_next; \ +} while (/*CONSTCOND*/0) + +#define LIST_INSERT_BEFORE(listelm, elm, field) do { \ + (elm)->field.le_prev = (listelm)->field.le_prev; \ + (elm)->field.le_next = (listelm); \ + *(listelm)->field.le_prev = (elm); \ + (listelm)->field.le_prev = &(elm)->field.le_next; \ +} while (/*CONSTCOND*/0) + +#define LIST_INSERT_HEAD(head, elm, field) do { \ + if (((elm)->field.le_next = (head)->lh_first) != NULL) \ + (head)->lh_first->field.le_prev = &(elm)->field.le_next;\ + (head)->lh_first = (elm); \ + (elm)->field.le_prev = &(head)->lh_first; \ +} while (/*CONSTCOND*/0) + +#define LIST_REMOVE(elm, field) do { \ + if ((elm)->field.le_next != NULL) \ + (elm)->field.le_next->field.le_prev = \ + (elm)->field.le_prev; \ + *(elm)->field.le_prev = (elm)->field.le_next; \ +} while (/*CONSTCOND*/0) + +#define LIST_FOREACH(var, head, field) \ + for ((var) = ((head)->lh_first); \ + (var); \ + (var) = ((var)->field.le_next)) + +/* + * List access methods. + */ +#define LIST_EMPTY(head) ((head)->lh_first == NULL) +#define LIST_FIRST(head) ((head)->lh_first) +#define LIST_NEXT(elm, field) ((elm)->field.le_next) + + +/* + * Singly-linked List definitions. + */ +#define SLIST_HEAD(name, type) \ +struct name { \ + struct type *slh_first; /* first element */ \ +} + +#define SLIST_HEAD_INITIALIZER(head) \ + { NULL } + +#define SLIST_ENTRY(type) \ +struct { \ + struct type *sle_next; /* next element */ \ +} + +/* + * Singly-linked List functions. + */ +#define SLIST_INIT(head) do { \ + (head)->slh_first = NULL; \ +} while (/*CONSTCOND*/0) + +#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \ + (elm)->field.sle_next = (slistelm)->field.sle_next; \ + (slistelm)->field.sle_next = (elm); \ +} while (/*CONSTCOND*/0) + +#define SLIST_INSERT_HEAD(head, elm, field) do { \ + (elm)->field.sle_next = (head)->slh_first; \ + (head)->slh_first = (elm); \ +} while (/*CONSTCOND*/0) + +#define SLIST_REMOVE_HEAD(head, field) do { \ + (head)->slh_first = (head)->slh_first->field.sle_next; \ +} while (/*CONSTCOND*/0) + +#define SLIST_REMOVE(head, elm, type, field) do { \ + if ((head)->slh_first == (elm)) { \ + SLIST_REMOVE_HEAD((head), field); \ + } \ + else { \ + struct type *curelm = (head)->slh_first; \ + while(curelm->field.sle_next != (elm)) \ + curelm = curelm->field.sle_next; \ + curelm->field.sle_next = \ + curelm->field.sle_next->field.sle_next; \ + } \ +} while (/*CONSTCOND*/0) + +#define SLIST_FOREACH(var, head, field) \ + for((var) = (head)->slh_first; (var); (var) = (var)->field.sle_next) + +/* + * Singly-linked List access methods. + */ +#define SLIST_EMPTY(head) ((head)->slh_first == NULL) +#define SLIST_FIRST(head) ((head)->slh_first) +#define SLIST_NEXT(elm, field) ((elm)->field.sle_next) + + +/* + * Singly-linked Tail queue declarations. + */ +#define STAILQ_HEAD(name, type) \ +struct name { \ + struct type *stqh_first; /* first element */ \ + struct type **stqh_last; /* addr of last next element */ \ +} + +#define STAILQ_HEAD_INITIALIZER(head) \ + { NULL, &(head).stqh_first } + +#define STAILQ_ENTRY(type) \ +struct { \ + struct type *stqe_next; /* next element */ \ +} + +/* + * Singly-linked Tail queue functions. + */ +#define STAILQ_INIT(head) do { \ + (head)->stqh_first = NULL; \ + (head)->stqh_last = &(head)->stqh_first; \ +} while (/*CONSTCOND*/0) + +#define STAILQ_INSERT_HEAD(head, elm, field) do { \ + if (((elm)->field.stqe_next = (head)->stqh_first) == NULL) \ + (head)->stqh_last = &(elm)->field.stqe_next; \ + (head)->stqh_first = (elm); \ +} while (/*CONSTCOND*/0) + +#define STAILQ_INSERT_TAIL(head, elm, field) do { \ + (elm)->field.stqe_next = NULL; \ + *(head)->stqh_last = (elm); \ + (head)->stqh_last = &(elm)->field.stqe_next; \ +} while (/*CONSTCOND*/0) + +#define STAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ + if (((elm)->field.stqe_next = (listelm)->field.stqe_next) == NULL)\ + (head)->stqh_last = &(elm)->field.stqe_next; \ + (listelm)->field.stqe_next = (elm); \ +} while (/*CONSTCOND*/0) + +#define STAILQ_REMOVE_HEAD(head, field) do { \ + if (((head)->stqh_first = (head)->stqh_first->field.stqe_next) == NULL) \ + (head)->stqh_last = &(head)->stqh_first; \ +} while (/*CONSTCOND*/0) + +#define STAILQ_REMOVE(head, elm, type, field) do { \ + if ((head)->stqh_first == (elm)) { \ + STAILQ_REMOVE_HEAD((head), field); \ + } else { \ + struct type *curelm = (head)->stqh_first; \ + while (curelm->field.stqe_next != (elm)) \ + curelm = curelm->field.stqe_next; \ + if ((curelm->field.stqe_next = \ + curelm->field.stqe_next->field.stqe_next) == NULL) \ + (head)->stqh_last = &(curelm)->field.stqe_next; \ + } \ +} while (/*CONSTCOND*/0) + +#define STAILQ_FOREACH(var, head, field) \ + for ((var) = ((head)->stqh_first); \ + (var); \ + (var) = ((var)->field.stqe_next)) + +/* + * Singly-linked Tail queue access methods. + */ +#define STAILQ_EMPTY(head) ((head)->stqh_first == NULL) +#define STAILQ_FIRST(head) ((head)->stqh_first) +#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next) + + +/* + * Simple queue definitions. + */ +#define SIMPLEQ_HEAD(name, type) \ +struct name { \ + struct type *sqh_first; /* first element */ \ + struct type **sqh_last; /* addr of last next element */ \ +} + +#define SIMPLEQ_HEAD_INITIALIZER(head) \ + { NULL, &(head).sqh_first } + +#define SIMPLEQ_ENTRY(type) \ +struct { \ + struct type *sqe_next; /* next element */ \ +} + +/* + * Simple queue functions. + */ +#define SIMPLEQ_INIT(head) do { \ + (head)->sqh_first = NULL; \ + (head)->sqh_last = &(head)->sqh_first; \ +} while (/*CONSTCOND*/0) + +#define SIMPLEQ_INSERT_HEAD(head, elm, field) do { \ + if (((elm)->field.sqe_next = (head)->sqh_first) == NULL) \ + (head)->sqh_last = &(elm)->field.sqe_next; \ + (head)->sqh_first = (elm); \ +} while (/*CONSTCOND*/0) + +#define SIMPLEQ_INSERT_TAIL(head, elm, field) do { \ + (elm)->field.sqe_next = NULL; \ + *(head)->sqh_last = (elm); \ + (head)->sqh_last = &(elm)->field.sqe_next; \ +} while (/*CONSTCOND*/0) + +#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ + if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\ + (head)->sqh_last = &(elm)->field.sqe_next; \ + (listelm)->field.sqe_next = (elm); \ +} while (/*CONSTCOND*/0) + +#define SIMPLEQ_REMOVE_HEAD(head, field) do { \ + if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \ + (head)->sqh_last = &(head)->sqh_first; \ +} while (/*CONSTCOND*/0) + +#define SIMPLEQ_REMOVE(head, elm, type, field) do { \ + if ((head)->sqh_first == (elm)) { \ + SIMPLEQ_REMOVE_HEAD((head), field); \ + } else { \ + struct type *curelm = (head)->sqh_first; \ + while (curelm->field.sqe_next != (elm)) \ + curelm = curelm->field.sqe_next; \ + if ((curelm->field.sqe_next = \ + curelm->field.sqe_next->field.sqe_next) == NULL) \ + (head)->sqh_last = &(curelm)->field.sqe_next; \ + } \ +} while (/*CONSTCOND*/0) + +#define SIMPLEQ_FOREACH(var, head, field) \ + for ((var) = ((head)->sqh_first); \ + (var); \ + (var) = ((var)->field.sqe_next)) + +/* + * Simple queue access methods. + */ +#define SIMPLEQ_EMPTY(head) ((head)->sqh_first == NULL) +#define SIMPLEQ_FIRST(head) ((head)->sqh_first) +#define SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next) + + +/* + * Tail queue definitions. + */ +#define _TAILQ_HEAD(name, type, qual) \ +struct name { \ + qual type *tqh_first; /* first element */ \ + qual type *qual *tqh_last; /* addr of last next element */ \ +} +#define TAILQ_HEAD(name, type) _TAILQ_HEAD(name, struct type,) + +#define TAILQ_HEAD_INITIALIZER(head) \ + { NULL, &(head).tqh_first } + +#define _TAILQ_ENTRY(type, qual) \ +struct { \ + qual type *tqe_next; /* next element */ \ + qual type *qual *tqe_prev; /* address of previous next element */\ +} +#define TAILQ_ENTRY(type) _TAILQ_ENTRY(struct type,) + +/* + * Tail queue functions. + */ +#define TAILQ_INIT(head) do { \ + (head)->tqh_first = NULL; \ + (head)->tqh_last = &(head)->tqh_first; \ +} while (/*CONSTCOND*/0) + +#define TAILQ_INSERT_HEAD(head, elm, field) do { \ + if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \ + (head)->tqh_first->field.tqe_prev = \ + &(elm)->field.tqe_next; \ + else \ + (head)->tqh_last = &(elm)->field.tqe_next; \ + (head)->tqh_first = (elm); \ + (elm)->field.tqe_prev = &(head)->tqh_first; \ +} while (/*CONSTCOND*/0) + +#define TAILQ_INSERT_TAIL(head, elm, field) do { \ + (elm)->field.tqe_next = NULL; \ + (elm)->field.tqe_prev = (head)->tqh_last; \ + *(head)->tqh_last = (elm); \ + (head)->tqh_last = &(elm)->field.tqe_next; \ +} while (/*CONSTCOND*/0) + +#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ + if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\ + (elm)->field.tqe_next->field.tqe_prev = \ + &(elm)->field.tqe_next; \ + else \ + (head)->tqh_last = &(elm)->field.tqe_next; \ + (listelm)->field.tqe_next = (elm); \ + (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \ +} while (/*CONSTCOND*/0) + +#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ + (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ + (elm)->field.tqe_next = (listelm); \ + *(listelm)->field.tqe_prev = (elm); \ + (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \ +} while (/*CONSTCOND*/0) + +#define TAILQ_REMOVE(head, elm, field) do { \ + if (((elm)->field.tqe_next) != NULL) \ + (elm)->field.tqe_next->field.tqe_prev = \ + (elm)->field.tqe_prev; \ + else \ + (head)->tqh_last = (elm)->field.tqe_prev; \ + *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ +} while (/*CONSTCOND*/0) + +#define TAILQ_FOREACH(var, head, field) \ + for ((var) = ((head)->tqh_first); \ + (var); \ + (var) = ((var)->field.tqe_next)) + +#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ + for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last)); \ + (var); \ + (var) = (*(((struct headname *)((var)->field.tqe_prev))->tqh_last))) + +/* + * Tail queue access methods. + */ +#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL) +#define TAILQ_FIRST(head) ((head)->tqh_first) +#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) + +#define TAILQ_LAST(head, headname) \ + (*(((struct headname *)((head)->tqh_last))->tqh_last)) +#define TAILQ_PREV(elm, headname, field) \ + (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) + + +/* + * Circular queue definitions. + */ +#define CIRCLEQ_HEAD(name, type) \ +struct name { \ + struct type *cqh_first; /* first element */ \ + struct type *cqh_last; /* last element */ \ +} + +#define CIRCLEQ_HEAD_INITIALIZER(head) \ + { (void *)&head, (void *)&head } + +#define CIRCLEQ_ENTRY(type) \ +struct { \ + struct type *cqe_next; /* next element */ \ + struct type *cqe_prev; /* previous element */ \ +} + +/* + * Circular queue functions. + */ +#define CIRCLEQ_INIT(head) do { \ + (head)->cqh_first = (void *)(head); \ + (head)->cqh_last = (void *)(head); \ +} while (/*CONSTCOND*/0) + +#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ + (elm)->field.cqe_next = (listelm)->field.cqe_next; \ + (elm)->field.cqe_prev = (listelm); \ + if ((listelm)->field.cqe_next == (void *)(head)) \ + (head)->cqh_last = (elm); \ + else \ + (listelm)->field.cqe_next->field.cqe_prev = (elm); \ + (listelm)->field.cqe_next = (elm); \ +} while (/*CONSTCOND*/0) + +#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \ + (elm)->field.cqe_next = (listelm); \ + (elm)->field.cqe_prev = (listelm)->field.cqe_prev; \ + if ((listelm)->field.cqe_prev == (void *)(head)) \ + (head)->cqh_first = (elm); \ + else \ + (listelm)->field.cqe_prev->field.cqe_next = (elm); \ + (listelm)->field.cqe_prev = (elm); \ +} while (/*CONSTCOND*/0) + +#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \ + (elm)->field.cqe_next = (head)->cqh_first; \ + (elm)->field.cqe_prev = (void *)(head); \ + if ((head)->cqh_last == (void *)(head)) \ + (head)->cqh_last = (elm); \ + else \ + (head)->cqh_first->field.cqe_prev = (elm); \ + (head)->cqh_first = (elm); \ +} while (/*CONSTCOND*/0) + +#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \ + (elm)->field.cqe_next = (void *)(head); \ + (elm)->field.cqe_prev = (head)->cqh_last; \ + if ((head)->cqh_first == (void *)(head)) \ + (head)->cqh_first = (elm); \ + else \ + (head)->cqh_last->field.cqe_next = (elm); \ + (head)->cqh_last = (elm); \ +} while (/*CONSTCOND*/0) + +#define CIRCLEQ_REMOVE(head, elm, field) do { \ + if ((elm)->field.cqe_next == (void *)(head)) \ + (head)->cqh_last = (elm)->field.cqe_prev; \ + else \ + (elm)->field.cqe_next->field.cqe_prev = \ + (elm)->field.cqe_prev; \ + if ((elm)->field.cqe_prev == (void *)(head)) \ + (head)->cqh_first = (elm)->field.cqe_next; \ + else \ + (elm)->field.cqe_prev->field.cqe_next = \ + (elm)->field.cqe_next; \ +} while (/*CONSTCOND*/0) + +#define CIRCLEQ_FOREACH(var, head, field) \ + for ((var) = ((head)->cqh_first); \ + (var) != (const void *)(head); \ + (var) = ((var)->field.cqe_next)) + +#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \ + for ((var) = ((head)->cqh_last); \ + (var) != (const void *)(head); \ + (var) = ((var)->field.cqe_prev)) + +/* + * Circular queue access methods. + */ +#define CIRCLEQ_EMPTY(head) ((head)->cqh_first == (void *)(head)) +#define CIRCLEQ_FIRST(head) ((head)->cqh_first) +#define CIRCLEQ_LAST(head) ((head)->cqh_last) +#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next) +#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev) + +#define CIRCLEQ_LOOP_NEXT(head, elm, field) \ + (((elm)->field.cqe_next == (void *)(head)) \ + ? ((head)->cqh_first) \ + : (elm->field.cqe_next)) +#define CIRCLEQ_LOOP_PREV(head, elm, field) \ + (((elm)->field.cqe_prev == (void *)(head)) \ + ? ((head)->cqh_last) \ + : (elm->field.cqe_prev)) + +#endif /* sys/queue.h */ diff --git a/headers/sys/quota.h b/headers/sys/quota.h new file mode 100644 index 000000000..a20f62c14 --- /dev/null +++ b/headers/sys/quota.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_QUOTA_H_ +#define _SYS_QUOTA_H_ + +#include <sys/cdefs.h> + +// The uapi header uses different names from userspace, oddly. +#define if_dqblk dqblk +#define if_dqinfo dqinfo +#include <linux/quota.h> +#undef if_dqblk +#undef if_dqinfo + +__BEGIN_DECLS + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +int quotactl(int, const char*, int, char*) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + +__END_DECLS + +#endif diff --git a/headers/sys/reboot.h b/headers/sys/reboot.h new file mode 100644 index 000000000..df4739e56 --- /dev/null +++ b/headers/sys/reboot.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_REBOOT_H_ +#define _SYS_REBOOT_H_ + +#include <sys/cdefs.h> +#include <linux/reboot.h> + +__BEGIN_DECLS + +/* use glibc names as well */ + +#define RB_AUTOBOOT LINUX_REBOOT_CMD_RESTART +#define RB_HALT_SYSTEM LINUX_REBOOT_CMD_HALT +#define RB_ENABLE_CAD LINUX_REBOOT_CMD_CAD_ON +#define RB_DISABLE_CAD LINUX_REBOOT_CMD_CAD_OFF +#define RB_POWER_OFF LINUX_REBOOT_CMD_POWER_OFF + +int reboot(int reboot_type); + +__END_DECLS + +#endif /* _SYS_REBOOT_H_ */ diff --git a/headers/sys/reg.h b/headers/sys/reg.h new file mode 100644 index 000000000..1066b6dc5 --- /dev/null +++ b/headers/sys/reg.h @@ -0,0 +1,86 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_REG_H_ +#define _SYS_REG_H_ + +#include <sys/cdefs.h> + +#if defined(__i386__) + +#define EBX 0 +#define ECX 1 +#define EDX 2 +#define ESI 3 +#define EDI 4 +#define EBP 5 +#define EAX 6 +#define DS 7 +#define ES 8 +#define FS 9 +#define GS 10 +#define ORIG_EAX 11 +#define EIP 12 +#define CS 13 +#define EFL 14 +#define UESP 15 +#define SS 16 + +#elif defined(__x86_64__) + +#define R15 0 +#define R14 1 +#define R13 2 +#define R12 3 +#define RBP 4 +#define RBX 5 +#define R11 6 +#define R10 7 +#define R9 8 +#define R8 9 +#define RAX 10 +#define RCX 11 +#define RDX 12 +#define RSI 13 +#define RDI 14 +#define ORIG_RAX 15 +#define RIP 16 +#define CS 17 +#define EFLAGS 18 +#define RSP 19 +#define SS 20 +#define FS_BASE 21 +#define GS_BASE 22 +#define DS 23 +#define ES 24 +#define FS 25 +#define GS 26 + +#endif + +#endif /* _SYS_REG_H_ */ diff --git a/headers/sys/resource.h b/headers/sys/resource.h new file mode 100644 index 000000000..7701d4899 --- /dev/null +++ b/headers/sys/resource.h @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_RESOURCE_H_ +#define _SYS_RESOURCE_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +#include <linux/resource.h> + +__BEGIN_DECLS + +/* The kernel header doesn't have these, but POSIX does. */ +#define RLIM_SAVED_CUR RLIM_INFINITY +#define RLIM_SAVED_MAX RLIM_INFINITY + +typedef unsigned long rlim_t; + +int getrlimit(int, struct rlimit*); +int setrlimit(int, const struct rlimit*); + + +#if __ANDROID_API__ >= 21 +int getrlimit64(int, struct rlimit64*) __INTRODUCED_IN(21); +int setrlimit64(int, const struct rlimit64*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +int getpriority(int, id_t); +int setpriority(int, id_t, int); + +int getrusage(int, struct rusage*); + + +#if (!defined(__LP64__) && __ANDROID_API__ >= 24) || (defined(__LP64__)) +int prlimit(pid_t, int, const struct rlimit*, struct rlimit*) __INTRODUCED_IN_32(24) + __INTRODUCED_IN_64(21); +#endif /* (!defined(__LP64__) && __ANDROID_API__ >= 24) || (defined(__LP64__)) */ + + +#if __ANDROID_API__ >= 21 +int prlimit64(pid_t, int, const struct rlimit64*, struct rlimit64*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +__END_DECLS + +#endif /* _SYS_RESOURCE_H_ */ diff --git a/headers/sys/select.h b/headers/sys/select.h new file mode 100644 index 000000000..0c77ff0b6 --- /dev/null +++ b/headers/sys/select.h @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_SELECT_H_ +#define _SYS_SELECT_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +#include <linux/time.h> +#include <signal.h> + +__BEGIN_DECLS + +#define FD_SETSIZE 1024 +#define NFDBITS (8 * sizeof(unsigned long)) +#define __FDSET_LONGS (FD_SETSIZE/NFDBITS) + +typedef struct { + unsigned long fds_bits[__FDSET_LONGS]; +} fd_set; + +#define __FDELT(fd) ((fd) / NFDBITS) +#define __FDMASK(fd) (1UL << ((fd) % NFDBITS)) +#define __FDS_BITS(set) (__BIONIC_CAST(static_cast, fd_set*, set)->fds_bits) + +/* Inline loop so we don't have to declare memset. */ +#define FD_ZERO(set) \ + do { \ + size_t __i; \ + for (__i = 0; __i < __FDSET_LONGS; ++__i) { \ + (set)->fds_bits[__i] = 0; \ + } \ + } while (0) + + +#if __ANDROID_API__ >= 21 +void __FD_CLR_chk(int, fd_set*, size_t) __INTRODUCED_IN(21); +void __FD_SET_chk(int, fd_set*, size_t) __INTRODUCED_IN(21); +int __FD_ISSET_chk(int, fd_set*, size_t) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +#if defined(__BIONIC_FORTIFY) && __ANDROID_API__ >= __ANDROID_API_L__ +#define FD_CLR(fd, set) __FD_CLR_chk(fd, set, __bos(set)) +#define FD_SET(fd, set) __FD_SET_chk(fd, set, __bos(set)) +#define FD_ISSET(fd, set) __FD_ISSET_chk(fd, set, __bos(set)) +#else +#define FD_CLR(fd, set) (__FDS_BITS(set)[__FDELT(fd)] &= ~__FDMASK(fd)) +#define FD_SET(fd, set) (__FDS_BITS(set)[__FDELT(fd)] |= __FDMASK(fd)) +#define FD_ISSET(fd, set) ((__FDS_BITS(set)[__FDELT(fd)] & __FDMASK(fd)) != 0) +#endif /* defined(__BIONIC_FORTIFY) && __ANDROID_API >= 21 */ + +int select(int, fd_set*, fd_set*, fd_set*, struct timeval*); +int pselect(int, fd_set*, fd_set*, fd_set*, const struct timespec*, const sigset_t*); + +__END_DECLS + +#endif /* _SYS_SELECT_H_ */ diff --git a/headers/sys/sem.h b/headers/sys/sem.h new file mode 100644 index 000000000..0b28c9af0 --- /dev/null +++ b/headers/sys/sem.h @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_SEM_H_ +#define _SYS_SEM_H_ + +#include <sys/cdefs.h> +#include <sys/ipc.h> +#include <sys/types.h> + +#if defined(__USE_GNU) +#include <bits/timespec.h> +#endif + +#include <linux/sem.h> + +#define semid_ds semid64_ds + +__BEGIN_DECLS + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +int semctl(int, int, int, ...) __INTRODUCED_IN_FUTURE; +int semget(key_t, int, int) __INTRODUCED_IN_FUTURE; +int semop(int, struct sembuf*, size_t) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + +#if defined(__USE_GNU) + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +int semtimedop(int, struct sembuf*, size_t, const struct timespec*) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + +#endif + +__END_DECLS + +#endif diff --git a/headers/sys/sendfile.h b/headers/sys/sendfile.h new file mode 100644 index 000000000..72abdc2ec --- /dev/null +++ b/headers/sys/sendfile.h @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_SENDFILE_H_ +#define _SYS_SENDFILE_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> + +__BEGIN_DECLS + +#if defined(__USE_FILE_OFFSET64) + +#if __ANDROID_API__ >= 21 +ssize_t sendfile(int out_fd, int in_fd, off_t* offset, size_t count) __RENAME(sendfile64) + __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +#else +ssize_t sendfile(int out_fd, int in_fd, off_t* offset, size_t count); +#endif + +#if __ANDROID_API__ >= 21 +ssize_t sendfile64(int out_fd, int in_fd, off64_t* offset, size_t count) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +__END_DECLS + +#endif /* _SYS_SENDFILE_H_ */ diff --git a/headers/sys/shm.h b/headers/sys/shm.h new file mode 100644 index 000000000..c3721d21d --- /dev/null +++ b/headers/sys/shm.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_SHM_H_ +#define _SYS_SHM_H_ + +#include <sys/cdefs.h> +#include <sys/ipc.h> +#include <sys/types.h> + +#include <linux/shm.h> + +#define shmid_ds shmid64_ds +#define SHMLBA 4096 + +__BEGIN_DECLS + +typedef unsigned long shmatt_t; + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +void* shmat(int, const void*, int) __INTRODUCED_IN_FUTURE; +int shmctl(int, int, struct shmid_ds*) __INTRODUCED_IN_FUTURE; +int shmdt(const void*) __INTRODUCED_IN_FUTURE; +int shmget(key_t, size_t, int) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + +__END_DECLS + +#endif diff --git a/headers/sys/signal.h b/headers/sys/signal.h new file mode 100644 index 000000000..2e602dad8 --- /dev/null +++ b/headers/sys/signal.h @@ -0,0 +1 @@ +#include <signal.h> diff --git a/headers/sys/signalfd.h b/headers/sys/signalfd.h new file mode 100644 index 000000000..55299a85d --- /dev/null +++ b/headers/sys/signalfd.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_SIGNALFD_H_ +#define _SYS_SIGNALFD_H_ + +#include <sys/cdefs.h> + +#include <linux/signalfd.h> +#include <signal.h> + +__BEGIN_DECLS + + +#if __ANDROID_API__ >= 18 +int signalfd(int fd, const sigset_t* _Nonnull mask, int flags) __INTRODUCED_IN(18); +#endif /* __ANDROID_API__ >= 18 */ + + +__END_DECLS + +#endif /* _SYS_SIGNALFD_H */ diff --git a/headers/sys/socket.h b/headers/sys/socket.h new file mode 100644 index 000000000..87246260a --- /dev/null +++ b/headers/sys/socket.h @@ -0,0 +1,383 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_SOCKET_H_ +#define _SYS_SOCKET_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <linux/socket.h> + +#include <asm/fcntl.h> +#include <asm/socket.h> +#include <linux/sockios.h> +#include <linux/uio.h> +#include <linux/types.h> +#include <linux/compiler.h> + +#include <bits/sa_family_t.h> + +__BEGIN_DECLS + +#define sockaddr_storage __kernel_sockaddr_storage + +struct timespec; + +#ifdef __mips__ +#define SOCK_DGRAM 1 +#define SOCK_STREAM 2 +#else +#define SOCK_STREAM 1 +#define SOCK_DGRAM 2 +#endif +#define SOCK_RAW 3 +#define SOCK_RDM 4 +#define SOCK_SEQPACKET 5 +#define SOCK_DCCP 6 +#define SOCK_PACKET 10 + +#define SOCK_CLOEXEC O_CLOEXEC +#define SOCK_NONBLOCK O_NONBLOCK + +enum { + SHUT_RD = 0, +#define SHUT_RD SHUT_RD + SHUT_WR, +#define SHUT_WR SHUT_WR + SHUT_RDWR +#define SHUT_RDWR SHUT_RDWR +}; + +struct sockaddr { + sa_family_t sa_family; + char sa_data[14]; +}; + +struct linger { + int l_onoff; + int l_linger; +}; + +struct msghdr { + void* msg_name; + socklen_t msg_namelen; + struct iovec* msg_iov; + size_t msg_iovlen; + void* msg_control; + size_t msg_controllen; + int msg_flags; +}; + +struct mmsghdr { + struct msghdr msg_hdr; + unsigned int msg_len; +}; + +struct cmsghdr { + size_t cmsg_len; + int cmsg_level; + int cmsg_type; +}; + +#define CMSG_NXTHDR(mhdr, cmsg) __cmsg_nxthdr((mhdr), (cmsg)) +#define CMSG_ALIGN(len) ( ((len)+sizeof(long)-1) & ~(sizeof(long)-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_LEN(len) (CMSG_ALIGN(sizeof(struct cmsghdr)) + (len)) +#define CMSG_FIRSTHDR(msg) \ + ((msg)->msg_controllen >= sizeof(struct cmsghdr) \ + ? (struct cmsghdr*) (msg)->msg_control : (struct cmsghdr*) NULL) +#define CMSG_OK(mhdr, cmsg) ((cmsg)->cmsg_len >= sizeof(struct cmsghdr) && (cmsg)->cmsg_len <= (unsigned long) ((mhdr)->msg_controllen - ((char*)(cmsg) - (char*)(mhdr)->msg_control))) + +#if __ANDROID_API__ >= __ANDROID_API_L__ +struct cmsghdr* __cmsg_nxthdr(struct msghdr*, struct cmsghdr*) __INTRODUCED_IN(21); +#else +/* TODO(danalbert): Move this into libandroid_support. */ +static inline struct cmsghdr* __cmsg_nxthdr(struct msghdr* msg, struct cmsghdr* cmsg) { + struct cmsghdr* ptr = + __BIONIC_CAST(reinterpret_cast, struct cmsghdr*, + (__BIONIC_CAST(reinterpret_cast, char*, cmsg) + CMSG_ALIGN(cmsg->cmsg_len))); + size_t len = __BIONIC_CAST(reinterpret_cast, char*, ptr + 1) - + __BIONIC_CAST(reinterpret_cast, char*, msg->msg_control); + if (len > msg->msg_controllen) { + return NULL; + } + return ptr; +} +#endif /* __ANDROID_API__ >= __ANDROID_API_L__ */ + +#define SCM_RIGHTS 0x01 +#define SCM_CREDENTIALS 0x02 +#define SCM_SECURITY 0x03 + +struct ucred { + pid_t pid; + uid_t uid; + gid_t gid; +}; + +#define AF_UNSPEC 0 +#define AF_UNIX 1 +#define AF_LOCAL 1 +#define AF_INET 2 +#define AF_AX25 3 +#define AF_IPX 4 +#define AF_APPLETALK 5 +#define AF_NETROM 6 +#define AF_BRIDGE 7 +#define AF_ATMPVC 8 +#define AF_X25 9 +#define AF_INET6 10 +#define AF_ROSE 11 +#define AF_DECnet 12 +#define AF_NETBEUI 13 +#define AF_SECURITY 14 +#define AF_KEY 15 +#define AF_NETLINK 16 +#define AF_ROUTE AF_NETLINK +#define AF_PACKET 17 +#define AF_ASH 18 +#define AF_ECONET 19 +#define AF_ATMSVC 20 +#define AF_RDS 21 +#define AF_SNA 22 +#define AF_IRDA 23 +#define AF_PPPOX 24 +#define AF_WANPIPE 25 +#define AF_LLC 26 +#define AF_CAN 29 +#define AF_TIPC 30 +#define AF_BLUETOOTH 31 +#define AF_IUCV 32 +#define AF_RXRPC 33 +#define AF_ISDN 34 +#define AF_PHONET 35 +#define AF_IEEE802154 36 +#define AF_CAIF 37 +#define AF_ALG 38 +#define AF_NFC 39 +#define AF_VSOCK 40 +#define AF_KCM 41 +#define AF_QIPCRTR 42 +#define AF_MAX 43 + +#define PF_UNSPEC AF_UNSPEC +#define PF_UNIX AF_UNIX +#define PF_LOCAL AF_LOCAL +#define PF_INET AF_INET +#define PF_AX25 AF_AX25 +#define PF_IPX AF_IPX +#define PF_APPLETALK AF_APPLETALK +#define PF_NETROM AF_NETROM +#define PF_BRIDGE AF_BRIDGE +#define PF_ATMPVC AF_ATMPVC +#define PF_X25 AF_X25 +#define PF_INET6 AF_INET6 +#define PF_ROSE AF_ROSE +#define PF_DECnet AF_DECnet +#define PF_NETBEUI AF_NETBEUI +#define PF_SECURITY AF_SECURITY +#define PF_KEY AF_KEY +#define PF_NETLINK AF_NETLINK +#define PF_ROUTE AF_ROUTE +#define PF_PACKET AF_PACKET +#define PF_ASH AF_ASH +#define PF_ECONET AF_ECONET +#define PF_ATMSVC AF_ATMSVC +#define PF_RDS AF_RDS +#define PF_SNA AF_SNA +#define PF_IRDA AF_IRDA +#define PF_PPPOX AF_PPPOX +#define PF_WANPIPE AF_WANPIPE +#define PF_LLC AF_LLC +#define PF_CAN AF_CAN +#define PF_TIPC AF_TIPC +#define PF_BLUETOOTH AF_BLUETOOTH +#define PF_IUCV AF_IUCV +#define PF_RXRPC AF_RXRPC +#define PF_ISDN AF_ISDN +#define PF_PHONET AF_PHONET +#define PF_IEEE802154 AF_IEEE802154 +#define PF_CAIF AF_CAIF +#define PF_ALG AF_ALG +#define PF_NFC AF_NFC +#define PF_VSOCK AF_VSOCK +#define PF_KCM AF_KCM +#define PF_QIPCRTR AF_QIPCRTR +#define PF_MAX AF_MAX + +#define SOMAXCONN 128 + +#define MSG_OOB 1 +#define MSG_PEEK 2 +#define MSG_DONTROUTE 4 +#define MSG_TRYHARD 4 +#define MSG_CTRUNC 8 +#define MSG_PROBE 0x10 +#define MSG_TRUNC 0x20 +#define MSG_DONTWAIT 0x40 +#define MSG_EOR 0x80 +#define MSG_WAITALL 0x100 +#define MSG_FIN 0x200 +#define MSG_SYN 0x400 +#define MSG_CONFIRM 0x800 +#define MSG_RST 0x1000 +#define MSG_ERRQUEUE 0x2000 +#define MSG_NOSIGNAL 0x4000 +#define MSG_MORE 0x8000 +#define MSG_WAITFORONE 0x10000 +#define MSG_BATCH 0x40000 +#define MSG_FASTOPEN 0x20000000 +#define MSG_CMSG_CLOEXEC 0x40000000 +#define MSG_EOF MSG_FIN +#define MSG_CMSG_COMPAT 0 + +#define SOL_IP 0 +#define SOL_TCP 6 +#define SOL_UDP 17 +#define SOL_IPV6 41 +#define SOL_ICMPV6 58 +#define SOL_SCTP 132 +#define SOL_RAW 255 +#define SOL_IPX 256 +#define SOL_AX25 257 +#define SOL_ATALK 258 +#define SOL_NETROM 259 +#define SOL_ROSE 260 +#define SOL_DECNET 261 +#define SOL_X25 262 +#define SOL_PACKET 263 +#define SOL_ATM 264 +#define SOL_AAL 265 +#define SOL_IRDA 266 +#define SOL_NETBEUI 267 +#define SOL_LLC 268 +#define SOL_DCCP 269 +#define SOL_NETLINK 270 +#define SOL_TIPC 271 +#define SOL_RXRPC 272 +#define SOL_PPPOL2TP 273 +#define SOL_BLUETOOTH 274 +#define SOL_PNPIPE 275 +#define SOL_RDS 276 +#define SOL_IUCV 277 +#define SOL_CAIF 278 +#define SOL_ALG 279 +#define SOL_NFC 280 +#define SOL_KCM 281 + +#define IPX_TYPE 1 + +#ifdef __i386__ +# define __socketcall extern __attribute__((__cdecl__)) +#else +# define __socketcall extern +#endif + +__socketcall int accept(int, struct sockaddr*, socklen_t*); + +#if __ANDROID_API__ >= 21 +__socketcall int accept4(int, struct sockaddr*, socklen_t*, int) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +__socketcall int bind(int, const struct sockaddr*, socklen_t); +__socketcall int connect(int, const struct sockaddr*, socklen_t); +__socketcall int getpeername(int, struct sockaddr*, socklen_t*); +__socketcall int getsockname(int, struct sockaddr*, socklen_t*); +__socketcall int getsockopt(int, int, int, void*, socklen_t*); +__socketcall int listen(int, int); + +#if __ANDROID_API__ >= 21 +__socketcall int recvmmsg(int, struct mmsghdr*, unsigned int, int, const struct timespec*) + __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +__socketcall ssize_t recvmsg(int, struct msghdr*, int); + +#if __ANDROID_API__ >= 21 +__socketcall int sendmmsg(int, const struct mmsghdr*, unsigned int, int) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +__socketcall ssize_t sendmsg(int, const struct msghdr*, int); +__socketcall int setsockopt(int, int, int, const void*, socklen_t); +__socketcall int shutdown(int, int); +__socketcall int socket(int, int, int); +__socketcall int socketpair(int, int, int, int*); + +ssize_t recv(int, void*, size_t, int); +ssize_t send(int, const void*, size_t, int); + +__socketcall ssize_t sendto(int, const void*, size_t, int, const struct sockaddr*, socklen_t); +__socketcall ssize_t recvfrom(int, void*, size_t, int, struct sockaddr*, socklen_t*); + +__errordecl(__recvfrom_error, "recvfrom called with size bigger than buffer"); + +#if __ANDROID_API__ >= 21 +ssize_t __recvfrom_chk(int, void*, size_t, size_t, int, struct sockaddr*, socklen_t*) + __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +ssize_t __recvfrom_real(int, void*, size_t, int, struct sockaddr*, socklen_t*) __RENAME(recvfrom); + +#if defined(__BIONIC_FORTIFY) + +#if __ANDROID_API__ >= __ANDROID_API_N__ +__BIONIC_FORTIFY_INLINE +ssize_t recvfrom(int fd, void* buf, size_t len, int flags, struct sockaddr* src_addr, socklen_t* addr_len) { + size_t bos = __bos0(buf); + +#if !defined(__clang__) + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __recvfrom_real(fd, buf, len, flags, src_addr, addr_len); + } + + if (__builtin_constant_p(len) && (len <= bos)) { + return __recvfrom_real(fd, buf, len, flags, src_addr, addr_len); + } + + if (__builtin_constant_p(len) && (len > bos)) { + __recvfrom_error(); + } +#endif + + return __recvfrom_chk(fd, buf, len, bos, flags, src_addr, addr_len); +} +#endif /* __ANDROID_API__ >= __ANDROID_API_N__ */ + +__BIONIC_FORTIFY_INLINE +ssize_t recv(int socket, void* buf, size_t len, int flags) { + return recvfrom(socket, buf, len, flags, NULL, 0); +} + +#endif /* __BIONIC_FORTIFY */ + +#undef __socketcall + +__END_DECLS + +#endif /* _SYS_SOCKET_H */ diff --git a/headers/sys/stat.h b/headers/sys/stat.h new file mode 100644 index 000000000..753ad7f99 --- /dev/null +++ b/headers/sys/stat.h @@ -0,0 +1,247 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_STAT_H_ +#define _SYS_STAT_H_ + +#include <bits/timespec.h> +#include <linux/stat.h> +#include <sys/cdefs.h> +#include <sys/types.h> + +__BEGIN_DECLS + +#if defined(__aarch64__) || (defined(__mips__) && defined(__LP64__)) +#define __STAT64_BODY \ + dev_t st_dev; \ + ino_t st_ino; \ + mode_t st_mode; \ + nlink_t st_nlink; \ + uid_t st_uid; \ + gid_t st_gid; \ + dev_t st_rdev; \ + unsigned long __pad1; \ + off_t st_size; \ + int st_blksize; \ + int __pad2; \ + long st_blocks; \ + struct timespec st_atim; \ + struct timespec st_mtim; \ + struct timespec st_ctim; \ + unsigned int __unused4; \ + unsigned int __unused5; \ + +#elif defined(__mips__) && !defined(__LP64__) +#define __STAT64_BODY \ + unsigned int st_dev; \ + unsigned int __pad0[3]; \ + unsigned long long st_ino; \ + mode_t st_mode; \ + nlink_t st_nlink; \ + uid_t st_uid; \ + gid_t st_gid; \ + unsigned int st_rdev; \ + unsigned int __pad1[3]; \ + long long st_size; \ + struct timespec st_atim; \ + struct timespec st_mtim; \ + struct timespec st_ctim; \ + unsigned int st_blksize; \ + unsigned int __pad2; \ + unsigned long long st_blocks; \ + +#elif defined(__x86_64__) +#define __STAT64_BODY \ + dev_t st_dev; \ + ino_t st_ino; \ + unsigned long st_nlink; \ + mode_t st_mode; \ + uid_t st_uid; \ + gid_t st_gid; \ + unsigned int __pad0; \ + dev_t st_rdev; \ + off_t st_size; \ + long st_blksize; \ + long st_blocks; \ + struct timespec st_atim; \ + struct timespec st_mtim; \ + struct timespec st_ctim; \ + long __pad3[3]; \ + +#else /* __arm__ || __i386__ */ +#define __STAT64_BODY \ + unsigned long long st_dev; \ + unsigned char __pad0[4]; \ + unsigned long __st_ino; \ + unsigned int st_mode; \ + nlink_t st_nlink; \ + uid_t st_uid; \ + gid_t st_gid; \ + unsigned long long st_rdev; \ + unsigned char __pad3[4]; \ + long long st_size; \ + unsigned long st_blksize; \ + unsigned long long st_blocks; \ + struct timespec st_atim; \ + struct timespec st_mtim; \ + struct timespec st_ctim; \ + unsigned long long st_ino; \ + +#endif + +struct stat { __STAT64_BODY }; +struct stat64 { __STAT64_BODY }; + +#undef __STAT64_BODY + +/* Compatibility with older versions of POSIX. */ +#define st_atime st_atim.tv_sec +#define st_mtime st_mtim.tv_sec +#define st_ctime st_ctim.tv_sec +/* Compatibility with glibc. */ +#define st_atimensec st_atim.tv_nsec +#define st_mtimensec st_mtim.tv_nsec +#define st_ctimensec st_ctim.tv_nsec + +#if defined(__USE_BSD) +/* Permission macros provided by glibc for compatibility with BSDs. */ +#define ACCESSPERMS (S_IRWXU | S_IRWXG | S_IRWXO) /* 0777 */ +#define ALLPERMS (S_ISUID | S_ISGID | S_ISVTX | S_IRWXU | S_IRWXG | S_IRWXO) /* 07777 */ +#define DEFFILEMODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH) /* 0666 */ +#endif + +#if defined(__USE_BSD) || defined(__USE_GNU) +#define S_IREAD S_IRUSR +#define S_IWRITE S_IWUSR +#define S_IEXEC S_IXUSR +#endif + +/* POSIX mandates these, but Linux doesn't implement them as distinct file types. */ +#define S_TYPEISMQ(__sb) 0 +#define S_TYPEISSEM(__sb) 0 +#define S_TYPEISSHM(__sb) 0 +#define S_TYPEISTMO(__sb) 0 + +int chmod(const char*, mode_t); +int fchmod(int, mode_t); +int mkdir(const char*, mode_t); + +int fstat(int, struct stat*); + +#if __ANDROID_API__ >= 21 +int fstat64(int, struct stat64*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int fstatat(int, const char*, struct stat*, int); + +#if __ANDROID_API__ >= 21 +int fstatat64(int, const char*, struct stat64*, int) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int lstat(const char*, struct stat*); + +#if __ANDROID_API__ >= 21 +int lstat64(const char*, struct stat64*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int stat(const char*, struct stat*); + +#if __ANDROID_API__ >= 21 +int stat64(const char*, struct stat64*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +int mknod(const char*, mode_t, dev_t); +mode_t umask(mode_t); + + +#if __ANDROID_API__ >= 18 +mode_t __umask_chk(mode_t) __INTRODUCED_IN(18); +#endif /* __ANDROID_API__ >= 18 */ + +mode_t __umask_real(mode_t) __RENAME(umask); +__errordecl(__umask_invalid_mode, "umask called with invalid mode"); + +#if defined(__BIONIC_FORTIFY) + +#if __ANDROID_API__ >= __ANDROID_API_J_MR2__ +__BIONIC_FORTIFY_INLINE +mode_t umask(mode_t mode) { +#if !defined(__clang__) + if (__builtin_constant_p(mode)) { + if ((mode & 0777) != mode) { + __umask_invalid_mode(); + } + return __umask_real(mode); + } +#endif + return __umask_chk(mode); +} +#endif /* __ANDROID_API__ >= __ANDROID_API_J_MR2__ */ + +#endif /* defined(__BIONIC_FORTIFY) */ + +#if __ANDROID_API__ >= __ANDROID_API_L__ +int mkfifo(const char*, mode_t) __INTRODUCED_IN(21); +#else +// Implemented as a static inline before 21. +#endif + + +#if __ANDROID_API__ >= 23 +int mkfifoat(int, const char*, mode_t) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +int fchmodat(int, const char*, mode_t, int); +int mkdirat(int, const char*, mode_t); + +#if __ANDROID_API__ >= 21 +int mknodat(int, const char*, mode_t, dev_t) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +#define UTIME_NOW ((1L << 30) - 1L) +#define UTIME_OMIT ((1L << 30) - 2L) + +#if __ANDROID_API__ >= 12 +int utimensat(int fd, const char* path, const struct timespec times[2], int flags) + __INTRODUCED_IN(12); +#endif /* __ANDROID_API__ >= 12 */ + + +#if __ANDROID_API__ >= 19 +int futimens(int fd, const struct timespec times[2]) __INTRODUCED_IN(19); +#endif /* __ANDROID_API__ >= 19 */ + + +__END_DECLS + +#include <android/legacy_sys_stat_inlines.h> + +#endif /* _SYS_STAT_H_ */ diff --git a/headers/sys/statfs.h b/headers/sys/statfs.h new file mode 100644 index 000000000..53b3b5e4d --- /dev/null +++ b/headers/sys/statfs.h @@ -0,0 +1 @@ +#include <sys/vfs.h> diff --git a/headers/sys/statvfs.h b/headers/sys/statvfs.h new file mode 100644 index 000000000..215a25152 --- /dev/null +++ b/headers/sys/statvfs.h @@ -0,0 +1,87 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _SYS_STATVFS_H_ +#define _SYS_STATVFS_H_ + +#include <stdint.h> +#include <sys/cdefs.h> +#include <sys/types.h> + +__BEGIN_DECLS + +#ifdef __LP64__ +#define __STATVFS64_RESERVED uint32_t __f_reserved[6]; +#else +#define __STATVFS64_RESERVED +#endif + +#define __STATVFS64_BODY \ + unsigned long f_bsize; \ + unsigned long f_frsize; \ + fsblkcnt_t f_blocks; \ + fsblkcnt_t f_bfree; \ + fsblkcnt_t f_bavail; \ + fsfilcnt_t f_files; \ + fsfilcnt_t f_ffree; \ + fsfilcnt_t f_favail; \ + unsigned long f_fsid; \ + unsigned long f_flag; \ + unsigned long f_namemax; \ + __STATVFS64_RESERVED + +struct statvfs { __STATVFS64_BODY }; +struct statvfs64 { __STATVFS64_BODY }; + +#undef __STATVFS64_BODY +#undef __STATVFS64_RESERVED + +#define ST_RDONLY 0x0001 +#define ST_NOSUID 0x0002 +#define ST_NODEV 0x0004 +#define ST_NOEXEC 0x0008 +#define ST_SYNCHRONOUS 0x0010 +#define ST_MANDLOCK 0x0040 +#define ST_NOATIME 0x0400 +#define ST_NODIRATIME 0x0800 +#define ST_RELATIME 0x1000 + + +#if __ANDROID_API__ >= 19 +int statvfs(const char* __restrict _Nonnull, struct statvfs* __restrict _Nonnull) + __INTRODUCED_IN(19); +#endif /* __ANDROID_API__ >= 19 */ + + +#if __ANDROID_API__ >= 21 +int statvfs64(const char* __restrict _Nonnull, struct statvfs64* __restrict _Nonnull) + __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +#if __ANDROID_API__ >= 19 +int fstatvfs(int, struct statvfs* _Nonnull) __INTRODUCED_IN(19); +#endif /* __ANDROID_API__ >= 19 */ + + +#if __ANDROID_API__ >= 21 +int fstatvfs64(int, struct statvfs64* _Nonnull) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +__END_DECLS + +#endif /* _SYS_STATVFS_H_ */ diff --git a/headers/sys/swap.h b/headers/sys/swap.h new file mode 100644 index 000000000..b936550c2 --- /dev/null +++ b/headers/sys/swap.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_SWAP_H_ +#define _SYS_SWAP_H_ + +#include <sys/cdefs.h> + +__BEGIN_DECLS + +#define SWAP_FLAG_DISCARD 0x10000 +#define SWAP_FLAG_PREFER 0x8000 +#define SWAP_FLAG_PRIO_MASK 0x7fff +#define SWAP_FLAG_PRIO_SHIFT 0 + + +#if __ANDROID_API__ >= 19 +int swapon(const char* _Nonnull, int) __INTRODUCED_IN(19); +int swapoff(const char* _Nonnull) __INTRODUCED_IN(19); +#endif /* __ANDROID_API__ >= 19 */ + + +__END_DECLS + +#endif /* _SYS_SWAP_H_ */ diff --git a/headers/sys/syscall.h b/headers/sys/syscall.h new file mode 100644 index 000000000..a49323d15 --- /dev/null +++ b/headers/sys/syscall.h @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_SYSCALL_H_ +#define _SYS_SYSCALL_H_ + +#include <asm/unistd.h> /* Linux kernel __NR_* names. */ +#include <bits/glibc-syscalls.h> /* glibc-compatible SYS_* aliases. */ +#include <sys/cdefs.h> + +/* The syscall function itself is declared in <unistd.h>, not here. */ + +#endif /* _SYS_SYSCALL_H_ */ diff --git a/headers/sys/sysconf.h b/headers/sys/sysconf.h new file mode 100644 index 000000000..eb30faf8f --- /dev/null +++ b/headers/sys/sysconf.h @@ -0,0 +1,6 @@ +/* + * This file used to contain the declarations of sysconf and its associated constants. + * No standard mentions a <sys/sysconf.h>, but there are enough users in vendor (and potential ones + * in the NDK) to warrant not breaking source compatibility. + */ +#include <bits/sysconf.h> diff --git a/headers/sys/sysinfo.h b/headers/sys/sysinfo.h new file mode 100644 index 000000000..5c58bcf58 --- /dev/null +++ b/headers/sys/sysinfo.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef _SYS_SYSINFO_H_ +#define _SYS_SYSINFO_H_ + +#include <sys/cdefs.h> +#include <linux/kernel.h> + +__BEGIN_DECLS + +int sysinfo(struct sysinfo* info); + + +#if __ANDROID_API__ >= 23 +int get_nprocs_conf(void) __INTRODUCED_IN(23); + +int get_nprocs(void) __INTRODUCED_IN(23); + +long get_phys_pages(void) __INTRODUCED_IN(23); + +long get_avphys_pages(void) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +__END_DECLS + +#endif /* _SYS_SYSINFO_H_ */ diff --git a/headers/sys/syslog.h b/headers/sys/syslog.h new file mode 100644 index 000000000..7761eceeb --- /dev/null +++ b/headers/sys/syslog.h @@ -0,0 +1 @@ +#include <syslog.h> diff --git a/headers/sys/sysmacros.h b/headers/sys/sysmacros.h new file mode 100644 index 000000000..592cc5e0b --- /dev/null +++ b/headers/sys/sysmacros.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_SYSMACROS_H_ +#define _SYS_SYSMACROS_H_ + +#include <sys/cdefs.h> + +#define makedev(__major, __minor) \ + ( \ + (((__major) & 0xfffff000ULL) << 32) | (((__major) & 0xfffULL) << 8) | \ + (((__minor) & 0xffffff00ULL) << 12) | (((__minor) & 0xffULL)) \ + ) + +#define major(__dev) \ + ((unsigned) ((((unsigned long long) (__dev) >> 32) & 0xfffff000) | (((__dev) >> 8) & 0xfff))) + +#define minor(__dev) \ + ((unsigned) ((((__dev) >> 12) & 0xffffff00) | ((__dev) & 0xff))) + +#endif /* _SYS_SYSMACROS_H_ */ diff --git a/headers/sys/system_properties.h b/headers/sys/system_properties.h new file mode 100644 index 000000000..b3fbc48ff --- /dev/null +++ b/headers/sys/system_properties.h @@ -0,0 +1,119 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _INCLUDE_SYS_SYSTEM_PROPERTIES_H +#define _INCLUDE_SYS_SYSTEM_PROPERTIES_H + +#include <sys/cdefs.h> +#include <stddef.h> + +__BEGIN_DECLS + +typedef struct prop_info prop_info; + +#define PROP_NAME_MAX 32 +#define PROP_VALUE_MAX 92 + +/* Look up a system property by name, copying its value and a +** \0 terminator to the provided pointer. The total bytes +** copied will be no greater than PROP_VALUE_MAX. Returns +** the string length of the value. A property that is not +** defined is identical to a property with a length 0 value. +*/ +int __system_property_get(const char *name, char *value); + +/* Set a system property by name. +**/ + +#if __ANDROID_API__ >= 12 +int __system_property_set(const char* key, const char* value) __INTRODUCED_IN(12); +#endif /* __ANDROID_API__ >= 12 */ + + +/* Return a pointer to the system property named name, if it +** exists, or NULL if there is no such property. Use +** __system_property_read() to obtain the string value from +** the returned prop_info pointer. +** +** It is safe to cache the prop_info pointer to avoid future +** lookups. These returned pointers will remain valid for +** the lifetime of the system. +*/ +const prop_info *__system_property_find(const char *name); + +/* Read the value of a system property. Returns the length +** of the value. Copies the value and \0 terminator into +** the provided value pointer. Total length (including +** terminator) will be no greater that PROP_VALUE_MAX for +** __system_property_read. +** +** If name is nonzero, up to PROP_NAME_MAX bytes will be +** copied into the provided name pointer. The name will +** be \0 terminated. +*/ +int __system_property_read(const prop_info *pi, char *name, char *value); + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +void __system_property_read_callback(const prop_info *pi, + void (*)(void* cookie, const char *name, const char *value), + void* cookie) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + +/* Return a prop_info for the nth system property, or NULL if +** there is no nth property. Use __system_property_read() to +** read the value of this property. +** +** Please do not call this method. It only exists to provide +** backwards compatibility to NDK apps. Its implementation +** is inefficient and order of results may change from call +** to call. +*/ +const prop_info *__system_property_find_nth(unsigned n) + __REMOVED_IN(26); + +/* Pass a prop_info for each system property to the provided +** callback. Use __system_property_read() to read the value +** of this property. +** +** This method is for inspecting and debugging the property +** system. Please use __system_property_find() instead. +** +** Order of results may change from call to call. This is +** not a bug. +*/ + +#if __ANDROID_API__ >= 19 +int __system_property_foreach(void (*propfn)(const prop_info* pi, void* cookie), void* cookie) + __INTRODUCED_IN(19); +#endif /* __ANDROID_API__ >= 19 */ + + +__END_DECLS + +#endif diff --git a/headers/sys/time.h b/headers/sys/time.h new file mode 100644 index 000000000..85c8d15e4 --- /dev/null +++ b/headers/sys/time.h @@ -0,0 +1,108 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_TIME_H_ +#define _SYS_TIME_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <linux/time.h> + +/* POSIX says <sys/time.h> gets you most of <sys/select.h> and may get you all of it. */ +#include <sys/select.h> + +__BEGIN_DECLS + +int gettimeofday(struct timeval*, struct timezone*); +int settimeofday(const struct timeval*, const struct timezone*); + +int getitimer(int, struct itimerval*); +int setitimer(int, const struct itimerval*, struct itimerval*); + +int utimes(const char*, const struct timeval*); + +#if defined(__USE_BSD) + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +int futimes(int, const struct timeval[2]) __INTRODUCED_IN_FUTURE; +int lutimes(const char*, const struct timeval[2]) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + +#endif + +#if defined(__USE_GNU) + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +int futimesat(int, const char*, const struct timeval[2]) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + +#endif + +#define timerclear(a) \ + ((a)->tv_sec = (a)->tv_usec = 0) + +#define timerisset(a) \ + ((a)->tv_sec != 0 || (a)->tv_usec != 0) + +#define timercmp(a, b, op) \ + ((a)->tv_sec == (b)->tv_sec \ + ? (a)->tv_usec op (b)->tv_usec \ + : (a)->tv_sec op (b)->tv_sec) + +#define timeradd(a, b, res) \ + do { \ + (res)->tv_sec = (a)->tv_sec + (b)->tv_sec; \ + (res)->tv_usec = (a)->tv_usec + (b)->tv_usec; \ + if ((res)->tv_usec >= 1000000) { \ + (res)->tv_usec -= 1000000; \ + (res)->tv_sec += 1; \ + } \ + } while (0) + +#define timersub(a, b, res) \ + do { \ + (res)->tv_sec = (a)->tv_sec - (b)->tv_sec; \ + (res)->tv_usec = (a)->tv_usec - (b)->tv_usec; \ + if ((res)->tv_usec < 0) { \ + (res)->tv_usec += 1000000; \ + (res)->tv_sec -= 1; \ + } \ + } while (0) + +#define TIMEVAL_TO_TIMESPEC(tv, ts) { \ + (ts)->tv_sec = (tv)->tv_sec; \ + (ts)->tv_nsec = (tv)->tv_usec * 1000; \ +} +#define TIMESPEC_TO_TIMEVAL(tv, ts) { \ + (tv)->tv_sec = (ts)->tv_sec; \ + (tv)->tv_usec = (ts)->tv_nsec / 1000; \ +} + +__END_DECLS + +#endif /* _SYS_TIME_H_ */ diff --git a/headers/sys/timerfd.h b/headers/sys/timerfd.h new file mode 100644 index 000000000..32dcec4c0 --- /dev/null +++ b/headers/sys/timerfd.h @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_TIMERFD_H_ +#define _SYS_TIMERFD_H_ + +#include <fcntl.h> /* For O_CLOEXEC and O_NONBLOCK. */ +#include <time.h> +#include <sys/cdefs.h> +#include <sys/types.h> + +__BEGIN_DECLS + +#define TFD_TIMER_ABSTIME (1 << 0) +#define TFD_TIMER_CANCEL_ON_SET (1 << 1) + +#define TFD_CLOEXEC O_CLOEXEC +#define TFD_NONBLOCK O_NONBLOCK + + +#if __ANDROID_API__ >= 19 +int timerfd_create(clockid_t, int) __INTRODUCED_IN(19); +int timerfd_settime(int, int, const struct itimerspec*, struct itimerspec*) __INTRODUCED_IN(19); +int timerfd_gettime(int, struct itimerspec*) __INTRODUCED_IN(19); +#endif /* __ANDROID_API__ >= 19 */ + + +__END_DECLS + +#endif /* _SYS_TIMERFD_H */ diff --git a/headers/sys/times.h b/headers/sys/times.h new file mode 100644 index 000000000..f52db1f99 --- /dev/null +++ b/headers/sys/times.h @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_TIMES_H_ +#define _SYS_TIMES_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <linux/times.h> + +__BEGIN_DECLS + +clock_t times(struct tms*); + +__END_DECLS + +#endif /* _SYS_TIMES_H_ */ diff --git a/headers/sys/timex.h b/headers/sys/timex.h new file mode 100644 index 000000000..783c49df6 --- /dev/null +++ b/headers/sys/timex.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_TIMEX_H_ +#define _SYS_TIMEX_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <linux/timex.h> + +__BEGIN_DECLS + + +#if __ANDROID_API__ >= 24 +int adjtimex(struct timex*) __INTRODUCED_IN(24); +int clock_adjtime(clockid_t, struct timex*) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + + +__END_DECLS + +#endif /* _SYS_TIMEX_H_ */ diff --git a/headers/sys/ttydefaults.h b/headers/sys/ttydefaults.h new file mode 100644 index 000000000..62af84b10 --- /dev/null +++ b/headers/sys/ttydefaults.h @@ -0,0 +1,113 @@ +/* $NetBSD: ttydefaults.h,v 1.16 2008/05/24 14:06:39 yamt Exp $ */ + +/*- + * Copyright (c) 1982, 1986, 1993 + * The Regents of the University of California. All rights reserved. + * (c) UNIX System Laboratories, Inc. + * All or some portions of this file are derived from material licensed + * to the University of California by American Telephone and Telegraph + * Co. or Unix System Laboratories, Inc. and are reproduced herein with + * the permission of UNIX System Laboratories, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)ttydefaults.h 8.4 (Berkeley) 1/21/94 + */ + +/* + * System wide defaults for terminal state. + */ +#ifndef _SYS_TTYDEFAULTS_H_ +#define _SYS_TTYDEFAULTS_H_ + +#include <sys/cdefs.h> + +/* + * Defaults on "first" open. + */ +#define TTYDEF_IFLAG (BRKINT | ICRNL | IMAXBEL | IXON | IXANY) +#define TTYDEF_OFLAG (OPOST | ONLCR | OXTABS) +#define TTYDEF_LFLAG (ECHO | ICANON | ISIG | IEXTEN | ECHOE|ECHOKE|ECHOCTL) +#define TTYDEF_CFLAG (CREAD | CS8 | HUPCL) +#define TTYDEF_SPEED (B9600) + +/* + * Control Character Defaults + */ +#define CTRL(x) (x&037) +#define CEOF CTRL('d') +#define CEOL ((unsigned char)'\377') /* XXX avoid _POSIX_VDISABLE */ +#define CERASE 0177 +#define CINTR CTRL('c') +#define CSTATUS CTRL('t') +#define CKILL CTRL('u') +#define CMIN 1 +#define CQUIT 034 /* FS, ^\ */ +#define CSUSP CTRL('z') +#define CTIME 0 +#define CDSUSP CTRL('y') +#define CSTART CTRL('q') +#define CSTOP CTRL('s') +#define CLNEXT CTRL('v') +#define CDISCARD CTRL('o') +#define CWERASE CTRL('w') +#define CREPRINT CTRL('r') +#define CEOT CEOF +/* compat */ +#define CBRK CEOL +#define CRPRNT CREPRINT +#define CFLUSH CDISCARD + +/* PROTECTED INCLUSION ENDS HERE */ +#endif /* !_SYS_TTYDEFAULTS_H_ */ + +/* + * #define TTYDEFCHARS to include an array of default control characters. + */ +#ifdef TTYDEFCHARS +const cc_t ttydefchars[NCCS] = { + [VEOF] = CEOF, + [VEOL] = CEOL, + [VEOL2] = CEOL, + [VERASE] = CERASE, + [VWERASE] = CWERASE, + [VKILL] = CKILL, + [VREPRINT] = CREPRINT, + [7] = _POSIX_VDISABLE, /* spare */ + [VINTR] = CINTR, + [VQUIT] = CQUIT, + [VSUSP] = CSUSP, + [VDSUSP] = CDSUSP, + [VSTART] = CSTART, + [VSTOP] = CSTOP, + [VLNEXT] = CLNEXT, + [VDISCARD] = CDISCARD, + [VMIN] = CMIN, + [VTIME] = CTIME, + [VSTATUS] = CSTATUS, + [19] = _POSIX_VDISABLE, /* spare */ +}; +#undef TTYDEFCHARS +#endif diff --git a/headers/sys/types.h b/headers/sys/types.h new file mode 100644 index 000000000..637ef0215 --- /dev/null +++ b/headers/sys/types.h @@ -0,0 +1,147 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_TYPES_H_ +#define _SYS_TYPES_H_ + +#include <stddef.h> +#include <stdint.h> +#include <sys/cdefs.h> + +#include <linux/types.h> +#include <linux/posix_types.h> + +#include <bits/pthread_types.h> + +/* gids, uids, and pids are all 32-bit. */ +typedef __kernel_gid32_t __gid_t; +typedef __gid_t gid_t; +typedef __kernel_uid32_t __uid_t; +typedef __uid_t uid_t; +typedef __kernel_pid_t __pid_t; +typedef __pid_t pid_t; +typedef uint32_t __id_t; +typedef __id_t id_t; + +typedef unsigned long blkcnt_t; +typedef unsigned long blksize_t; +typedef __kernel_caddr_t caddr_t; +typedef __kernel_clock_t clock_t; + +typedef __kernel_clockid_t __clockid_t; +typedef __clockid_t clockid_t; + +typedef __kernel_daddr_t daddr_t; +typedef unsigned long fsblkcnt_t; +typedef unsigned long fsfilcnt_t; + +typedef __kernel_mode_t __mode_t; +typedef __mode_t mode_t; + +typedef __kernel_key_t __key_t; +typedef __key_t key_t; + +typedef __kernel_ino_t __ino_t; +typedef __ino_t ino_t; + +typedef uint64_t ino64_t; + +typedef uint32_t __nlink_t; +typedef __nlink_t nlink_t; + +typedef void* __timer_t; +typedef __timer_t timer_t; + +typedef __kernel_suseconds_t __suseconds_t; +typedef __suseconds_t suseconds_t; + +/* useconds_t is 32-bit on both LP32 and LP64. */ +typedef uint32_t __useconds_t; +typedef __useconds_t useconds_t; + +#if !defined(__LP64__) +/* This historical accident means that we had a 32-bit dev_t on 32-bit architectures. */ +typedef uint32_t dev_t; +#else +typedef uint64_t dev_t; +#endif + +/* This historical accident means that we had a 32-bit time_t on 32-bit architectures. */ +typedef __kernel_time_t __time_t; +typedef __time_t time_t; + +#if defined(__USE_FILE_OFFSET64) || defined(__LP64__) +typedef int64_t off_t; +typedef off_t loff_t; +typedef loff_t off64_t; +#else +/* This historical accident means that we had a 32-bit off_t on 32-bit architectures. */ +typedef __kernel_off_t off_t; +typedef __kernel_loff_t loff_t; +typedef loff_t off64_t; +#endif + +#if !defined(__LP64__) +/* This historical accident means that we had a signed socklen_t on 32-bit architectures. */ +typedef int32_t __socklen_t; +#else +/* LP64 still has a 32-bit socklen_t. */ +typedef uint32_t __socklen_t; +#endif +typedef __socklen_t socklen_t; + +typedef __builtin_va_list __va_list; + +#ifndef _SSIZE_T_DEFINED_ +#define _SSIZE_T_DEFINED_ +/* Traditionally, bionic's ssize_t was "long int". This caused GCC to emit warnings when you + * pass a ssize_t to a printf-style function. The correct type is __kernel_ssize_t, which is + * "int", which isn't an ABI change for C code (because they're the same size) but is an ABI + * change for C++ because "int" and "long int" mangle to "i" and "l" respectively. So until + * we can fix the ABI, this change should not be propagated to the NDK. http://b/8253769. */ +typedef __kernel_ssize_t ssize_t; +#endif + +typedef unsigned int uint_t; +typedef unsigned int uint; + +#if defined(__USE_BSD) || defined(__BIONIC__) /* Historically bionic exposed these. */ +#include <sys/sysmacros.h> + +typedef unsigned char u_char; +typedef unsigned short u_short; +typedef unsigned int u_int; +typedef unsigned long u_long; + +typedef uint32_t u_int32_t; +typedef uint16_t u_int16_t; +typedef uint8_t u_int8_t; +typedef uint64_t u_int64_t; +#endif + +#endif diff --git a/headers/sys/ucontext.h b/headers/sys/ucontext.h new file mode 100644 index 000000000..4eddf233c --- /dev/null +++ b/headers/sys/ucontext.h @@ -0,0 +1,313 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_UCONTEXT_H_ +#define _SYS_UCONTEXT_H_ + +#include <sys/cdefs.h> + +#include <signal.h> +#include <sys/user.h> + +__BEGIN_DECLS + +#if defined(__arm__) + +enum { + REG_R0 = 0, + REG_R1, + REG_R2, + REG_R3, + REG_R4, + REG_R5, + REG_R6, + REG_R7, + REG_R8, + REG_R9, + REG_R10, + REG_R11, + REG_R12, + REG_R13, + REG_R14, + REG_R15, +}; + +#define NGREG 18 /* Like glibc. */ + +typedef int greg_t; +typedef greg_t gregset_t[NGREG]; +typedef struct user_fpregs fpregset_t; + +#include <asm/sigcontext.h> +typedef struct sigcontext mcontext_t; + +typedef struct ucontext { + unsigned long uc_flags; + struct ucontext* uc_link; + stack_t uc_stack; + mcontext_t uc_mcontext; + sigset_t uc_sigmask; + /* Android has a wrong (smaller) sigset_t on ARM. */ + uint32_t __padding_rt_sigset; + /* The kernel adds extra padding after uc_sigmask to match glibc sigset_t on ARM. */ + char __padding[120]; + unsigned long uc_regspace[128] __attribute__((__aligned__(8))); +} ucontext_t; + +#elif defined(__aarch64__) + +#define NGREG 34 /* x0..x30 + sp + pc + pstate */ +typedef unsigned long greg_t; +typedef greg_t gregset_t[NGREG]; +typedef struct user_fpsimd_struct fpregset_t; + +#include <asm/sigcontext.h> +typedef struct sigcontext mcontext_t; + +typedef struct ucontext { + unsigned long uc_flags; + struct ucontext *uc_link; + stack_t uc_stack; + sigset_t uc_sigmask; + /* The kernel adds extra padding after uc_sigmask to match glibc sigset_t on ARM64. */ + char __padding[128 - sizeof(sigset_t)]; + mcontext_t uc_mcontext; +} ucontext_t; + +#elif defined(__i386__) + +enum { + REG_GS = 0, + REG_FS, + REG_ES, + REG_DS, + REG_EDI, + REG_ESI, + REG_EBP, + REG_ESP, + REG_EBX, + REG_EDX, + REG_ECX, + REG_EAX, + REG_TRAPNO, + REG_ERR, + REG_EIP, + REG_CS, + REG_EFL, + REG_UESP, + REG_SS, + NGREG +}; + +typedef int greg_t; +typedef greg_t gregset_t[NGREG]; + +struct _libc_fpreg { + unsigned short significand[4]; + unsigned short exponent; +}; + +struct _libc_fpstate { + unsigned long cw; + unsigned long sw; + unsigned long tag; + unsigned long ipoff; + unsigned long cssel; + unsigned long dataoff; + unsigned long datasel; + struct _libc_fpreg _st[8]; + unsigned long status; +}; + +typedef struct _libc_fpstate* fpregset_t; + +typedef struct { + gregset_t gregs; + fpregset_t fpregs; + unsigned long oldmask; + unsigned long cr2; +} mcontext_t; + +typedef struct ucontext { + unsigned long uc_flags; + struct ucontext* uc_link; + stack_t uc_stack; + mcontext_t uc_mcontext; + sigset_t uc_sigmask; + /* Android has a wrong (smaller) sigset_t on x86. */ + uint32_t __padding_rt_sigset; + struct _libc_fpstate __fpregs_mem; +} ucontext_t; + +#elif defined(__mips__) + +/* glibc doesn't have names for MIPS registers. */ + +#define NGREG 32 +#define NFPREG 32 + +typedef unsigned long long greg_t; +typedef greg_t gregset_t[NGREG]; + +typedef struct fpregset { + union { + double fp_dregs[NFPREG]; + struct { + float _fp_fregs; + unsigned _fp_pad; + } fp_fregs[NFPREG]; + } fp_r; +} fpregset_t; + +#ifdef __LP64__ +typedef struct { + gregset_t gregs; + fpregset_t fpregs; + greg_t mdhi; + greg_t hi1; + greg_t hi2; + greg_t hi3; + greg_t mdlo; + greg_t lo1; + greg_t lo2; + greg_t lo3; + greg_t pc; + uint32_t fpc_csr; + uint32_t used_math; + uint32_t dsp; + uint32_t reserved; +} mcontext_t; +#else +typedef struct { + unsigned regmask; + unsigned status; + greg_t pc; + gregset_t gregs; + fpregset_t fpregs; + unsigned fp_owned; + unsigned fpc_csr; + unsigned fpc_eir; + unsigned used_math; + unsigned dsp; + greg_t mdhi; + greg_t mdlo; + unsigned long hi1; + unsigned long lo1; + unsigned long hi2; + unsigned long lo2; + unsigned long hi3; + unsigned long lo3; +} mcontext_t; +#endif + +typedef struct ucontext { + unsigned long uc_flags; + struct ucontext* uc_link; + stack_t uc_stack; + mcontext_t uc_mcontext; + sigset_t uc_sigmask; +} ucontext_t; + +#elif defined(__x86_64__) + +enum { + REG_R8 = 0, + REG_R9, + REG_R10, + REG_R11, + REG_R12, + REG_R13, + REG_R14, + REG_R15, + REG_RDI, + REG_RSI, + REG_RBP, + REG_RBX, + REG_RDX, + REG_RAX, + REG_RCX, + REG_RSP, + REG_RIP, + REG_EFL, + REG_CSGSFS, + REG_ERR, + REG_TRAPNO, + REG_OLDMASK, + REG_CR2, + NGREG +}; + +typedef long greg_t; +typedef greg_t gregset_t[NGREG]; + +struct _libc_fpxreg { + unsigned short significand[4]; + unsigned short exponent; + unsigned short padding[3]; +}; + +struct _libc_xmmreg { + uint32_t element[4]; +}; + +struct _libc_fpstate { + uint16_t cwd; + uint16_t swd; + uint16_t ftw; + uint16_t fop; + uint64_t rip; + uint64_t rdp; + uint32_t mxcsr; + uint32_t mxcr_mask; + struct _libc_fpxreg _st[8]; + struct _libc_xmmreg _xmm[16]; + uint32_t padding[24]; +}; + +typedef struct _libc_fpstate* fpregset_t; + +typedef struct { + gregset_t gregs; + fpregset_t fpregs; + unsigned long __reserved1[8]; +} mcontext_t; + +typedef struct ucontext { + unsigned long uc_flags; + struct ucontext* uc_link; + stack_t uc_stack; + mcontext_t uc_mcontext; + sigset_t uc_sigmask; + struct _libc_fpstate __fpregs_mem; +} ucontext_t; + +#endif + +__END_DECLS + +#endif /* _SYS_UCONTEXT_H_ */ diff --git a/headers/sys/uio.h b/headers/sys/uio.h new file mode 100644 index 000000000..fb2701fc9 --- /dev/null +++ b/headers/sys/uio.h @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef _SYS_UIO_H_ +#define _SYS_UIO_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <linux/uio.h> + +__BEGIN_DECLS + +ssize_t readv(int, const struct iovec*, int); +ssize_t writev(int, const struct iovec*, int); + +#if defined(__USE_GNU) +#if defined(__USE_FILE_OFFSET64) +ssize_t preadv(int, const struct iovec*, int, off_t) __RENAME(preadv64); +ssize_t pwritev(int, const struct iovec*, int, off_t) __RENAME(pwritev64); +#else + +#if __ANDROID_API__ >= 24 +ssize_t preadv(int, const struct iovec*, int, off_t) __INTRODUCED_IN(24); +ssize_t pwritev(int, const struct iovec*, int, off_t) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + +#endif + +#if __ANDROID_API__ >= 24 +ssize_t preadv64(int, const struct iovec*, int, off64_t) __INTRODUCED_IN(24); +ssize_t pwritev64(int, const struct iovec*, int, off64_t) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + +#endif + +#if defined(__USE_GNU) + +#if __ANDROID_API__ >= 23 +ssize_t process_vm_readv(pid_t, const struct iovec*, unsigned long, const struct iovec*, + unsigned long, unsigned long) __INTRODUCED_IN(23); +ssize_t process_vm_writev(pid_t, const struct iovec*, unsigned long, const struct iovec*, + unsigned long, unsigned long) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +#endif + +__END_DECLS + +#endif /* _SYS_UIO_H_ */ diff --git a/headers/sys/un.h b/headers/sys/un.h new file mode 100644 index 000000000..3e1c429d7 --- /dev/null +++ b/headers/sys/un.h @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_UN_H_ +#define _SYS_UN_H_ + +#include <bits/sa_family_t.h> +#include <linux/un.h> +#include <sys/cdefs.h> + +#endif diff --git a/headers/sys/unistd.h b/headers/sys/unistd.h new file mode 100644 index 000000000..1e823fbd5 --- /dev/null +++ b/headers/sys/unistd.h @@ -0,0 +1 @@ +#include <unistd.h> diff --git a/headers/sys/user.h b/headers/sys/user.h new file mode 100644 index 000000000..f9ad9563e --- /dev/null +++ b/headers/sys/user.h @@ -0,0 +1,256 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_USER_H_ +#define _SYS_USER_H_ + +#include <sys/cdefs.h> +#include <stddef.h> /* For size_t. */ +#include <stdint.h> + +__BEGIN_DECLS + +#define PAGE_SIZE 4096 +#define PAGE_MASK (~(PAGE_SIZE - 1)) + +#if defined(__i386__) + +struct user_fpregs_struct { + long cwd; + long swd; + long twd; + long fip; + long fcs; + long foo; + long fos; + long st_space[20]; +}; +struct user_fpxregs_struct { + unsigned short cwd; + unsigned short swd; + unsigned short twd; + unsigned short fop; + long fip; + long fcs; + long foo; + long fos; + long mxcsr; + long reserved; + long st_space[32]; + long xmm_space[32]; + long padding[56]; +}; +struct user_regs_struct { + long ebx; + long ecx; + long edx; + long esi; + long edi; + long ebp; + long eax; + long xds; + long xes; + long xfs; + long xgs; + long orig_eax; + long eip; + long xcs; + long eflags; + long esp; + long xss; +}; +struct user { + struct user_regs_struct regs; + int u_fpvalid; + struct user_fpregs_struct i387; + unsigned long int u_tsize; + unsigned long int u_dsize; + unsigned long int u_ssize; + unsigned long start_code; + unsigned long start_stack; + long int signal; + int reserved; + struct user_regs_struct* u_ar0; + struct user_fpregs_struct* u_fpstate; + unsigned long magic; + char u_comm[32]; + int u_debugreg[8]; +}; + +#elif defined(__x86_64__) + +struct user_fpregs_struct { + unsigned short cwd; + unsigned short swd; + unsigned short ftw; + unsigned short fop; + unsigned long rip; + unsigned long rdp; + unsigned int mxcsr; + unsigned int mxcr_mask; + unsigned int st_space[32]; + unsigned int xmm_space[64]; + unsigned int padding[24]; +}; +struct user_regs_struct { + unsigned long r15; + unsigned long r14; + unsigned long r13; + unsigned long r12; + unsigned long rbp; + unsigned long rbx; + unsigned long r11; + unsigned long r10; + unsigned long r9; + unsigned long r8; + unsigned long rax; + unsigned long rcx; + unsigned long rdx; + unsigned long rsi; + unsigned long rdi; + unsigned long orig_rax; + unsigned long rip; + unsigned long cs; + unsigned long eflags; + unsigned long rsp; + unsigned long ss; + unsigned long fs_base; + unsigned long gs_base; + unsigned long ds; + unsigned long es; + unsigned long fs; + unsigned long gs; +}; +struct user { + struct user_regs_struct regs; + int u_fpvalid; + int pad0; + struct user_fpregs_struct i387; + unsigned long int u_tsize; + unsigned long int u_dsize; + unsigned long int u_ssize; + unsigned long start_code; + unsigned long start_stack; + long int signal; + int reserved; + int pad1; + struct user_regs_struct* u_ar0; + struct user_fpregs_struct* u_fpstate; + unsigned long magic; + char u_comm[32]; + unsigned long u_debugreg[8]; + unsigned long error_code; + unsigned long fault_address; +}; + +#elif defined(__mips__) + +struct user { + unsigned long regs[180 / sizeof(unsigned long) + 64]; + size_t u_tsize; + size_t u_dsize; + size_t u_ssize; + unsigned long start_code; + unsigned long start_data; + unsigned long start_stack; + long int signal; + void* u_ar0; + unsigned long magic; + char u_comm[32]; +}; + +#elif defined(__arm__) + +struct user_fpregs { + struct fp_reg { + unsigned int sign1:1; + unsigned int unused:15; + unsigned int sign2:1; + unsigned int exponent:14; + unsigned int j:1; + unsigned int mantissa1:31; + unsigned int mantissa0:32; + } fpregs[8]; + unsigned int fpsr:32; + unsigned int fpcr:32; + unsigned char ftype[8]; + unsigned int init_flag; +}; +struct user_regs { + unsigned long uregs[18]; +}; +struct user_vfp { + unsigned long long fpregs[32]; + unsigned long fpscr; +}; +struct user_vfp_exc { + unsigned long fpexc; + unsigned long fpinst; + unsigned long fpinst2; +}; +struct user { + struct user_regs regs; + int u_fpvalid; + unsigned long int u_tsize; + unsigned long int u_dsize; + unsigned long int u_ssize; + unsigned long start_code; + unsigned long start_stack; + long int signal; + int reserved; + struct user_regs* u_ar0; + unsigned long magic; + char u_comm[32]; + int u_debugreg[8]; + struct user_fpregs u_fp; + struct user_fpregs* u_fp0; +}; + +#elif defined(__aarch64__) + +struct user_regs_struct { + uint64_t regs[31]; + uint64_t sp; + uint64_t pc; + uint64_t pstate; +}; +struct user_fpsimd_struct { + __uint128_t vregs[32]; + uint32_t fpsr; + uint32_t fpcr; +}; + +#else + +#error "Unsupported architecture." + +#endif + +__END_DECLS + +#endif /* _SYS_USER_H_ */ diff --git a/headers/sys/utsname.h b/headers/sys/utsname.h new file mode 100644 index 000000000..b3856a704 --- /dev/null +++ b/headers/sys/utsname.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_UTSNAME_H_ +#define _SYS_UTSNAME_H_ + +#include <sys/cdefs.h> + +__BEGIN_DECLS + +#define SYS_NMLN 65 + +struct utsname { + char sysname [SYS_NMLN]; + char nodename [SYS_NMLN]; + char release [SYS_NMLN]; + char version [SYS_NMLN]; + char machine [SYS_NMLN]; + char domainname[SYS_NMLN]; +}; + +int uname(struct utsname*); + +__END_DECLS + +#endif /* _SYS_UTSNAME_H_ */ diff --git a/headers/sys/vfs.h b/headers/sys/vfs.h new file mode 100644 index 000000000..69b686337 --- /dev/null +++ b/headers/sys/vfs.h @@ -0,0 +1,155 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_VFS_H_ +#define _SYS_VFS_H_ + +#include <stdint.h> +#include <sys/cdefs.h> +#include <sys/types.h> + +__BEGIN_DECLS + +/* The kernel's __kernel_fsid_t has a 'val' member but glibc uses '__val'. */ +typedef struct { int __val[2]; } __fsid_t; +typedef __fsid_t fsid_t; + +#if defined(__aarch64__) || defined(__x86_64__) +#define __STATFS64_BODY \ + uint64_t f_type; \ + uint64_t f_bsize; \ + uint64_t f_blocks; \ + uint64_t f_bfree; \ + uint64_t f_bavail; \ + uint64_t f_files; \ + uint64_t f_ffree; \ + fsid_t f_fsid; \ + uint64_t f_namelen; \ + uint64_t f_frsize; \ + uint64_t f_flags; \ + uint64_t f_spare[4]; \ + +#elif defined(__mips__) && defined(__LP64__) +/* 64-bit MIPS. */ +#define __STATFS64_BODY \ + uint64_t f_type; \ + uint64_t f_bsize; \ + uint64_t f_frsize; /* Fragment size - unsupported. */ \ + uint64_t f_blocks; \ + uint64_t f_bfree; \ + uint64_t f_files; \ + uint64_t f_ffree; \ + uint64_t f_bavail; \ + fsid_t f_fsid; \ + uint64_t f_namelen; \ + uint64_t f_flags; \ + uint64_t f_spare[5]; \ + +#elif defined(__mips__) +/* 32-bit MIPS (corresponds to the kernel's statfs64 type). */ +#define __STATFS64_BODY \ + uint32_t f_type; \ + uint32_t f_bsize; \ + uint32_t f_frsize; \ + uint32_t __pad; \ + uint64_t f_blocks; \ + uint64_t f_bfree; \ + uint64_t f_files; \ + uint64_t f_ffree; \ + uint64_t f_bavail; \ + fsid_t f_fsid; \ + uint32_t f_namelen; \ + uint32_t f_flags; \ + uint32_t f_spare[5]; \ + +#else +/* 32-bit ARM or x86 (corresponds to the kernel's statfs64 type). */ +#define __STATFS64_BODY \ + uint32_t f_type; \ + uint32_t f_bsize; \ + uint64_t f_blocks; \ + uint64_t f_bfree; \ + uint64_t f_bavail; \ + uint64_t f_files; \ + uint64_t f_ffree; \ + fsid_t f_fsid; \ + uint32_t f_namelen; \ + uint32_t f_frsize; \ + uint32_t f_flags; \ + uint32_t f_spare[4]; \ + +#endif + +struct statfs { __STATFS64_BODY }; +struct statfs64 { __STATFS64_BODY }; + +#undef __STATFS64_BODY + +/* Declare that we have the f_namelen, f_frsize, and f_flags fields. */ +#define _STATFS_F_NAMELEN +#define _STATFS_F_FRSIZE +#define _STATFS_F_FLAGS + +/* Pull in the kernel magic numbers. */ +#include <linux/magic.h> +/* Add in ones that we had historically that aren't in the uapi header. */ +#define BEFS_SUPER_MAGIC 0x42465331 +#define BFS_MAGIC 0x1BADFACE +#define CIFS_MAGIC_NUMBER 0xFF534D42 +#define COH_SUPER_MAGIC 0x012FF7B7 +#define DEVFS_SUPER_MAGIC 0x1373 +#define EXT_SUPER_MAGIC 0x137D +#define EXT2_OLD_SUPER_MAGIC 0xEF51 +#define HFS_SUPER_MAGIC 0x4244 +#define JFS_SUPER_MAGIC 0x3153464a +#define NTFS_SB_MAGIC 0x5346544e +#define ROMFS_MAGIC 0x7275 +#define SYSV2_SUPER_MAGIC 0x012FF7B6 +#define SYSV4_SUPER_MAGIC 0x012FF7B5 +#define UDF_SUPER_MAGIC 0x15013346 +#define UFS_MAGIC 0x00011954 +#define VXFS_SUPER_MAGIC 0xa501FCF5 +#define XENIX_SUPER_MAGIC 0x012FF7B4 +#define XFS_SUPER_MAGIC 0x58465342 + +int statfs(const char* _Nonnull, struct statfs* _Nonnull); + +#if __ANDROID_API__ >= 21 +int statfs64(const char* _Nonnull, struct statfs64* _Nonnull) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int fstatfs(int, struct statfs* _Nonnull); + +#if __ANDROID_API__ >= 21 +int fstatfs64(int, struct statfs64* _Nonnull) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +__END_DECLS + +#endif /* _SYS_VFS_H_ */ diff --git a/headers/sys/vt.h b/headers/sys/vt.h new file mode 100644 index 000000000..834abfbc8 --- /dev/null +++ b/headers/sys/vt.h @@ -0,0 +1 @@ +#include <linux/vt.h> diff --git a/headers/sys/wait.h b/headers/sys/wait.h new file mode 100644 index 000000000..0247b2bce --- /dev/null +++ b/headers/sys/wait.h @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef _SYS_WAIT_H_ +#define _SYS_WAIT_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <sys/resource.h> +#include <linux/wait.h> +#include <signal.h> + +__BEGIN_DECLS + +#define WEXITSTATUS(s) (((s) & 0xff00) >> 8) +#define WCOREDUMP(s) ((s) & 0x80) +#define WTERMSIG(s) ((s) & 0x7f) +#define WSTOPSIG(s) WEXITSTATUS(s) + +#define WIFEXITED(s) (WTERMSIG(s) == 0) +#define WIFSTOPPED(s) (WTERMSIG(s) == 0x7f) +#define WIFSIGNALED(s) (WTERMSIG((s)+1) >= 2) +#define WIFCONTINUED(s) ((s) == 0xffff) + +#define W_EXITCODE(ret, sig) ((ret) << 8 | (sig)) +#define W_STOPCODE(sig) ((sig) << 8 | 0x7f) + +pid_t wait(int*); +pid_t waitpid(pid_t, int*, int); +#if __ANDROID_API__ >= __ANDROID_API_J_MR2__ +pid_t wait4(pid_t, int*, int, struct rusage*) __INTRODUCED_IN(18); +#else +// Implemented as a static inline before 18. +#endif + +/* Posix states that idtype_t should be an enumeration type, but + * the kernel headers define P_ALL, P_PID and P_PGID as constant macros + * instead. + */ +typedef int idtype_t; + +int waitid(idtype_t which, id_t id, siginfo_t* info, int options); + +__END_DECLS + +#include <android/legacy_sys_wait_inlines.h> + +#endif /* _SYS_WAIT_H_ */ diff --git a/headers/sys/xattr.h b/headers/sys/xattr.h new file mode 100644 index 000000000..a1ab742dc --- /dev/null +++ b/headers/sys/xattr.h @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYS_XATTR_H_ +#define _SYS_XATTR_H_ + +#include <linux/xattr.h> +#include <sys/cdefs.h> +#include <sys/types.h> + +__BEGIN_DECLS + + +#if __ANDROID_API__ >= 16 +int fsetxattr(int fd, const char* name, const void* value, size_t size, int flags) + __INTRODUCED_IN(16); +int setxattr(const char* path, const char* name, const void* value, size_t size, int flags) + __INTRODUCED_IN(16); +int lsetxattr(const char* path, const char* name, const void* value, size_t size, int flags) + __INTRODUCED_IN(16); + +ssize_t fgetxattr(int fd, const char* name, void* value, size_t size) __INTRODUCED_IN(16); +ssize_t getxattr(const char* path, const char* name, void* value, size_t size) __INTRODUCED_IN(16); +ssize_t lgetxattr(const char* path, const char* name, void* value, size_t size) __INTRODUCED_IN(16); + +ssize_t listxattr(const char* path, char* list, size_t size) __INTRODUCED_IN(16); +ssize_t llistxattr(const char* path, char* list, size_t size) __INTRODUCED_IN(16); +ssize_t flistxattr(int fd, char* list, size_t size) __INTRODUCED_IN(16); + +int removexattr(const char* path, const char* name) __INTRODUCED_IN(16); +int lremovexattr(const char* path, const char* name) __INTRODUCED_IN(16); +int fremovexattr(int fd, const char* name) __INTRODUCED_IN(16); +#endif /* __ANDROID_API__ >= 16 */ + + +__END_DECLS + +#endif /* _SYS_XATTR_H_ */ diff --git a/headers/syscall.h b/headers/syscall.h new file mode 100644 index 000000000..4c3057844 --- /dev/null +++ b/headers/syscall.h @@ -0,0 +1 @@ +#include <sys/syscall.h> diff --git a/headers/sysexits.h b/headers/sysexits.h new file mode 100644 index 000000000..97f5366ca --- /dev/null +++ b/headers/sysexits.h @@ -0,0 +1,121 @@ +/* $OpenBSD: sysexits.h,v 1.5 2003/06/02 19:34:12 millert Exp $ */ +/* $NetBSD: sysexits.h,v 1.4 1994/10/26 00:56:33 cgd Exp $ */ + +/* + * Copyright (c) 1987 Regents of the University of California. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)sysexits.h 4.8 (Berkeley) 4/3/91 + */ + +#ifndef _SYSEXITS_H_ +#define _SYSEXITS_H_ + +#include <sys/cdefs.h> + +/* + * SYSEXITS.H -- Exit status codes for system programs. + * + * This include file attempts to categorize possible error + * exit statuses for system programs, notably delivermail + * and the Berkeley network. + * + * Error numbers begin at EX__BASE to reduce the possibility of + * clashing with other exit statuses that random programs may + * already return. The meaning of the codes is approximately + * as follows: + * + * EX_USAGE -- The command was used incorrectly, e.g., with + * the wrong number of arguments, a bad flag, a bad + * syntax in a parameter, or whatever. + * EX_DATAERR -- The input data was incorrect in some way. + * This should only be used for user's data & not + * system files. + * EX_NOINPUT -- An input file (not a system file) did not + * exist or was not readable. This could also include + * errors like "No message" to a mailer (if it cared + * to catch it). + * EX_NOUSER -- The user specified did not exist. This might + * be used for mail addresses or remote logins. + * EX_NOHOST -- The host specified did not exist. This is used + * in mail addresses or network requests. + * EX_UNAVAILABLE -- A service is unavailable. This can occur + * if a support program or file does not exist. This + * can also be used as a catchall message when something + * you wanted to do doesn't work, but you don't know + * why. + * EX_SOFTWARE -- An internal software error has been detected. + * This should be limited to non-operating system related + * errors as possible. + * EX_OSERR -- An operating system error has been detected. + * This is intended to be used for such things as "cannot + * fork", "cannot create pipe", or the like. It includes + * things like getuid returning a user that does not + * exist in the passwd file. + * EX_OSFILE -- Some system file (e.g., /etc/passwd, /var/run/utmp, + * etc.) does not exist, cannot be opened, or has some + * sort of error (e.g., syntax error). + * EX_CANTCREAT -- A (user specified) output file cannot be + * created. + * EX_IOERR -- An error occurred while doing I/O on some file. + * EX_TEMPFAIL -- temporary failure, indicating something that + * is not really an error. In sendmail, this means + * that a mailer (e.g.) could not create a connection, + * and the request should be reattempted later. + * EX_PROTOCOL -- the remote system returned something that + * was "not possible" during a protocol exchange. + * EX_NOPERM -- You did not have sufficient permission to + * perform the operation. This is not intended for + * file system problems, which should use EX_NOINPUT or + * EX_CANTCREAT, but rather for higher level permissions. + * EX_CONFIG -- Something was found in an unconfigured or + * misconfigured state. + */ + +#define EX_OK 0 /* successful termination */ + +#define EX__BASE 64 /* base value for error messages */ + +#define EX_USAGE 64 /* command line usage error */ +#define EX_DATAERR 65 /* data format error */ +#define EX_NOINPUT 66 /* cannot open input */ +#define EX_NOUSER 67 /* addressee unknown */ +#define EX_NOHOST 68 /* host name unknown */ +#define EX_UNAVAILABLE 69 /* service unavailable */ +#define EX_SOFTWARE 70 /* internal software error */ +#define EX_OSERR 71 /* system error (e.g., can't fork) */ +#define EX_OSFILE 72 /* critical OS file missing */ +#define EX_CANTCREAT 73 /* can't create (user) output file */ +#define EX_IOERR 74 /* input/output error */ +#define EX_TEMPFAIL 75 /* temp failure; user is invited to retry */ +#define EX_PROTOCOL 76 /* remote error in protocol */ +#define EX_NOPERM 77 /* permission denied */ +#define EX_CONFIG 78 /* configuration error */ + +#define EX__MAX 78 /* maximum listed value */ + +#endif /* !_SYSEXITS_H_ */ diff --git a/headers/syslog.h b/headers/syslog.h new file mode 100644 index 000000000..4b7eecb24 --- /dev/null +++ b/headers/syslog.h @@ -0,0 +1,100 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SYSLOG_H +#define _SYSLOG_H + +#include <stdio.h> +#include <sys/cdefs.h> +#include <stdarg.h> + +__BEGIN_DECLS + +/* Priorities are translated to Android log priorities as shown. */ +#define LOG_EMERG 0 /* ERROR */ +#define LOG_ALERT 1 /* ERROR */ +#define LOG_CRIT 2 /* ERROR */ +#define LOG_ERR 3 /* ERROR */ +#define LOG_WARNING 4 /* WARN */ +#define LOG_NOTICE 5 /* INFO */ +#define LOG_INFO 6 /* INFO */ +#define LOG_DEBUG 7 /* DEBUG */ + +#define LOG_PRIMASK 7 +#define LOG_PRI(x) ((x) & LOG_PRIMASK) +#define LOG_MAKEPRI(fac, pri) ((fac) | (pri)) + +/* Facilities are currently ignored on Android. */ +#define LOG_KERN 0000 +#define LOG_USER 0010 +#define LOG_MAIL 0020 +#define LOG_DAEMON 0030 +#define LOG_AUTH 0040 +#define LOG_SYSLOG 0050 +#define LOG_LPR 0060 +#define LOG_NEWS 0070 +#define LOG_UUCP 0100 +#define LOG_CRON 0110 +#define LOG_AUTHPRIV 0120 +#define LOG_FTP 0130 +#define LOG_LOCAL0 0200 +#define LOG_LOCAL1 0210 +#define LOG_LOCAL2 0220 +#define LOG_LOCAL3 0230 +#define LOG_LOCAL4 0240 +#define LOG_LOCAL5 0250 +#define LOG_LOCAL6 0260 +#define LOG_LOCAL7 0270 + +#define LOG_FACMASK 01770 +#define LOG_FAC(x) (((x) >> 3) & (LOG_FACMASK >> 3)) + +#define LOG_MASK(pri) (1 << (pri)) +#define LOG_UPTO(pri) ((1 << ((pri)+1)) - 1) + +/* openlog(3) flags are currently ignored on Android. */ +#define LOG_PID 0x01 +#define LOG_CONS 0x02 +#define LOG_ODELAY 0x04 +#define LOG_NDELAY 0x08 +#define LOG_NOWAIT 0x10 +#define LOG_PERROR 0x20 + +void closelog(void); +void openlog(const char* _Nullable, int, int); +int setlogmask(int); +void syslog(int, const char* _Nonnull, ...) __printflike(2, 3); +#if defined(__arm__) || defined(__aarch64__) || defined(__x86_64__) +void vsyslog(int, const char* _Nonnull, va_list) __printflike(2, 0); +#else /* defined(__mips__) || defined(__i386__) */ +void vsyslog(int, const char* _Nonnull, va_list _Nonnull) __printflike(2, 0); +#endif + +__END_DECLS + +#endif /* _SYSLOG_H */ diff --git a/headers/tar.h b/headers/tar.h new file mode 100644 index 000000000..a5d7a36cd --- /dev/null +++ b/headers/tar.h @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _TAR_H_ +#define _TAR_H_ + +#include <sys/cdefs.h> + +#define TMAGIC "ustar" +#define TMAGLEN 6 +#define TVERSION "00" +#define TVERSLEN 2 + +#define REGTYPE '0' +#define AREGTYPE '\0' +#define LNKTYPE '1' +#define SYMTYPE '2' +#define CHRTYPE '3' +#define BLKTYPE '4' +#define DIRTYPE '5' +#define FIFOTYPE '6' +#define CONTTYPE '7' + +#define TSUID 04000 +#define TSGID 02000 +#define TSVTX 01000 +#define TUREAD 00400 +#define TUWRITE 00200 +#define TUEXEC 00100 +#define TGREAD 00040 +#define TGWRITE 00020 +#define TGEXEC 00010 +#define TOREAD 00004 +#define TOWRITE 00002 +#define TOEXEC 00001 + +#endif /* _TAR_H_ */ diff --git a/headers/termio.h b/headers/termio.h new file mode 100644 index 000000000..9e2695652 --- /dev/null +++ b/headers/termio.h @@ -0,0 +1 @@ +#include <termios.h> diff --git a/headers/termios.h b/headers/termios.h new file mode 100644 index 000000000..ab27d9d83 --- /dev/null +++ b/headers/termios.h @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef _TERMIOS_H_ +#define _TERMIOS_H_ + +#include <sys/cdefs.h> +#include <sys/ioctl.h> +#include <sys/types.h> +#include <linux/termios.h> + +__BEGIN_DECLS + +#if __ANDROID_API__ >= __ANDROID_API_L__ +// Implemented as static inlines before 21. +speed_t cfgetispeed(const struct termios*) __INTRODUCED_IN(21); +speed_t cfgetospeed(const struct termios*) __INTRODUCED_IN(21); +void cfmakeraw(struct termios*) __INTRODUCED_IN(21); +int cfsetispeed(struct termios*, speed_t) __INTRODUCED_IN(21); +int cfsetospeed(struct termios*, speed_t) __INTRODUCED_IN(21); +int tcflow(int, int) __INTRODUCED_IN(21); +int tcflush(int, int) __INTRODUCED_IN(21); +int tcgetattr(int, struct termios*) __INTRODUCED_IN(21); +pid_t tcgetsid(int) __INTRODUCED_IN(21); +int tcsendbreak(int, int) __INTRODUCED_IN(21); +int tcsetattr(int, int, const struct termios*) __INTRODUCED_IN(21); +#endif + + +#if __ANDROID_API__ >= 21 +int cfsetspeed(struct termios*, speed_t) __INTRODUCED_IN(21); +int tcdrain(int) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +__END_DECLS + +#include <android/legacy_termios_inlines.h> + +#endif /* _TERMIOS_H_ */ diff --git a/headers/time.h b/headers/time.h new file mode 100644 index 000000000..ea8e413bd --- /dev/null +++ b/headers/time.h @@ -0,0 +1,120 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _TIME_H_ +#define _TIME_H_ + +#include <sys/cdefs.h> +#include <sys/time.h> +#include <xlocale.h> + +__BEGIN_DECLS + +#define CLOCKS_PER_SEC 1000000 + +extern char* tzname[]; +extern int daylight; +extern long int timezone; + +struct sigevent; + +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; + const char* tm_zone; +}; + +#define TM_ZONE tm_zone + +time_t time(time_t*); +int nanosleep(const struct timespec*, struct timespec*); + +char* asctime(const struct tm*); +char* asctime_r(const struct tm*, char*); + +double difftime(time_t, time_t); +time_t mktime(struct tm*); + +struct tm* localtime(const time_t*); +struct tm* localtime_r(const time_t*, struct tm*); + +struct tm* gmtime(const time_t*); +struct tm* gmtime_r(const time_t*, struct tm*); + +char* strptime(const char*, const char*, struct tm*); +size_t strftime(char*, size_t, const char*, const struct tm*); + +#if __ANDROID_API__ >= __ANDROID_API_L__ +size_t strftime_l(char*, size_t, const char*, const struct tm*, locale_t) __INTRODUCED_IN(21); +#else +// Implemented as static inline before 21. +#endif + +char* ctime(const time_t*); +char* ctime_r(const time_t*, char*); + +void tzset(void); + +clock_t clock(void); + + +#if __ANDROID_API__ >= 23 +int clock_getcpuclockid(pid_t, clockid_t*) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +int clock_getres(clockid_t, struct timespec*); +int clock_gettime(clockid_t, struct timespec*); +int clock_nanosleep(clockid_t, int, const struct timespec*, struct timespec*); +int clock_settime(clockid_t, const struct timespec*); + +int timer_create(int, struct sigevent*, timer_t*); +int timer_delete(timer_t); +int timer_settime(timer_t, int, const struct itimerspec*, struct itimerspec*); +int timer_gettime(timer_t, struct itimerspec*); +int timer_getoverrun(timer_t); + +/* Non-standard extensions that are in the BSDs and glibc. */ + +#if __ANDROID_API__ >= 12 +time_t timelocal(struct tm*) __INTRODUCED_IN(12); +time_t timegm(struct tm*) __INTRODUCED_IN(12); +#endif /* __ANDROID_API__ >= 12 */ + + +__END_DECLS + +#endif /* _TIME_H_ */ diff --git a/headers/time64.h b/headers/time64.h new file mode 100644 index 000000000..905669d98 --- /dev/null +++ b/headers/time64.h @@ -0,0 +1,66 @@ +/* + +Copyright (c) 2007-2008 Michael G Schwern + +This software originally derived from Paul Sheer's pivotal_gmtime_r.c. + +The MIT License: + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +Origin: http://code.google.com/p/y2038 +Modified for Bionic by the Android Open Source Project + +*/ +#ifndef TIME64_H +#define TIME64_H + +#if defined(__LP64__) + +#error Your time_t is already 64-bit. + +#else + +/* Legacy cruft for LP32 where time_t was 32-bit. */ + +#include <sys/cdefs.h> +#include <time.h> +#include <stdint.h> + +__BEGIN_DECLS + +typedef int64_t time64_t; + +char* asctime64(const struct tm*); +char* asctime64_r(const struct tm*, char*); +char* ctime64(const time64_t*); +char* ctime64_r(const time64_t*, char*); +struct tm* gmtime64(const time64_t*); +struct tm* gmtime64_r(const time64_t*, struct tm*); +struct tm* localtime64(const time64_t*); +struct tm* localtime64_r(const time64_t*, struct tm*); +time64_t mktime64(const struct tm*); +time64_t timegm64(const struct tm*); +time64_t timelocal64(const struct tm*); + +__END_DECLS + +#endif + +#endif /* TIME64_H */ diff --git a/headers/uchar.h b/headers/uchar.h new file mode 100644 index 000000000..b523dc598 --- /dev/null +++ b/headers/uchar.h @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _UCHAR_H_ +#define _UCHAR_H_ + +#include <stddef.h> +#include <sys/cdefs.h> +#include <bits/mbstate_t.h> + +__BEGIN_DECLS + +#if !defined(__cplusplus) +typedef __CHAR16_TYPE__ char16_t; +typedef __CHAR32_TYPE__ char32_t; +#endif + +#define __STD_UTF_16__ 1 +#define __STD_UTF_32__ 1 + + +#if __ANDROID_API__ >= 21 +size_t c16rtomb(char* __restrict, char16_t, mbstate_t* __restrict) __INTRODUCED_IN(21); +size_t c32rtomb(char* __restrict, char32_t, mbstate_t* __restrict) __INTRODUCED_IN(21); +size_t mbrtoc16(char16_t* __restrict, const char* __restrict, size_t, mbstate_t* __restrict) + __INTRODUCED_IN(21); +size_t mbrtoc32(char32_t* __restrict, const char* __restrict, size_t, mbstate_t* __restrict) + __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +__END_DECLS + +#endif /* _UCHAR_H_ */ diff --git a/headers/ucontext.h b/headers/ucontext.h new file mode 100644 index 000000000..73c2166c8 --- /dev/null +++ b/headers/ucontext.h @@ -0,0 +1 @@ +#include <sys/ucontext.h> diff --git a/headers/unistd.h b/headers/unistd.h new file mode 100644 index 000000000..a1e23fcdc --- /dev/null +++ b/headers/unistd.h @@ -0,0 +1,640 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _UNISTD_H_ +#define _UNISTD_H_ + +#include <stddef.h> +#include <sys/cdefs.h> +#include <sys/types.h> +#include <sys/select.h> + +#include <bits/fcntl.h> +#include <bits/getopt.h> +#include <bits/ioctl.h> +#include <bits/lockf.h> +#include <bits/posix_limits.h> +#include <bits/seek_constants.h> +#include <bits/sysconf.h> + +__BEGIN_DECLS + +#define STDIN_FILENO 0 +#define STDOUT_FILENO 1 +#define STDERR_FILENO 2 + +#define F_OK 0 +#define X_OK 1 +#define W_OK 2 +#define R_OK 4 + +#define _PC_FILESIZEBITS 0 +#define _PC_LINK_MAX 1 +#define _PC_MAX_CANON 2 +#define _PC_MAX_INPUT 3 +#define _PC_NAME_MAX 4 +#define _PC_PATH_MAX 5 +#define _PC_PIPE_BUF 6 +#define _PC_2_SYMLINKS 7 +#define _PC_ALLOC_SIZE_MIN 8 +#define _PC_REC_INCR_XFER_SIZE 9 +#define _PC_REC_MAX_XFER_SIZE 10 +#define _PC_REC_MIN_XFER_SIZE 11 +#define _PC_REC_XFER_ALIGN 12 +#define _PC_SYMLINK_MAX 13 +#define _PC_CHOWN_RESTRICTED 14 +#define _PC_NO_TRUNC 15 +#define _PC_VDISABLE 16 +#define _PC_ASYNC_IO 17 +#define _PC_PRIO_IO 18 +#define _PC_SYNC_IO 19 + +extern char** environ; + +__noreturn void _exit(int __status); + +pid_t fork(void); +pid_t vfork(void); +pid_t getpid(void); +pid_t gettid(void) __attribute_const__; +pid_t getpgid(pid_t __pid); +int setpgid(pid_t __pid, pid_t __pgid); +pid_t getppid(void); +pid_t getpgrp(void); +int setpgrp(void); + +#if __ANDROID_API__ >= 17 +pid_t getsid(pid_t __pid) __INTRODUCED_IN(17); +#endif /* __ANDROID_API__ >= 17 */ + +pid_t setsid(void); + +int execv(const char* __path, char* const* __argv); +int execvp(const char* __file, char* const* __argv); + +#if __ANDROID_API__ >= 21 +int execvpe(const char* __file, char* const* __argv, char* const* __envp) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int execve(const char* __file, char* const* __argv, char* const* __envp); +int execl(const char* __path, const char* __arg0, ...) __attribute__((__sentinel__)); +int execlp(const char* __file, const char* __arg0, ...) __attribute__((__sentinel__)); +int execle(const char* __path, const char* __arg0, ... /*, char* const* __envp */) + __attribute__((__sentinel__(1))); + +int nice(int __incr); + +int setuid(uid_t __uid); +uid_t getuid(void); +int seteuid(uid_t __uid); +uid_t geteuid(void); +int setgid(gid_t __gid); +gid_t getgid(void); +int setegid(gid_t __gid); +gid_t getegid(void); +int getgroups(int __size, gid_t* __list); +int setgroups(size_t __size, const gid_t* __list); +int setreuid(uid_t __ruid, uid_t __euid); +int setregid(gid_t __rgid, gid_t __egid); +int setresuid(uid_t __ruid, uid_t __euid, uid_t __suid); +int setresgid(gid_t __rgid, gid_t __egid, gid_t __sgid); +int getresuid(uid_t* __ruid, uid_t* __euid, uid_t* __suid); +int getresgid(gid_t* __rgid, gid_t* __egid, gid_t* __sgid); +char* getlogin(void); + +long fpathconf(int __fd, int __name); +long pathconf(const char* __path, int __name); + +int access(const char* __path, int __mode); + +#if __ANDROID_API__ >= 16 +int faccessat(int __dirfd, const char* __path, int __mode, int __flags) __INTRODUCED_IN(16); +#endif /* __ANDROID_API__ >= 16 */ + +int link(const char* __oldpath, const char* __newpath); + +#if __ANDROID_API__ >= 21 +int linkat(int __olddirfd, const char* __oldpath, int __newdirfd, + const char* __newpath, int __flags) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int unlink(const char* __path); +int unlinkat(int __dirfd, const char* __path, int __flags); +int chdir(const char* __path); +int fchdir(int __fd); +int rmdir(const char* __path); +int pipe(int* __pipefd); +#if defined(__USE_GNU) +int pipe2(int* __pipefd, int __flags) __INTRODUCED_IN(9); +#endif +int chroot(const char* __path); +int symlink(const char* __oldpath, const char* __newpath); + +#if __ANDROID_API__ >= 21 +int symlinkat(const char* __oldpath, int __newdirfd, const char* __newpath) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +ssize_t readlink(const char* __path, char* __buf, size_t __bufsiz); + +#if __ANDROID_API__ >= 21 +ssize_t readlinkat(int __dirfd, const char* __path, char* __buf, + size_t __bufsiz) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int chown(const char* __path, uid_t __owner, gid_t __group); +int fchown(int __fd, uid_t __owner, gid_t __group); +int fchownat(int __dirfd, const char* __path, uid_t __owner, gid_t __group, int __flags); +int lchown(const char* __path, uid_t __owner, gid_t __group); +char* getcwd(char* __buf, size_t __size); + +void sync(void); + +int close(int __fd); + +ssize_t read(int __fd, void* __buf, size_t __count); +ssize_t write(int __fd, const void* __buf, size_t __count); + +int dup(int __oldfd); +int dup2(int __oldfd, int __newfd); + +#if __ANDROID_API__ >= 21 +int dup3(int __oldfd, int __newfd, int __flags) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int fsync(int __fd); +int fdatasync(int __fd) __INTRODUCED_IN(9); + +#if defined(__USE_FILE_OFFSET64) +off_t lseek(int __fd, off_t __offset, int __whence) __RENAME(lseek64); +#else +off_t lseek(int __fd, off_t __offset, int __whence); +#endif + +off64_t lseek64(int __fd, off64_t __offset, int __whence); + +#if defined(__USE_FILE_OFFSET64) && __ANDROID_API__ >= __ANDROID_API_L__ +int truncate(const char* __path, off_t __length) __RENAME(truncate64) __INTRODUCED_IN(21); +ssize_t pread(int __fd, void* __buf, size_t __count, off_t __offset) __RENAME(pread64) + __INTRODUCED_IN(12); +ssize_t pwrite(int __fd, const void* __buf, size_t __count, off_t __offset) + __RENAME(pwrite64) __INTRODUCED_IN(12); +int ftruncate(int __fd, off_t __length) __RENAME(ftruncate64) __INTRODUCED_IN(12); +#else +int truncate(const char* __path, off_t __length); +ssize_t pread(int __fd, void* __buf, size_t __count, off_t __offset); +ssize_t pwrite(int __fd, const void* __buf, size_t __count, off_t __offset); +int ftruncate(int __fd, off_t __length); +#endif + + +#if __ANDROID_API__ >= 21 +int truncate64(const char* __path, off64_t __length) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +#if __ANDROID_API__ >= 12 +ssize_t pread64(int __fd, void* __buf, size_t __count, off64_t __offset) __INTRODUCED_IN(12); +ssize_t pwrite64(int __fd, const void* __buf, size_t __count, off64_t __offset) + __INTRODUCED_IN(12); +int ftruncate64(int __fd, off64_t __length) __INTRODUCED_IN(12); +#endif /* __ANDROID_API__ >= 12 */ + + +int pause(void); +unsigned int alarm(unsigned int __seconds); +unsigned int sleep(unsigned int __seconds); +int usleep(useconds_t __usec); + +int gethostname(char* __name, size_t __len); + +#if __ANDROID_API__ >= 23 +int sethostname(const char* __name, size_t __len) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +int brk(void* __addr); +void* sbrk(ptrdiff_t __increment); + +int isatty(int __fd); +char* ttyname(int __fd); +int ttyname_r(int __fd, char* __buf, size_t __buflen) __INTRODUCED_IN(8); + +int acct(const char* __filepath); + +#if __ANDROID_API__ >= __ANDROID_API_L__ +int getpagesize(void) __INTRODUCED_IN(21); +#else +static __inline__ int getpagesize(void) { + return sysconf(_SC_PAGESIZE); +} +#endif + +long syscall(long __number, ...); + +int daemon(int __nochdir, int __noclose); + +#if defined(__arm__) || (defined(__mips__) && !defined(__LP64__)) +int cacheflush(long __addr, long __nbytes, long __cache); + /* __attribute__((deprecated("use __builtin___clear_cache instead"))); */ +#endif + +pid_t tcgetpgrp(int __fd); +int tcsetpgrp(int __fd, pid_t __pid); + +/* Used to retry syscalls that can return EINTR. */ +#define TEMP_FAILURE_RETRY(exp) ({ \ + __typeof__(exp) _rc; \ + do { \ + _rc = (exp); \ + } while (_rc == -1 && errno == EINTR); \ + _rc; }) + +/* TODO(unified-headers): Factor out all the FORTIFY features. */ + +#if __ANDROID_API__ >= 24 +char* __getcwd_chk(char*, size_t, size_t) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + +__errordecl(__getcwd_dest_size_error, "getcwd called with size bigger than destination"); +char* __getcwd_real(char*, size_t) __RENAME(getcwd); + + +#if __ANDROID_API__ >= 23 +ssize_t __pread_chk(int, void*, size_t, off_t, size_t) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +__errordecl(__pread_dest_size_error, "pread called with size bigger than destination"); +__errordecl(__pread_count_toobig_error, "pread called with count > SSIZE_MAX"); +ssize_t __pread_real(int, void*, size_t, off_t) __RENAME(pread); + + +#if __ANDROID_API__ >= 23 +ssize_t __pread64_chk(int, void*, size_t, off64_t, size_t) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +__errordecl(__pread64_dest_size_error, "pread64 called with size bigger than destination"); +__errordecl(__pread64_count_toobig_error, "pread64 called with count > SSIZE_MAX"); + +#if __ANDROID_API__ >= 12 +ssize_t __pread64_real(int, void*, size_t, off64_t) __RENAME(pread64) __INTRODUCED_IN(12); +#endif /* __ANDROID_API__ >= 12 */ + + + +#if __ANDROID_API__ >= 24 +ssize_t __pwrite_chk(int, const void*, size_t, off_t, size_t) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + +__errordecl(__pwrite_dest_size_error, "pwrite called with size bigger than destination"); +__errordecl(__pwrite_count_toobig_error, "pwrite called with count > SSIZE_MAX"); +ssize_t __pwrite_real(int, const void*, size_t, off_t) __RENAME(pwrite); + + +#if __ANDROID_API__ >= 24 +ssize_t __pwrite64_chk(int, const void*, size_t, off64_t, size_t) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + +__errordecl(__pwrite64_dest_size_error, "pwrite64 called with size bigger than destination"); +__errordecl(__pwrite64_count_toobig_error, "pwrite64 called with count > SSIZE_MAX"); + +#if __ANDROID_API__ >= 12 +ssize_t __pwrite64_real(int, const void*, size_t, off64_t) __RENAME(pwrite64) __INTRODUCED_IN(12); +#endif /* __ANDROID_API__ >= 12 */ + + + +#if __ANDROID_API__ >= 21 +ssize_t __read_chk(int, void*, size_t, size_t) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +__errordecl(__read_dest_size_error, "read called with size bigger than destination"); +__errordecl(__read_count_toobig_error, "read called with count > SSIZE_MAX"); +ssize_t __read_real(int, void*, size_t) __RENAME(read); + + +#if __ANDROID_API__ >= 24 +ssize_t __write_chk(int, const void*, size_t, size_t) __INTRODUCED_IN(24); +#endif /* __ANDROID_API__ >= 24 */ + +__errordecl(__write_dest_size_error, "write called with size bigger than destination"); +__errordecl(__write_count_toobig_error, "write called with count > SSIZE_MAX"); +ssize_t __write_real(int, const void*, size_t) __RENAME(write); + + +#if __ANDROID_API__ >= 23 +ssize_t __readlink_chk(const char*, char*, size_t, size_t) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +__errordecl(__readlink_dest_size_error, "readlink called with size bigger than destination"); +__errordecl(__readlink_size_toobig_error, "readlink called with size > SSIZE_MAX"); +ssize_t __readlink_real(const char*, char*, size_t) __RENAME(readlink); + + +#if __ANDROID_API__ >= 23 +ssize_t __readlinkat_chk(int dirfd, const char*, char*, size_t, size_t) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +__errordecl(__readlinkat_dest_size_error, "readlinkat called with size bigger than destination"); +__errordecl(__readlinkat_size_toobig_error, "readlinkat called with size > SSIZE_MAX"); + +#if __ANDROID_API__ >= 21 +ssize_t __readlinkat_real(int dirfd, const char*, char*, size_t) __RENAME(readlinkat) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +int getdomainname(char*, size_t) __INTRODUCED_IN_FUTURE; +int setdomainname(const char*, size_t) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + +#if defined(__BIONIC_FORTIFY) + +#if __ANDROID_API__ >= __ANDROID_API_N__ +__BIONIC_FORTIFY_INLINE +char* getcwd(char* buf, size_t size) { + size_t bos = __bos(buf); + +#if defined(__clang__) + /* + * Work around LLVM's incorrect __builtin_object_size implementation here + * to avoid needing the workaround in the __getcwd_chk ABI forever. + * + * https://llvm.org/bugs/show_bug.cgi?id=23277 + */ + if (buf == NULL) { + bos = __BIONIC_FORTIFY_UNKNOWN_SIZE; + } +#else + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __getcwd_real(buf, size); + } + + if (__builtin_constant_p(size) && (size > bos)) { + __getcwd_dest_size_error(); + } + + if (__builtin_constant_p(size) && (size <= bos)) { + return __getcwd_real(buf, size); + } +#endif + + return __getcwd_chk(buf, size, bos); +} +#endif /* __ANDROID_API__ >= __ANDROID_API_N__ */ + +#if defined(__USE_FILE_OFFSET64) +#define __PREAD_PREFIX(x) __pread64_ ## x +#else +#define __PREAD_PREFIX(x) __pread_ ## x +#endif + +#if __ANDROID_API__ >= __ANDROID_API_M__ +__BIONIC_FORTIFY_INLINE +ssize_t pread(int fd, void* buf, size_t count, off_t offset) { + size_t bos = __bos0(buf); + +#if !defined(__clang__) + if (__builtin_constant_p(count) && (count > SSIZE_MAX)) { + __PREAD_PREFIX(count_toobig_error)(); + } + + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __PREAD_PREFIX(real)(fd, buf, count, offset); + } + + if (__builtin_constant_p(count) && (count > bos)) { + __PREAD_PREFIX(dest_size_error)(); + } + + if (__builtin_constant_p(count) && (count <= bos)) { + return __PREAD_PREFIX(real)(fd, buf, count, offset); + } +#endif + + return __PREAD_PREFIX(chk)(fd, buf, count, offset, bos); +} + +__BIONIC_FORTIFY_INLINE +ssize_t pread64(int fd, void* buf, size_t count, off64_t offset) { + size_t bos = __bos0(buf); + +#if !defined(__clang__) + if (__builtin_constant_p(count) && (count > SSIZE_MAX)) { + __pread64_count_toobig_error(); + } + + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __pread64_real(fd, buf, count, offset); + } + + if (__builtin_constant_p(count) && (count > bos)) { + __pread64_dest_size_error(); + } + + if (__builtin_constant_p(count) && (count <= bos)) { + return __pread64_real(fd, buf, count, offset); + } +#endif + + return __pread64_chk(fd, buf, count, offset, bos); +} +#endif /* __ANDROID_API__ >= __ANDROID_API_M__ */ + +#if defined(__USE_FILE_OFFSET64) +#define __PWRITE_PREFIX(x) __pwrite64_ ## x +#else +#define __PWRITE_PREFIX(x) __pwrite_ ## x +#endif + +#if __ANDROID_API__ >= __ANDROID_API_N__ +__BIONIC_FORTIFY_INLINE +ssize_t pwrite(int fd, const void* buf, size_t count, off_t offset) { + size_t bos = __bos0(buf); + +#if !defined(__clang__) + if (__builtin_constant_p(count) && (count > SSIZE_MAX)) { + __PWRITE_PREFIX(count_toobig_error)(); + } + + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __PWRITE_PREFIX(real)(fd, buf, count, offset); + } + + if (__builtin_constant_p(count) && (count > bos)) { + __PWRITE_PREFIX(dest_size_error)(); + } + + if (__builtin_constant_p(count) && (count <= bos)) { + return __PWRITE_PREFIX(real)(fd, buf, count, offset); + } +#endif + + return __PWRITE_PREFIX(chk)(fd, buf, count, offset, bos); +} + +__BIONIC_FORTIFY_INLINE +ssize_t pwrite64(int fd, const void* buf, size_t count, off64_t offset) { + size_t bos = __bos0(buf); + +#if !defined(__clang__) + if (__builtin_constant_p(count) && (count > SSIZE_MAX)) { + __pwrite64_count_toobig_error(); + } + + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __pwrite64_real(fd, buf, count, offset); + } + + if (__builtin_constant_p(count) && (count > bos)) { + __pwrite64_dest_size_error(); + } + + if (__builtin_constant_p(count) && (count <= bos)) { + return __pwrite64_real(fd, buf, count, offset); + } +#endif + + return __pwrite64_chk(fd, buf, count, offset, bos); +} +#endif /* __ANDROID_API__ >= __ANDROID_API_N__ */ + +#if __ANDROID_API__ >= __ANDROID_API_L__ +__BIONIC_FORTIFY_INLINE +ssize_t read(int fd, void* buf, size_t count) { + size_t bos = __bos0(buf); + +#if !defined(__clang__) + if (__builtin_constant_p(count) && (count > SSIZE_MAX)) { + __read_count_toobig_error(); + } + + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __read_real(fd, buf, count); + } + + if (__builtin_constant_p(count) && (count > bos)) { + __read_dest_size_error(); + } + + if (__builtin_constant_p(count) && (count <= bos)) { + return __read_real(fd, buf, count); + } +#endif + + return __read_chk(fd, buf, count, bos); +} +#endif /* __ANDROID_API__ >= __ANDROID_API_L__ */ + +#if __ANDROID_API__ >= __ANDROID_API_N__ +__BIONIC_FORTIFY_INLINE +ssize_t write(int fd, const void* buf, size_t count) { + size_t bos = __bos0(buf); + +#if !defined(__clang__) +#if 0 /* work around a false positive due to a missed optimization */ + if (__builtin_constant_p(count) && (count > SSIZE_MAX)) { + __write_count_toobig_error(); + } +#endif + + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __write_real(fd, buf, count); + } + + if (__builtin_constant_p(count) && (count > bos)) { + __write_dest_size_error(); + } + + if (__builtin_constant_p(count) && (count <= bos)) { + return __write_real(fd, buf, count); + } +#endif + + return __write_chk(fd, buf, count, bos); +} +#endif /* __ANDROID_API__ >= __ANDROID_API_N__ */ + +#if __ANDROID_API__ >= __ANDROID_API_M__ +__BIONIC_FORTIFY_INLINE +ssize_t readlink(const char* path, char* buf, size_t size) { + size_t bos = __bos(buf); + +#if !defined(__clang__) + if (__builtin_constant_p(size) && (size > SSIZE_MAX)) { + __readlink_size_toobig_error(); + } + + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __readlink_real(path, buf, size); + } + + if (__builtin_constant_p(size) && (size > bos)) { + __readlink_dest_size_error(); + } + + if (__builtin_constant_p(size) && (size <= bos)) { + return __readlink_real(path, buf, size); + } +#endif + + return __readlink_chk(path, buf, size, bos); +} + +__BIONIC_FORTIFY_INLINE +ssize_t readlinkat(int dirfd, const char* path, char* buf, size_t size) { + size_t bos = __bos(buf); + +#if !defined(__clang__) + if (__builtin_constant_p(size) && (size > SSIZE_MAX)) { + __readlinkat_size_toobig_error(); + } + + if (bos == __BIONIC_FORTIFY_UNKNOWN_SIZE) { + return __readlinkat_real(dirfd, path, buf, size); + } + + if (__builtin_constant_p(size) && (size > bos)) { + __readlinkat_dest_size_error(); + } + + if (__builtin_constant_p(size) && (size <= bos)) { + return __readlinkat_real(dirfd, path, buf, size); + } +#endif + + return __readlinkat_chk(dirfd, path, buf, size, bos); +} +#endif /* __ANDROID_API__ >= __ANDROID_API_M__ */ + +#endif /* defined(__BIONIC_FORTIFY) */ + +__END_DECLS + +#endif /* _UNISTD_H_ */ diff --git a/headers/utime.h b/headers/utime.h new file mode 100644 index 000000000..978385994 --- /dev/null +++ b/headers/utime.h @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _UTIME_H_ +#define _UTIME_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <linux/utime.h> + +__BEGIN_DECLS + +int utime(const char*, const struct utimbuf*); + +__END_DECLS + +#endif /* _UTIME_H_ */ diff --git a/headers/utmp.h b/headers/utmp.h new file mode 100644 index 000000000..90433e3af --- /dev/null +++ b/headers/utmp.h @@ -0,0 +1,112 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef _UTMP_H_ +#define _UTMP_H_ + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <time.h> + +#define _PATH_UTMP "/var/run/utmp" +#define _PATH_WTMP "/var/log/wtmp" +#define _PATH_LASTLOG "/var/log/lastlog" + +#ifdef __LP64__ +#define UT_NAMESIZE 32 +#define UT_LINESIZE 32 +#define UT_HOSTSIZE 256 +#else +#define UT_NAMESIZE 8 +#define UT_LINESIZE 8 +#define UT_HOSTSIZE 16 +#endif + +#define EMPTY 0 +#define RUN_LVL 1 +#define BOOT_TIME 2 +#define NEW_TIME 3 +#define OLD_TIME 4 +#define INIT_PROCESS 5 +#define LOGIN_PROCESS 6 +#define USER_PROCESS 7 +#define DEAD_PROCESS 8 +#define ACCOUNTING 9 + +struct lastlog +{ + time_t ll_time; + char ll_line[UT_LINESIZE]; + char ll_host[UT_HOSTSIZE]; +}; + +struct exit_status +{ + short int e_termination; + short int e_exit; +}; + + +struct utmp +{ + short int ut_type; + pid_t ut_pid; + char ut_line[UT_LINESIZE]; + char ut_id[4]; + char ut_user[UT_NAMESIZE]; + char ut_host[UT_HOSTSIZE]; + + struct exit_status ut_exit; + + long int ut_session; + struct timeval ut_tv; + + int32_t ut_addr_v6[4]; + char unsed[20]; +}; + + +#define ut_name ut_user +#define ut_time ut_tv.tv_sec +#define ut_addr ut_addr_v6[0] + +__BEGIN_DECLS + +int utmpname(const char*); +void setutent(void); +struct utmp* getutent(void); +void endutent(void); + + +#if __ANDROID_API__ >= 23 +int login_tty(int) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + + +__END_DECLS + +#endif /* _UTMP_H_ */ diff --git a/headers/wait.h b/headers/wait.h new file mode 100644 index 000000000..d01b81125 --- /dev/null +++ b/headers/wait.h @@ -0,0 +1 @@ +#include <sys/wait.h> diff --git a/headers/wchar.h b/headers/wchar.h new file mode 100644 index 000000000..2197e70c6 --- /dev/null +++ b/headers/wchar.h @@ -0,0 +1,204 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#ifndef _WCHAR_H_ +#define _WCHAR_H_ + +#include <sys/cdefs.h> +#include <stdio.h> + +#include <stdarg.h> +#include <stddef.h> +#include <time.h> +#include <xlocale.h> + +#include <bits/mbstate_t.h> +#include <bits/wchar_limits.h> +#include <bits/wctype.h> + +__BEGIN_DECLS + +enum { + WC_TYPE_INVALID = 0, + WC_TYPE_ALNUM, + WC_TYPE_ALPHA, + WC_TYPE_BLANK, + WC_TYPE_CNTRL, + WC_TYPE_DIGIT, + WC_TYPE_GRAPH, + WC_TYPE_LOWER, + WC_TYPE_PRINT, + WC_TYPE_PUNCT, + WC_TYPE_SPACE, + WC_TYPE_UPPER, + WC_TYPE_XDIGIT, + WC_TYPE_MAX +}; + +wint_t btowc(int); +int fwprintf(FILE *, const wchar_t *, ...); +int fwscanf(FILE *, const wchar_t *, ...); +wint_t fgetwc(FILE *); +wchar_t *fgetws(wchar_t *, int, FILE *); +wint_t fputwc(wchar_t, FILE *); +int fputws(const wchar_t *, FILE *); +int fwide(FILE *, int); +wint_t getwc(FILE *); +wint_t getwchar(void); +int mbsinit(const mbstate_t *); +size_t mbrlen(const char *, size_t, mbstate_t *); +size_t mbrtowc(wchar_t *, const char *, size_t, mbstate_t *); +size_t mbsrtowcs(wchar_t*, const char**, size_t, mbstate_t*); + +#if __ANDROID_API__ >= 21 +size_t mbsnrtowcs(wchar_t*, const char**, size_t, size_t, mbstate_t*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +wint_t putwc(wchar_t, FILE *); +wint_t putwchar(wchar_t); +int swprintf(wchar_t *, size_t, const wchar_t *, ...); +int swscanf(const wchar_t *, const wchar_t *, ...); +wint_t ungetwc(wint_t, FILE *); +int vfwprintf(FILE*, const wchar_t*, va_list); + +#if __ANDROID_API__ >= 21 +int vfwscanf(FILE*, const wchar_t*, va_list) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int vswprintf(wchar_t*, size_t, const wchar_t*, va_list); + +#if __ANDROID_API__ >= 21 +int vswscanf(const wchar_t*, const wchar_t*, va_list) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int vwprintf(const wchar_t*, va_list); + +#if __ANDROID_API__ >= 21 +int vwscanf(const wchar_t*, va_list) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +wchar_t* wcpcpy (wchar_t*, const wchar_t *); +wchar_t* wcpncpy (wchar_t*, const wchar_t *, size_t); +size_t wcrtomb(char *, wchar_t, mbstate_t *); +int wcscasecmp(const wchar_t *, const wchar_t *); + +#if __ANDROID_API__ >= 23 +int wcscasecmp_l(const wchar_t*, const wchar_t*, locale_t) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +wchar_t *wcscat(wchar_t *, const wchar_t *); +wchar_t *wcschr(const wchar_t *, wchar_t); +int wcscmp(const wchar_t *, const wchar_t *); +int wcscoll(const wchar_t *, const wchar_t *); +wchar_t *wcscpy(wchar_t *, const wchar_t *); +size_t wcscspn(const wchar_t *, const wchar_t *); +size_t wcsftime(wchar_t *, size_t, const wchar_t *, const struct tm *); +size_t wcslen(const wchar_t *); +int wcsncasecmp(const wchar_t *, const wchar_t *, size_t); + +#if __ANDROID_API__ >= 23 +int wcsncasecmp_l(const wchar_t*, const wchar_t*, size_t, locale_t) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +wchar_t *wcsncat(wchar_t *, const wchar_t *, size_t); +int wcsncmp(const wchar_t *, const wchar_t *, size_t); +wchar_t *wcsncpy(wchar_t *, const wchar_t *, size_t); + +#if __ANDROID_API__ >= 21 +size_t wcsnrtombs(char*, const wchar_t**, size_t, size_t, mbstate_t*) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +wchar_t *wcspbrk(const wchar_t *, const wchar_t *); +wchar_t *wcsrchr(const wchar_t *, wchar_t); +size_t wcsrtombs(char*, const wchar_t**, size_t, mbstate_t*); +size_t wcsspn(const wchar_t *, const wchar_t *); +wchar_t *wcsstr(const wchar_t *, const wchar_t *); +double wcstod(const wchar_t*, wchar_t**); + +#if __ANDROID_API__ >= 21 +float wcstof(const wchar_t*, wchar_t**) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +wchar_t* wcstok(wchar_t*, const wchar_t*, wchar_t**); +long wcstol(const wchar_t*, wchar_t**, int); + +#if __ANDROID_API__ >= 21 +long long wcstoll(const wchar_t*, wchar_t**, int) __INTRODUCED_IN(21); +long double wcstold(const wchar_t*, wchar_t**) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +unsigned long wcstoul(const wchar_t*, wchar_t**, int); + +#if __ANDROID_API__ >= 21 +unsigned long long wcstoull(const wchar_t*, wchar_t**, int) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + +int wcswidth(const wchar_t *, size_t); +size_t wcsxfrm(wchar_t *, const wchar_t *, size_t); +int wctob(wint_t); +int wcwidth(wchar_t); +wchar_t *wmemchr(const wchar_t *, wchar_t, size_t); +int wmemcmp(const wchar_t *, const wchar_t *, size_t); +wchar_t *wmemcpy(wchar_t *, const wchar_t *, size_t); +#if defined(__USE_GNU) + +#if __ANDROID_API__ >= 23 +wchar_t* wmempcpy(wchar_t*, const wchar_t*, size_t) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +#endif +wchar_t *wmemmove(wchar_t *, const wchar_t *, size_t); +wchar_t *wmemset(wchar_t *, wchar_t, size_t); +int wprintf(const wchar_t *, ...); +int wscanf(const wchar_t *, ...); + +#if __ANDROID_API__ >= __ANDROID_API_L__ +long long wcstoll_l(const wchar_t*, wchar_t**, int, locale_t) __INTRODUCED_IN(21); +unsigned long long wcstoull_l(const wchar_t*, wchar_t**, int, locale_t) __INTRODUCED_IN(21); +long double wcstold_l(const wchar_t*, wchar_t**, locale_t) __INTRODUCED_IN(21); + +int wcscoll_l(const wchar_t* _Nonnull, const wchar_t* _Nonnull, locale_t) __attribute_pure__ + __INTRODUCED_IN(21); +size_t wcsxfrm_l(wchar_t*, const wchar_t* _Nonnull, size_t, locale_t) __INTRODUCED_IN(21); +#else +// Implemented as static inlines before 21. +#endif + +size_t wcslcat(wchar_t*, const wchar_t*, size_t); +size_t wcslcpy(wchar_t*, const wchar_t*, size_t); + + +#if __ANDROID_API__ >= 23 +FILE* open_wmemstream(wchar_t**, size_t*) __INTRODUCED_IN(23); +#endif /* __ANDROID_API__ >= 23 */ + +wchar_t* wcsdup(const wchar_t*); +size_t wcsnlen(const wchar_t*, size_t); + +__END_DECLS + +#endif /* _WCHAR_H_ */ diff --git a/headers/wctype.h b/headers/wctype.h new file mode 100644 index 000000000..5f53153ec --- /dev/null +++ b/headers/wctype.h @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _WCTYPE_H_ +#define _WCTYPE_H_ + +#include <bits/wctype.h> +#include <sys/cdefs.h> +#include <xlocale.h> + +__BEGIN_DECLS + +#if __ANDROID_API__ >= __ANDROID_API_L__ +int iswalnum_l(wint_t, locale_t) __INTRODUCED_IN(21); +int iswalpha_l(wint_t, locale_t) __INTRODUCED_IN(21); +int iswblank_l(wint_t, locale_t) __INTRODUCED_IN(21); +int iswcntrl_l(wint_t, locale_t) __INTRODUCED_IN(21); +int iswdigit_l(wint_t, locale_t) __INTRODUCED_IN(21); +int iswgraph_l(wint_t, locale_t) __INTRODUCED_IN(21); +int iswlower_l(wint_t, locale_t) __INTRODUCED_IN(21); +int iswprint_l(wint_t, locale_t) __INTRODUCED_IN(21); +int iswpunct_l(wint_t, locale_t) __INTRODUCED_IN(21); +int iswspace_l(wint_t, locale_t) __INTRODUCED_IN(21); +int iswupper_l(wint_t, locale_t) __INTRODUCED_IN(21); +int iswxdigit_l(wint_t, locale_t) __INTRODUCED_IN(21); + +wint_t towlower_l(wint_t, locale_t) __INTRODUCED_IN(21); +wint_t towupper_l(wint_t, locale_t) __INTRODUCED_IN(21); +#else +// Implemented as static inlines before 21. +#endif + + +#if __ANDROID_API__ >= __ANDROID_API_FUTURE__ +wint_t towctrans_l(wint_t, wctrans_t, locale_t) __INTRODUCED_IN_FUTURE; +wctrans_t wctrans_l(const char*, locale_t) __INTRODUCED_IN_FUTURE; +#endif /* __ANDROID_API__ >= __ANDROID_API_FUTURE__ */ + + + +#if __ANDROID_API__ >= 21 +wctype_t wctype_l(const char*, locale_t) __INTRODUCED_IN(21); +int iswctype_l(wint_t, wctype_t, locale_t) __INTRODUCED_IN(21); +#endif /* __ANDROID_API__ >= 21 */ + + +__END_DECLS + +#endif /* _WCTYPE_H_ */ diff --git a/headers/xlocale.h b/headers/xlocale.h new file mode 100644 index 000000000..559d24d68 --- /dev/null +++ b/headers/xlocale.h @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _XLOCALE_H_ +#define _XLOCALE_H_ + +#include <sys/cdefs.h> + +/* If we just use void* here, GCC exposes that in error messages. */ +struct __locale_t; +typedef struct __locale_t* locale_t; + +#endif /* _XLOCALE_H_ */ |