Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-02-27 15:07
📄 FlexLexer.h // --C++-- // FlexLexer.h -- define interfaces for lexical analyzer classes generated // by flex // Copyright (c) 1993 The Regents of the University of California. // All rights reserved. // // This code is derived from software contributed to Berkeley by // Kent Williams and Tom Epperly. // // 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. // 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 ``AS IS'' AND WITHOUT ANY EXPRESS OR // IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR // PURPOSE. // This file defines FlexLexer, an abstract class which specifies the // external interface provided to flex C++ lexer objects, and yyFlexLexer, // which defines a particular lexer class. // // If you want to create multiple lexer classes, you use the -P flag // to rename each yyFlexLexer to some other xxFlexLexer. You then // include <FlexLexer.h> in your other sources once per lexer class: // // #undef yyFlexLexer // #define yyFlexLexer xxFlexLexer // #include <FlexLexer.h> // // #undef yyFlexLexer // #define yyFlexLexer zzFlexLexer // #include <FlexLexer.h> // ... #ifndef __FLEX_LEXER_H // Never included before - need to define base class. #define __FLEX_LEXER_H #include <iostream> extern "C++" { struct yy_buffer_state; typedef int yy_state_type; class FlexLexer { public: virtual ~FlexLexer() { } const char* YYText() const { return yytext; } int YYLeng() const { return yyleng; } virtual void yy_switch_to_buffer( yy_buffer_state* new_buffer ) = 0; virtual yy_buffer_state* yy_create_buffer( std::istream* s, int size ) = 0; virtual yy_buffer_state* yy_create_buffer( std::istream& s, int size ) = 0; virtual void yy_delete_buffer( yy_buffer_state* b ) = 0; virtual void yyrestart( std::istream* s ) = 0; virtual void yyrestart( std::istream& s ) = 0; virtual int yylex() = 0; // Call yylex with new input/output sources. int yylex( std::istream& new_in, std::ostream& new_out ) { switch_streams( new_in, new_out ); return yylex(); } int yylex( std::istream* new_in, std::ostream* new_out = 0) { switch_streams( new_in, new_out ); return yylex(); } // Switch to new input/output streams. A nil stream pointer // indicates "keep the current one". virtual void switch_streams( std::istream* new_in, std::ostream* new_out ) = 0; virtual void switch_streams( std::istream& new_in, std::ostream& new_out ) = 0; int lineno() const { return yylineno; } int debug() const { return yy_flex_debug; } void set_debug( int flag ) { yy_flex_debug = flag; } protected: char* yytext; int yyleng; int yylineno; // only maintained if you use %option yylineno int yy_flex_debug; // only has effect with -d or "%option debug" }; } #endif // FLEXLEXER_H #if defined(yyFlexLexer) \|\| ! defined(yyFlexLexerOnce) // Either this is the first time through (yyFlexLexerOnce not defined), // or this is a repeated include to define a different flavor of // yyFlexLexer, as discussed in the flex manual. # define yyFlexLexerOnce extern "C++" { class yyFlexLexer : public FlexLexer { public: // arg_yyin and arg_yyout default to the cin and cout, but we // only make that assignment when initializing in yylex(). yyFlexLexer( std::istream& arg_yyin, std::ostream& arg_yyout ); yyFlexLexer( std::istream* arg_yyin = 0, std::ostream* arg_yyout = 0 ); private: void ctor_common(); public: virtual ~yyFlexLexer(); void yy_switch_to_buffer( yy_buffer_state* new_buffer ); yy_buffer_state* yy_create_buffer( std::istream* s, int size ); yy_buffer_state* yy_create_buffer( std::istream& s, int size ); void yy_delete_buffer( yy_buffer_state* b ); void yyrestart( std::istream* s ); void yyrestart( std::istream& s ); void yypush_buffer_state( yy_buffer_state* new_buffer ); void yypop_buffer_state(); virtual int yylex(); virtual void switch_streams( std::istream& new_in, std::ostream& new_out ); virtual void switch_streams( std::istream* new_in = 0, std::ostream* new_out = 0 ); virtual int yywrap(); protected: virtual int LexerInput( char* buf, int max_size ); virtual void LexerOutput( const char* buf, int size ); virtual void LexerError( const char* msg ); void yyunput( int c, char* buf_ptr ); int yyinput(); void yy_load_buffer_state(); void yy_init_buffer( yy_buffer_state* b, std::istream& s ); void yy_flush_buffer( yy_buffer_state* b ); int yy_start_stack_ptr; int yy_start_stack_depth; int* yy_start_stack; void yy_push_state( int new_state ); void yy_pop_state(); int yy_top_state(); yy_state_type yy_get_previous_state(); yy_state_type yy_try_NUL_trans( yy_state_type current_state ); int yy_get_next_buffer(); std::istream yyin; // input source for default LexerInput std::ostream yyout; // output sink for default LexerOutput // yy_hold_char holds the character lost when yytext is formed. char yy_hold_char; // Number of characters read into yy_ch_buf. int yy_n_chars; // Points to current character in buffer. char* yy_c_buf_p; int yy_init; // whether we need to initialize int yy_start; // start state number // Flag which is used to allow yywrap()'s to do buffer switches // instead of setting up a fresh yyin. A bit of a hack ... int yy_did_buffer_switch_on_eof; size_t yy_buffer_stack_top; /*< index of top of stack. / size_t yy_buffer_stack_max; /*< capacity of stack. / yy_buffer_state yy_buffer_stack; /< Stack as an array. / void yyensure_buffer_stack(void); // The following are not always needed, but may be depending // on use of certain flex features (like REJECT or yymore()). yy_state_type yy_last_accepting_state; char yy_last_accepting_cpos; yy_state_type* yy_state_buf; yy_state_type* yy_state_ptr; char* yy_full_match; int* yy_full_state; int yy_full_lp; int yy_lp; int yy_looking_for_trail_begin; int yy_more_flag; int yy_more_len; int yy_more_offset; int yy_prev_more_offset; }; } #endif // yyFlexLexer \|\| ! yyFlexLexerOnce	6.73 KB	2022-01-30 08:23
📄 GeoIP.h /* -- Mode: C; indent-tabs-mode: t; c-basic-offset: 2; tab-width: 2 -- / / GeoIP.h * * Copyright (C) 2016 MaxMind, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA / #ifndef GEOIP_H #define GEOIP_H #ifdef __cplusplus extern "C" { #endif #include <sys/types.h> #if !defined(_WIN32) #include <arpa/inet.h> #include <netinet/in.h> #include <sys/socket.h> #else / !defined(_WIN32) / #include <winsock2.h> #include <ws2tcpip.h> #define FILETIME_TO_USEC(ft) \ (((unsigned __int64)ft.dwHighDateTime << 32 \| ft.dwLowDateTime) / 10) #endif / !defined(_WIN32) / #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/stat.h> / for fstat / #include <sys/types.h> / for fstat / #define SEGMENT_RECORD_LENGTH 3 #define LARGE_SEGMENT_RECORD_LENGTH 4 #define STANDARD_RECORD_LENGTH 3 #define ORG_RECORD_LENGTH 4 #define MAX_RECORD_LENGTH 4 #define NUM_DB_TYPES (38 + 1) / 128 bit address in network order / typedef struct in6_addr geoipv6_t; #define GEOIP_CHKBIT_V6(bit, ptr) \ (ptr[((127UL - bit) >> 3)] & (1UL << (~(127 - bit) & 7))) typedef struct GeoIPTag { FILE GeoIPDatabase; char file_path; unsigned char cache; unsigned char index_cache; unsigned int databaseSegments; char databaseType; time_t mtime; int flags; off_t size; char record_length; int charset; /* 0 iso-8859-1 1 utf8 / int record_iter; / used in GeoIP_next_record / int netmask; / netmask of last lookup - set using depth in _GeoIP_seek_record / time_t last_mtime_check; off_t dyn_seg_size; / currently only used by the cityconfidence database / unsigned int ext_flags; / bit 0 teredo support enabled / } GeoIP; typedef struct GeoIPLookup { int netmask; } GeoIPLookup; typedef enum { GEOIP_TEREDO_BIT = 0 } GeoIPExtFlags; typedef enum { GEOIP_CHARSET_ISO_8859_1 = 0, GEOIP_CHARSET_UTF8 = 1 } GeoIPCharset; typedef struct GeoIPRegionTag { char country_code[3]; char region[3]; } GeoIPRegion; typedef enum { GEOIP_STANDARD = 0, GEOIP_MEMORY_CACHE = 1, GEOIP_CHECK_CACHE = 2, GEOIP_INDEX_CACHE = 4, GEOIP_MMAP_CACHE = 8, GEOIP_SILENCE = 16, } GeoIPOptions; typedef enum { GEOIP_COUNTRY_EDITION = 1, GEOIP_REGION_EDITION_REV0 = 7, GEOIP_CITY_EDITION_REV0 = 6, GEOIP_ORG_EDITION = 5, GEOIP_ISP_EDITION = 4, GEOIP_CITY_EDITION_REV1 = 2, GEOIP_REGION_EDITION_REV1 = 3, GEOIP_PROXY_EDITION = 8, GEOIP_ASNUM_EDITION = 9, GEOIP_NETSPEED_EDITION = 10, GEOIP_DOMAIN_EDITION = 11, GEOIP_COUNTRY_EDITION_V6 = 12, GEOIP_LOCATIONA_EDITION = 13, GEOIP_ACCURACYRADIUS_EDITION = 14, GEOIP_CITYCONFIDENCE_EDITION = 15, / unsupported / GEOIP_CITYCONFIDENCEDIST_EDITION = 16, / unsupported / GEOIP_LARGE_COUNTRY_EDITION = 17, GEOIP_LARGE_COUNTRY_EDITION_V6 = 18, GEOIP_CITYCONFIDENCEDIST_ISP_ORG_EDITION = 19, / unused, but gaps are not allowed / GEOIP_CCM_COUNTRY_EDITION = 20, / unused, but gaps are not allowed / GEOIP_ASNUM_EDITION_V6 = 21, GEOIP_ISP_EDITION_V6 = 22, GEOIP_ORG_EDITION_V6 = 23, GEOIP_DOMAIN_EDITION_V6 = 24, GEOIP_LOCATIONA_EDITION_V6 = 25, GEOIP_REGISTRAR_EDITION = 26, GEOIP_REGISTRAR_EDITION_V6 = 27, GEOIP_USERTYPE_EDITION = 28, GEOIP_USERTYPE_EDITION_V6 = 29, GEOIP_CITY_EDITION_REV1_V6 = 30, GEOIP_CITY_EDITION_REV0_V6 = 31, GEOIP_NETSPEED_EDITION_REV1 = 32, GEOIP_NETSPEED_EDITION_REV1_V6 = 33, GEOIP_COUNTRYCONF_EDITION = 34, GEOIP_CITYCONF_EDITION = 35, GEOIP_REGIONCONF_EDITION = 36, GEOIP_POSTALCONF_EDITION = 37, GEOIP_ACCURACYRADIUS_EDITION_V6 = 38 } GeoIPDBTypes; typedef enum { GEOIP_ANON_PROXY = 1, GEOIP_HTTP_X_FORWARDED_FOR_PROXY = 2, GEOIP_HTTP_CLIENT_IP_PROXY = 3, } GeoIPProxyTypes; typedef enum { GEOIP_UNKNOWN_SPEED = 0, GEOIP_DIALUP_SPEED = 1, GEOIP_CABLEDSL_SPEED = 2, GEOIP_CORPORATE_SPEED = 3, } GeoIPNetspeedValues; #if defined(_WIN32) && !defined(__MINGW32__) #ifdef GEOIP_EXPORTS #define GEOIP_API __declspec(dllexport) #define GEOIP_DATA __declspec(dllexport) #else #define GEOIP_DATA __declspec(dllimport) #define GEOIP_API #endif / GEOIP_EXPORTS / #else #define GEOIP_API #define GEOIP_DATA #endif extern char GeoIPDBFileName; extern GEOIP_DATA const char GeoIPDBDescription[NUM_DB_TYPES]; extern GEOIP_DATA const char GeoIPCountryDBFileName; extern GEOIP_DATA const char GeoIPRegionDBFileName; extern GEOIP_DATA const char GeoIPCityDBFileName; extern GEOIP_DATA const char GeoIPOrgDBFileName; extern GEOIP_DATA const char GeoIPISPDBFileName; extern GEOIP_DATA const char GeoIPLocationADBFileName; extern GEOIP_DATA const char GeoIPAccuracyRadiusFileName; extern GEOIP_DATA const char GeoIPCityConfidenceFileName; extern char GeoIP_custom_directory; / Warning: do not use those arrays as doing so may break your * program with newer GeoIP versions / extern GEOIP_DATA const char GeoIP_country_code[256][3]; extern GEOIP_DATA const char GeoIP_country_code3[256][4]; extern GEOIP_DATA const char GeoIP_country_name[256]; extern GEOIP_DATA const char GeoIP_utf8_country_name[256]; extern GEOIP_DATA const char GeoIP_country_continent[256][3]; GEOIP_API void GeoIP_setup_custom_directory(char dir); GEOIP_API GeoIP GeoIP_open_type(int type, int flags); GEOIP_API GeoIP GeoIP_new(int flags); GEOIP_API GeoIP GeoIP_open(const char filename, int flags); /* * WARNING: GeoIP_db_avail() checks for the existence of a database * file but does not check that it has the requested database revision. * For database types which have more than one revision (including Region, * City, and Cityv6), this can lead to unexpected results. Check the * return value of GeoIP_open_type() to find out whether a particular * database type is really available. / GEOIP_API int GeoIP_db_avail(int type); GEOIP_API void GeoIP_delete(GeoIP gi); GEOIP_API const char * GeoIP_country_code_by_addr_gl(GeoIP gi, const char addr, GeoIPLookup gl); GEOIP_API const char GeoIP_country_code_by_name_gl(GeoIP gi, const char host, GeoIPLookup gl); GEOIP_API const char GeoIP_country_code3_by_addr_gl(GeoIP gi, const char addr, GeoIPLookup gl); GEOIP_API const char GeoIP_country_code3_by_name_gl(GeoIP gi, const char host, GeoIPLookup gl); GEOIP_API const char GeoIP_country_name_by_addr_gl(GeoIP gi, const char addr, GeoIPLookup gl); GEOIP_API const char GeoIP_country_name_by_name_gl(GeoIP gi, const char host, GeoIPLookup gl); GEOIP_API const char GeoIP_country_name_by_ipnum_gl(GeoIP gi, unsigned long ipnum, GeoIPLookup gl); GEOIP_API const char * GeoIP_country_code_by_ipnum_gl(GeoIP gi, unsigned long ipnum, GeoIPLookup gl); GEOIP_API const char GeoIP_country_code3_by_ipnum_gl(GeoIP gi, unsigned long ipnum, GeoIPLookup gl); / / GEOIP_API const char GeoIP_country_name_by_ipnum_v6_gl(GeoIP gi, geoipv6_t ipnum, GeoIPLookup gl); GEOIP_API const char * GeoIP_country_code_by_ipnum_v6_gl(GeoIP gi, geoipv6_t ipnum, GeoIPLookup gl); GEOIP_API const char * GeoIP_country_code3_by_ipnum_v6_gl(GeoIP gi, geoipv6_t ipnum, GeoIPLookup gl); GEOIP_API const char * GeoIP_country_code_by_addr_v6_gl(GeoIP gi, const char addr, GeoIPLookup gl); GEOIP_API const char GeoIP_country_code_by_name_v6_gl(GeoIP gi, const char host, GeoIPLookup gl); GEOIP_API const char GeoIP_country_code3_by_addr_v6_gl(GeoIP gi, const char addr, GeoIPLookup gl); GEOIP_API const char GeoIP_country_code3_by_name_v6_gl(GeoIP gi, const char host, GeoIPLookup gl); GEOIP_API const char GeoIP_country_name_by_addr_v6_gl(GeoIP gi, const char addr, GeoIPLookup gl); GEOIP_API const char GeoIP_country_name_by_name_v6_gl(GeoIP gi, const char host, GeoIPLookup gl); GEOIP_API int GeoIP_id_by_addr_gl(GeoIP gi, const char addr, GeoIPLookup gl); GEOIP_API int GeoIP_id_by_name_gl(GeoIP gi, const char host, GeoIPLookup gl); GEOIP_API int GeoIP_id_by_ipnum_gl(GeoIP gi, unsigned long ipnum, GeoIPLookup gl); GEOIP_API int GeoIP_id_by_addr_v6_gl(GeoIP gi, const char addr, GeoIPLookup gl); GEOIP_API int GeoIP_id_by_name_v6_gl(GeoIP gi, const char host, GeoIPLookup gl); GEOIP_API int GeoIP_id_by_ipnum_v6_gl(GeoIP gi, geoipv6_t ipnum, GeoIPLookup gl); GEOIP_API GeoIPRegion GeoIP_region_by_addr_gl(GeoIP gi, const char addr, GeoIPLookup gl); GEOIP_API GeoIPRegion GeoIP_region_by_name_gl(GeoIP gi, const char host, GeoIPLookup gl); GEOIP_API GeoIPRegion GeoIP_region_by_ipnum_gl(GeoIP gi, unsigned long ipnum, GeoIPLookup gl); GEOIP_API GeoIPRegion * GeoIP_region_by_addr_v6_gl(GeoIP gi, const char addr, GeoIPLookup gl); GEOIP_API GeoIPRegion GeoIP_region_by_name_v6_gl(GeoIP gi, const char host, GeoIPLookup gl); GEOIP_API GeoIPRegion GeoIP_region_by_ipnum_v6_gl(GeoIP gi, geoipv6_t ipnum, GeoIPLookup gl); /* Warning - don't call this after GeoIP_assign_region_by_inetaddr calls / GEOIP_API void GeoIPRegion_delete(GeoIPRegion gir); GEOIP_API void GeoIP_assign_region_by_inetaddr_gl(GeoIP gi, unsigned long inetaddr, GeoIPRegion gir, GeoIPLookup gl); GEOIP_API void GeoIP_assign_region_by_inetaddr_v6_gl(GeoIP gi, geoipv6_t inetaddr, GeoIPRegion gir, GeoIPLookup gl); /* Used to query GeoIP Organization, ISP and AS Number databases / GEOIP_API char GeoIP_name_by_ipnum_gl(GeoIP gi, unsigned long ipnum, GeoIPLookup gl); GEOIP_API char * GeoIP_name_by_addr_gl(GeoIP gi, const char addr, GeoIPLookup gl); GEOIP_API char GeoIP_name_by_name_gl(GeoIP gi, const char host, GeoIPLookup gl); GEOIP_API char GeoIP_name_by_ipnum_v6_gl(GeoIP gi, geoipv6_t ipnum, GeoIPLookup gl); GEOIP_API char * GeoIP_name_by_addr_v6_gl(GeoIP gi, const char addr, GeoIPLookup gl); GEOIP_API char GeoIP_name_by_name_v6_gl(GeoIP gi, const char name, GeoIPLookup gl); /* return two letter country code / GEOIP_API const char GeoIP_code_by_id(int id); /** return three letter country code / GEOIP_API const char GeoIP_code3_by_id(int id); /** return full name of country in utf8 or iso-8859-1 / GEOIP_API const char GeoIP_country_name_by_id(GeoIP gi, int id); /* return full name of country / GEOIP_API const char GeoIP_name_by_id(int id); /** return continent of country / GEOIP_API const char GeoIP_continent_by_id(int id); / return id by country code / GEOIP_API int GeoIP_id_by_code(const char country); /* return return number of known countries / GEOIP_API unsigned GeoIP_num_countries(void); GEOIP_API char GeoIP_database_info(GeoIP gi); GEOIP_API unsigned char GeoIP_database_edition(GeoIP gi); GEOIP_API int GeoIP_charset(GeoIP gi); GEOIP_API int GeoIP_set_charset(GeoIP gi, int charset); GEOIP_API int GeoIP_enable_teredo(GeoIP gi, int true_false); GEOIP_API int GeoIP_teredo(GeoIP gi); GEOIP_API char ** GeoIP_range_by_ip_gl(GeoIP gi, const char addr, GeoIPLookup gl); GEOIP_API void GeoIP_range_by_ip_delete(char ptr); / Convert region code to region name / GEOIP_API const char GeoIP_region_name_by_code(const char country_code, const char region_code); /* Get timezone from country and region code / GEOIP_API const char GeoIP_time_zone_by_country_and_region(const char country_code, const char region_code); /* some v4 helper functions as of 1.4.7 exported to the public API / GEOIP_API unsigned long GeoIP_addr_to_num(const char addr); GEOIP_API char GeoIP_num_to_addr(unsigned long ipnum); / Internal function -- convert iso to utf8; return a malloced utf8 string. / char _GeoIP_iso_8859_1__utf8(const char iso); / Cleans up memory used to hold file name paths. Returns 1 if successful; * otherwise 0. * / GEOIP_API int GeoIP_cleanup(void); / Returns the library version in use. Helpful if you're loading dynamically. / GEOIP_API const char GeoIP_lib_version(void); /* deprecated / GEOIP_API const char GeoIP_country_code_by_addr(GeoIP gi, const char addr); GEOIP_API const char GeoIP_country_code_by_name(GeoIP gi, const char host); GEOIP_API const char GeoIP_country_code3_by_addr(GeoIP gi, const char addr); GEOIP_API const char GeoIP_country_code3_by_name(GeoIP gi, const char host); GEOIP_API const char GeoIP_country_name_by_addr(GeoIP gi, const char addr); GEOIP_API const char GeoIP_country_name_by_name(GeoIP gi, const char host); GEOIP_API const char GeoIP_country_name_by_ipnum(GeoIP gi, unsigned long ipnum); GEOIP_API const char GeoIP_country_code_by_ipnum(GeoIP gi, unsigned long ipnum); GEOIP_API const char GeoIP_country_code3_by_ipnum(GeoIP gi, unsigned long ipnum); GEOIP_API const char GeoIP_country_name_by_ipnum_v6(GeoIP gi, geoipv6_t ipnum); GEOIP_API const char GeoIP_country_code_by_ipnum_v6(GeoIP gi, geoipv6_t ipnum); GEOIP_API const char GeoIP_country_code3_by_ipnum_v6(GeoIP gi, geoipv6_t ipnum); GEOIP_API const char GeoIP_country_code_by_addr_v6(GeoIP gi, const char addr); GEOIP_API const char GeoIP_country_code_by_name_v6(GeoIP gi, const char host); GEOIP_API const char GeoIP_country_code3_by_addr_v6(GeoIP gi, const char addr); GEOIP_API const char GeoIP_country_code3_by_name_v6(GeoIP gi, const char host); GEOIP_API const char GeoIP_country_name_by_addr_v6(GeoIP gi, const char addr); GEOIP_API const char GeoIP_country_name_by_name_v6(GeoIP gi, const char host); GEOIP_API int GeoIP_id_by_addr(GeoIP gi, const char addr); GEOIP_API int GeoIP_id_by_name(GeoIP gi, const char host); GEOIP_API int GeoIP_id_by_ipnum(GeoIP gi, unsigned long ipnum); GEOIP_API int GeoIP_id_by_addr_v6(GeoIP gi, const char addr); GEOIP_API int GeoIP_id_by_name_v6(GeoIP gi, const char host); GEOIP_API int GeoIP_id_by_ipnum_v6(GeoIP gi, geoipv6_t ipnum); GEOIP_API GeoIPRegion GeoIP_region_by_addr(GeoIP gi, const char addr); GEOIP_API GeoIPRegion GeoIP_region_by_name(GeoIP gi, const char host); GEOIP_API GeoIPRegion GeoIP_region_by_ipnum(GeoIP gi, unsigned long ipnum); GEOIP_API GeoIPRegion GeoIP_region_by_addr_v6(GeoIP gi, const char addr); GEOIP_API GeoIPRegion GeoIP_region_by_name_v6(GeoIP gi, const char host); GEOIP_API GeoIPRegion GeoIP_region_by_ipnum_v6(GeoIP gi, geoipv6_t ipnum); GEOIP_API void GeoIP_assign_region_by_inetaddr(GeoIP gi, unsigned long inetaddr, GeoIPRegion gir); GEOIP_API void GeoIP_assign_region_by_inetaddr_v6(GeoIP gi, geoipv6_t inetaddr, GeoIPRegion gir); GEOIP_API char GeoIP_name_by_ipnum(GeoIP gi, unsigned long ipnum); GEOIP_API char GeoIP_name_by_addr(GeoIP gi, const char addr); GEOIP_API char GeoIP_name_by_name(GeoIP gi, const char host); GEOIP_API char GeoIP_name_by_ipnum_v6(GeoIP gi, geoipv6_t ipnum); GEOIP_API char GeoIP_name_by_addr_v6(GeoIP gi, const char addr); GEOIP_API char GeoIP_name_by_name_v6(GeoIP gi, const char name); /* GeoIP_last_netmask is deprecated - it is not thread safe / GEOIP_API int GeoIP_last_netmask(GeoIP gi); GEOIP_API char *GeoIP_range_by_ip(GeoIP gi, const char addr); / Deprecated - for backwards compatibility only / GEOIP_API int GeoIP_country_id_by_addr(GeoIP gi, const char addr); GEOIP_API int GeoIP_country_id_by_name(GeoIP gi, const char host); GEOIP_API char GeoIP_org_by_addr(GeoIP gi, const char addr); GEOIP_API char GeoIP_org_by_name(GeoIP gi, const char host); GEOIP_API char GeoIP_org_by_ipnum(GeoIP gi, unsigned long ipnum); GEOIP_API int GeoIP_country_id_by_addr_v6(GeoIP gi, const char addr); GEOIP_API char GeoIP_org_by_ipnum_v6(GeoIP gi, geoipv6_t ipnum); GEOIP_API char GeoIP_org_by_addr_v6(GeoIP gi, const char addr); GEOIP_API char GeoIP_org_by_name_v6(GeoIP gi, const char name); / End deprecated / # #ifdef __cplusplus } #endif #endif / GEOIP_H */	17.42 KB	2018-01-17 19:23
📄 GeoIPCity.h /* -- Mode: C; indent-tabs-mode: t; c-basic-offset: 2; tab-width: 2 -- / / GeoIPCity.h * * Copyright (C) 2016 MaxMind, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA / #ifndef GEOIPCITY_H #define GEOIPCITY_H #include "GeoIP.h" #ifdef __cplusplus extern "C" { #endif #define GEOIP_UNKNOWN_CONF (0x7f) typedef struct GeoIPRecordTag { char country_code; char country_code3; char country_name; char region; char city; char postal_code; float latitude; float longitude; union { int metro_code; / metro_code is an alias for dma_code / int dma_code; }; int area_code; int charset; char continent_code; int netmask; } GeoIPRecord; GEOIP_API GeoIPRecord GeoIP_record_by_ipnum(GeoIP gi, unsigned long ipnum); GEOIP_API GeoIPRecord GeoIP_record_by_addr(GeoIP gi, const char addr); GEOIP_API GeoIPRecord GeoIP_record_by_name(GeoIP gi, const char host); GEOIP_API GeoIPRecord GeoIP_record_by_ipnum_v6(GeoIP gi, geoipv6_t ipnum); GEOIP_API GeoIPRecord GeoIP_record_by_addr_v6(GeoIP gi, const char addr); GEOIP_API GeoIPRecord GeoIP_record_by_name_v6(GeoIP gi, const char host); GEOIP_API int GeoIP_record_id_by_addr(GeoIP gi, const char addr); GEOIP_API int GeoIP_record_id_by_addr_v6(GeoIP gi, const char addr); GEOIP_API int GeoIP_init_record_iter(GeoIP gi); / returns 0 on success, 1 on failure / GEOIP_API int GeoIP_next_record(GeoIP gi, GeoIPRecord *gir, int record_iter); GEOIP_API void GeoIPRecord_delete(GeoIPRecord gir); #ifdef __cplusplus } #endif #endif / GEOIPCITY_H */	2.24 KB	2018-01-17 19:23
📄 a.out.h #ifndef __A_OUT_GNU_H__ #define __A_OUT_GNU_H__ #include <bits/a.out.h> #define __GNU_EXEC_MACROS__ struct exec { unsigned long a_info; /* Use macros N_MAGIC, etc for access. / unsigned int a_text; / Length of text, in bytes. / unsigned int a_data; / Length of data, in bytes. / unsigned int a_bss; / Length of uninitialized data area for file, in bytes. / unsigned int a_syms; / Length of symbol table data in file, in bytes. / unsigned int a_entry; / Start address. / unsigned int a_trsize;/ Length of relocation info for text, in bytes. / unsigned int a_drsize;/ Length of relocation info for data, in bytes. / }; enum machine_type { M_OLDSUN2 = 0, M_68010 = 1, M_68020 = 2, M_SPARC = 3, M_386 = 100, M_MIPS1 = 151, M_MIPS2 = 152 }; #define N_MAGIC(exec) ((exec).a_info & 0xffff) #define N_MACHTYPE(exec) ((enum machine_type)(((exec).a_info >> 16) & 0xff)) #define N_FLAGS(exec) (((exec).a_info >> 24) & 0xff) #define N_SET_INFO(exec, magic, type, flags) \ ((exec).a_info = ((magic) & 0xffff) \ \| (((int)(type) & 0xff) << 16) \ \| (((flags) & 0xff) << 24)) #define N_SET_MAGIC(exec, magic) \ ((exec).a_info = ((exec).a_info & 0xffff0000) \| ((magic) & 0xffff)) #define N_SET_MACHTYPE(exec, machtype) \ ((exec).a_info = \ ((exec).a_info&0xff00ffff) \| ((((int)(machtype))&0xff) << 16)) #define N_SET_FLAGS(exec, flags) \ ((exec).a_info = \ ((exec).a_info&0x00ffffff) \| (((flags) & 0xff) << 24)) / Code indicating object file or impure executable. / #define OMAGIC 0407 / Code indicating pure executable. / #define NMAGIC 0410 / Code indicating demand-paged executable. / #define ZMAGIC 0413 / This indicates a demand-paged executable with the header in the text. The first page is unmapped to help trap NULL pointer references. / #define QMAGIC 0314 / Code indicating core file. / #define CMAGIC 0421 #define N_TRSIZE(a) ((a).a_trsize) #define N_DRSIZE(a) ((a).a_drsize) #define N_SYMSIZE(a) ((a).a_syms) #define N_BADMAG(x) \ (N_MAGIC(x) != OMAGIC && N_MAGIC(x) != NMAGIC \ && N_MAGIC(x) != ZMAGIC && N_MAGIC(x) != QMAGIC) #define _N_HDROFF(x) (1024 - sizeof (struct exec)) #define N_TXTOFF(x) \ (N_MAGIC(x) == ZMAGIC ? _N_HDROFF((x)) + sizeof (struct exec) \ : (N_MAGIC(x) == QMAGIC ? 0 : sizeof (struct exec))) #define N_DATOFF(x) (N_TXTOFF(x) + (x).a_text) #define N_TRELOFF(x) (N_DATOFF(x) + (x).a_data) #define N_DRELOFF(x) (N_TRELOFF(x) + N_TRSIZE(x)) #define N_SYMOFF(x) (N_DRELOFF(x) + N_DRSIZE(x)) #define N_STROFF(x) (N_SYMOFF(x) + N_SYMSIZE(x)) / Address of text segment in memory after it is loaded. / #define N_TXTADDR(x) (N_MAGIC(x) == QMAGIC ? 4096 : 0) / Address of data segment in memory after it is loaded. / #define SEGMENT_SIZE 1024 #define _N_SEGMENT_ROUND(x) (((x) + SEGMENT_SIZE - 1) & ~(SEGMENT_SIZE - 1)) #define _N_TXTENDADDR(x) (N_TXTADDR(x)+(x).a_text) #define N_DATADDR(x) \ (N_MAGIC(x)==OMAGIC? (_N_TXTENDADDR(x)) \ : (_N_SEGMENT_ROUND (_N_TXTENDADDR(x)))) #define N_BSSADDR(x) (N_DATADDR(x) + (x).a_data) #if !defined (N_NLIST_DECLARED) struct nlist { union { char n_name; struct nlist n_next; long n_strx; } n_un; unsigned char n_type; char n_other; short n_desc; unsigned long n_value; }; #endif / no N_NLIST_DECLARED. / #define N_UNDF 0 #define N_ABS 2 #define N_TEXT 4 #define N_DATA 6 #define N_BSS 8 #define N_FN 15 #define N_EXT 1 #define N_TYPE 036 #define N_STAB 0340 #define N_INDR 0xa #define N_SETA 0x14 / Absolute set element symbol. / #define N_SETT 0x16 / Text set element symbol. / #define N_SETD 0x18 / Data set element symbol. / #define N_SETB 0x1A / Bss set element symbol. / #define N_SETV 0x1C / Pointer to set vector in data area. / #if !defined (N_RELOCATION_INFO_DECLARED) / This structure describes a single relocation to be performed. The text-relocation section of the file is a vector of these structures, all of which apply to the text section. Likewise, the data-relocation section applies to the data section. / struct relocation_info { int r_address; unsigned int r_symbolnum:24; unsigned int r_pcrel:1; unsigned int r_length:2; unsigned int r_extern:1; unsigned int r_pad:4; }; #endif / no N_RELOCATION_INFO_DECLARED. / #endif / __A_OUT_GNU_H__ */	4.25 KB	2026-02-17 11:01
📄 aio.h /* Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO/IEC 9945-1:1996 6.7: Asynchronous Input and Output / #ifndef _AIO_H #define _AIO_H 1 #include <features.h> #include <sys/types.h> #include <bits/types/sigevent_t.h> #include <bits/sigevent-consts.h> #include <bits/types/struct_timespec.h> __BEGIN_DECLS / Asynchronous I/O control block. / struct aiocb { int aio_fildes; / File descriptor. / int aio_lio_opcode; / Operation to be performed. / int aio_reqprio; / Request priority offset. / volatile void aio_buf; /* Location of buffer. / size_t aio_nbytes; / Length of transfer. / struct sigevent aio_sigevent; / Signal number and value. / / Internal members. / struct aiocb __next_prio; int __abs_prio; int __policy; int __error_code; __ssize_t __return_value; #ifndef __USE_FILE_OFFSET64 __off_t aio_offset; /* File offset. / char __pad[sizeof (__off64_t) - sizeof (__off_t)]; #else __off64_t aio_offset; / File offset. / #endif char __glibc_reserved[32]; }; / The same for the 64bit offsets. Please note that the members aio_fildes to __return_value have to be the same in aiocb and aiocb64. / #ifdef __USE_LARGEFILE64 struct aiocb64 { int aio_fildes; / File descriptor. / int aio_lio_opcode; / Operation to be performed. / int aio_reqprio; / Request priority offset. / volatile void aio_buf; /* Location of buffer. / size_t aio_nbytes; / Length of transfer. / struct sigevent aio_sigevent; / Signal number and value. / / Internal members. / struct aiocb __next_prio; int __abs_prio; int __policy; int __error_code; __ssize_t __return_value; __off64_t aio_offset; /* File offset. / char __glibc_reserved[32]; }; #endif #ifdef __USE_GNU / To optimize the implementation one can use the following struct. / struct aioinit { int aio_threads; / Maximum number of threads. / int aio_num; / Number of expected simultaneous requests. / int aio_locks; / Not used. / int aio_usedba; / Not used. / int aio_debug; / Not used. / int aio_numusers; / Not used. / int aio_idle_time; / Number of seconds before idle thread terminates. / int aio_reserved; }; #endif / Return values of the aio_cancel function. / enum { AIO_CANCELED, #define AIO_CANCELED AIO_CANCELED AIO_NOTCANCELED, #define AIO_NOTCANCELED AIO_NOTCANCELED AIO_ALLDONE #define AIO_ALLDONE AIO_ALLDONE }; / Operation codes for `aio_lio_opcode'. / enum { LIO_READ, #define LIO_READ LIO_READ LIO_WRITE, #define LIO_WRITE LIO_WRITE LIO_NOP #define LIO_NOP LIO_NOP }; / Synchronization options for `lio_listio' function. / enum { LIO_WAIT, #define LIO_WAIT LIO_WAIT LIO_NOWAIT #define LIO_NOWAIT LIO_NOWAIT }; / Allow user to specify optimization. / #ifdef __USE_GNU extern void aio_init (const struct aioinit __init) __THROW __nonnull ((1)); #endif #ifndef __USE_FILE_OFFSET64 /* Enqueue read request for given number of bytes and the given priority. / extern int aio_read (struct aiocb __aiocbp) __THROW __nonnull ((1)); /* Enqueue write request for given number of bytes and the given priority. / extern int aio_write (struct aiocb __aiocbp) __THROW __nonnull ((1)); /* Initiate list of I/O requests. / extern int lio_listio (int __mode, struct aiocb const __list[__restrict_arr], int __nent, struct sigevent __restrict __sig) __THROW __nonnull ((2)); / Retrieve error status associated with AIOCBP. / extern int aio_error (const struct aiocb __aiocbp) __THROW __nonnull ((1)); /* Return status associated with AIOCBP. / extern __ssize_t aio_return (struct aiocb __aiocbp) __THROW __nonnull ((1)); /* Try to cancel asynchronous I/O requests outstanding against file descriptor FILDES. / extern int aio_cancel (int __fildes, struct aiocb __aiocbp) __THROW; /* Suspend calling thread until at least one of the asynchronous I/O operations referenced by LIST has completed. This function is a cancellation point and therefore not marked with __THROW. / extern int aio_suspend (const struct aiocb const __list[], int __nent, const struct timespec __restrict __timeout) __nonnull ((1)); / Force all operations associated with file desriptor described by `aio_fildes' member of AIOCBP. / extern int aio_fsync (int __operation, struct aiocb __aiocbp) __THROW __nonnull ((2)); #else # ifdef __REDIRECT_NTH extern int __REDIRECT_NTH (aio_read, (struct aiocb __aiocbp), aio_read64) __nonnull ((1)); extern int __REDIRECT_NTH (aio_write, (struct aiocb __aiocbp), aio_write64) __nonnull ((1)); extern int __REDIRECT_NTH (lio_listio, (int __mode, struct aiocb const __list[__restrict_arr], int __nent, struct sigevent __restrict __sig), lio_listio64) __nonnull ((2)); extern int __REDIRECT_NTH (aio_error, (const struct aiocb __aiocbp), aio_error64) __nonnull ((1)); extern __ssize_t __REDIRECT_NTH (aio_return, (struct aiocb __aiocbp), aio_return64) __nonnull ((1)); extern int __REDIRECT_NTH (aio_cancel, (int __fildes, struct aiocb __aiocbp), aio_cancel64); # ifdef __USE_TIME_BITS64 extern int __REDIRECT_NTH (aio_suspend, (const struct aiocb const __list[], int __nent, const struct timespec __restrict __timeout), __aio_suspend_time64) __nonnull ((1)); # else extern int __REDIRECT_NTH (aio_suspend, (const struct aiocb const __list[], int __nent, const struct timespec __restrict __timeout), aio_suspend64) __nonnull ((1)); # endif extern int __REDIRECT_NTH (aio_fsync, (int __operation, struct aiocb __aiocbp), aio_fsync64) __nonnull ((2)); # else # define aio_read aio_read64 # define aio_write aio_write64 # define lio_listio lio_listio64 # define aio_error aio_error64 # define aio_return aio_return64 # define aio_cancel aio_cancel64 # ifdef __USE_TIME_BITS64 # define aio_suspend __aio_suspend_time64 # else # define aio_suspend aio_suspend64 # endif # define aio_fsync aio_fsync64 # endif #endif #ifdef __USE_LARGEFILE64 extern int aio_read64 (struct aiocb64 __aiocbp) __THROW __nonnull ((1)); extern int aio_write64 (struct aiocb64 __aiocbp) __THROW __nonnull ((1)); extern int lio_listio64 (int __mode, struct aiocb64 const __list[__restrict_arr], int __nent, struct sigevent __restrict __sig) __THROW __nonnull ((2)); extern int aio_error64 (const struct aiocb64 __aiocbp) __THROW __nonnull ((1)); extern __ssize_t aio_return64 (struct aiocb64 __aiocbp) __THROW __nonnull ((1)); extern int aio_cancel64 (int __fildes, struct aiocb64 __aiocbp) __THROW; extern int aio_suspend64 (const struct aiocb64 const __list[], int __nent, const struct timespec __restrict __timeout) __THROW __nonnull ((1)); extern int aio_fsync64 (int __operation, struct aiocb64 __aiocbp) __THROW __nonnull ((2)); #endif __END_DECLS #endif /* aio.h */	7.56 KB	2026-02-17 11:01
📄 aliases.h /* Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _ALIASES_H #define _ALIASES_H 1 #include <features.h> #include <sys/types.h> __BEGIN_DECLS / Structure to represent one entry of the alias database. / struct aliasent { char alias_name; size_t alias_members_len; char *alias_members; int alias_local; }; / Open alias data base files. / extern void setaliasent (void) __THROW; / Close alias database files. / extern void endaliasent (void) __THROW; / Get the next entry from the alias database. / extern struct aliasent getaliasent (void) __THROW; /* Get the next entry from the alias database and put it in RESULT_BUF. / extern int getaliasent_r (struct aliasent __restrict __result_buf, char __restrict __buffer, size_t __buflen, struct aliasent __restrict __result) __THROW; / Get alias entry corresponding to NAME. / extern struct aliasent getaliasbyname (const char __name) __THROW; / Get alias entry corresponding to NAME and put it in RESULT_BUF. / extern int getaliasbyname_r (const char __restrict __name, struct aliasent __restrict __result_buf, char __restrict __buffer, size_t __buflen, struct aliasent *__restrict __result) __THROW; __END_DECLS #endif / aliases.h */	1.98 KB	2026-02-17 11:02
📄 alloca.h /* Copyright (C) 1992-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _ALLOCA_H #define _ALLOCA_H 1 #include <features.h> #define __need_size_t #include <stddef.h> __BEGIN_DECLS / Remove any previous definition. / #undef alloca / Allocate a block that will be freed when the calling function exits. / extern void alloca (size_t __size) __THROW; #ifdef __GNUC__ # define alloca(size) __builtin_alloca (size) #endif /* GCC. / __END_DECLS #endif / alloca.h */	1.17 KB	2026-02-17 11:01
📄 ar.h /* Header describing `ar' archive file format. Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _AR_H #define _AR_H 1 #include <sys/cdefs.h> / Archive files start with the ARMAG identifying string. Then follows a `struct ar_hdr', and as many bytes of member file data as its `ar_size' member indicates, for each member file. / #define ARMAG "!<arch>\n" / String that begins an archive file. / #define SARMAG 8 / Size of that string. / #define ARFMAG "`\n" / String in ar_fmag at end of each header. / __BEGIN_DECLS struct ar_hdr { char ar_name[16]; / Member file name, sometimes / terminated. / char ar_date[12]; / File date, decimal seconds since Epoch. / char ar_uid[6], ar_gid[6]; / User and group IDs, in ASCII decimal. / char ar_mode[8]; / File mode, in ASCII octal. / char ar_size[10]; / File size, in ASCII decimal. / char ar_fmag[2]; / Always contains ARFMAG. / }; __END_DECLS #endif / ar.h */	1.69 KB	2026-02-17 11:01
📄 argp.h /* Hierarchical argument parsing, layered over getopt. Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. Written by Miles Bader <miles@gnu.ai.mit.edu>. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _ARGP_H #define _ARGP_H #include <stdio.h> #include <ctype.h> #include <getopt.h> #include <limits.h> #include <errno.h> __BEGIN_DECLS / error_t may or may not be available from errno.h, depending on the operating system. / #ifndef __error_t_defined # define __error_t_defined 1 typedef int error_t; #endif / A description of a particular option. A pointer to an array of these is passed in the OPTIONS field of an argp structure. Each option entry can correspond to one long option and/or one short option; more names for the same option can be added by following an entry in an option array with options having the OPTION_ALIAS flag set. / struct argp_option { / The long option name. For more than one name for the same option, you can use following options with the OPTION_ALIAS flag set. / const char name; /* What key is returned for this option. If > 0 and printable, then it's also accepted as a short option. / int key; / If non-NULL, this is the name of the argument associated with this option, which is required unless the OPTION_ARG_OPTIONAL flag is set. / const char arg; /* OPTION_ flags. / int flags; / The doc string for this option. If both NAME and KEY are 0, This string will be printed outdented from the normal option column, making it useful as a group header (it will be the first thing printed in its group); in this usage, it's conventional to end the string with a `:'. / const char doc; /* The group this option is in. In a long help message, options are sorted alphabetically within each group, and the groups presented in the order 0, 1, 2, ..., n, -m, ..., -2, -1. Every entry in an options array with if this field 0 will inherit the group number of the previous entry, or zero if it's the first one, unless its a group header (NAME and KEY both 0), in which case, the previous entry + 1 is the default. Automagic options such as --help are put into group -1. / int group; }; / The argument associated with this option is optional. / #define OPTION_ARG_OPTIONAL 0x1 / This option isn't displayed in any help messages. / #define OPTION_HIDDEN 0x2 / This option is an alias for the closest previous non-alias option. This means that it will be displayed in the same help entry, and will inherit fields other than NAME and KEY from the aliased option. / #define OPTION_ALIAS 0x4 / This option isn't actually an option (and so should be ignored by the actual option parser), but rather an arbitrary piece of documentation that should be displayed in much the same manner as the options. If this flag is set, then the option NAME field is displayed unmodified (e.g., no `--' prefix is added) at the left-margin (where a short option would normally be displayed), and the documentation string in the normal place. For purposes of sorting, any leading whitespace and punctuation is ignored, except that if the first non-whitespace character is not `-', this entry is displayed after all options (and OPTION_DOC entries with a leading `-') in the same group. / #define OPTION_DOC 0x8 / This option shouldn't be included in `long' usage messages (but is still included in help messages). This is mainly intended for options that are completely documented in an argp's ARGS_DOC field, in which case including the option in the generic usage list would be redundant. For instance, if ARGS_DOC is "FOO BAR\n-x BLAH", and the `-x' option's purpose is to distinguish these two cases, -x should probably be marked OPTION_NO_USAGE. / #define OPTION_NO_USAGE 0x10 struct argp; / fwd declare this type / struct argp_state; / " / struct argp_child; / " / / The type of a pointer to an argp parsing function. / typedef error_t (argp_parser_t) (int __key, char __arg, struct argp_state __state); /* What to return for unrecognized keys. For special ARGP_KEY_ keys, such returns will simply be ignored. For user keys, this error will be turned into EINVAL (if the call to argp_parse is such that errors are propagated back to the user instead of exiting); returning EINVAL itself would result in an immediate stop to parsing in all cases. / #define ARGP_ERR_UNKNOWN E2BIG / Hurd should never need E2BIG. XXX / / Special values for the KEY argument to an argument parsing function. ARGP_ERR_UNKNOWN should be returned if they aren't understood. The sequence of keys to a parsing function is either (where each uppercased word should be prefixed by `ARGP_KEY_' and opt is a user key): INIT opt... NO_ARGS END SUCCESS -- No non-option arguments at all or INIT (opt \| ARG)... END SUCCESS -- All non-option args parsed or INIT (opt \| ARG)... SUCCESS -- Some non-option arg unrecognized The third case is where every parser returned ARGP_KEY_UNKNOWN for an argument, in which case parsing stops at that argument (returning the unparsed arguments to the caller of argp_parse if requested, or stopping with an error message if not). If an error occurs (either detected by argp, or because the parsing function returned an error value), then the parser is called with ARGP_KEY_ERROR, and no further calls are made. / / This is not an option at all, but rather a command line argument. If a parser receiving this key returns success, the fact is recorded, and the ARGP_KEY_NO_ARGS case won't be used. HOWEVER, if while processing the argument, a parser function decrements the NEXT field of the state it's passed, the option won't be considered processed; this is to allow you to actually modify the argument (perhaps into an option), and have it processed again. / #define ARGP_KEY_ARG 0 / There are remaining arguments not parsed by any parser, which may be found starting at (STATE->argv + STATE->next). If success is returned, but STATE->next left untouched, it's assumed that all arguments were consume, otherwise, the parser should adjust STATE->next to reflect any arguments consumed. / #define ARGP_KEY_ARGS 0x1000006 / There are no more command line arguments at all. / #define ARGP_KEY_END 0x1000001 / Because it's common to want to do some special processing if there aren't any non-option args, user parsers are called with this key if they didn't successfully process any non-option arguments. Called just before ARGP_KEY_END (where more general validity checks on previously parsed arguments can take place). / #define ARGP_KEY_NO_ARGS 0x1000002 / Passed in before any parsing is done. Afterwards, the values of each element of the CHILD_INPUT field, if any, in the state structure is copied to each child's state to be the initial value of the INPUT field. / #define ARGP_KEY_INIT 0x1000003 / Use after all other keys, including SUCCESS & END. / #define ARGP_KEY_FINI 0x1000007 / Passed in when parsing has successfully been completed (even if there are still arguments remaining). / #define ARGP_KEY_SUCCESS 0x1000004 / Passed in if an error occurs. / #define ARGP_KEY_ERROR 0x1000005 / An argp structure contains a set of options declarations, a function to deal with parsing one, documentation string, a possible vector of child argp's, and perhaps a function to filter help output. When actually parsing options, getopt is called with the union of all the argp structures chained together through their CHILD pointers, with conflicts being resolved in favor of the first occurrence in the chain. / struct argp { / An array of argp_option structures, terminated by an entry with both NAME and KEY having a value of 0. / const struct argp_option options; /* What to do with an option from this structure. KEY is the key associated with the option, and ARG is any associated argument (NULL if none was supplied). If KEY isn't understood, ARGP_ERR_UNKNOWN should be returned. If a non-zero, non-ARGP_ERR_UNKNOWN value is returned, then parsing is stopped immediately, and that value is returned from argp_parse(). For special (non-user-supplied) values of KEY, see the ARGP_KEY_ definitions below. / argp_parser_t parser; / A string describing what other arguments are wanted by this program. It is only used by argp_usage to print the `Usage:' message. If it contains newlines, the strings separated by them are considered alternative usage patterns, and printed on separate lines (lines after the first are prefix by ` or: ' instead of `Usage:'). / const char args_doc; /* If non-NULL, a string containing extra text to be printed before and after the options in a long help message (separated by a vertical tab `\v' character). / const char doc; /* A vector of argp_children structures, terminated by a member with a 0 argp field, pointing to child argps should be parsed with this one. Any conflicts are resolved in favor of this argp, or early argps in the CHILDREN list. This field is useful if you use libraries that supply their own argp structure, which you want to use in conjunction with your own. / const struct argp_child children; /* If non-zero, this should be a function to filter the output of help messages. KEY is either a key from an option, in which case TEXT is that option's help text, or a special key from the ARGP_KEY_HELP_ defines, below, describing which other help text TEXT is. The function should return either TEXT, if it should be used as-is, a replacement string, which should be malloced, and will be freed by argp, or NULL, meaning `print nothing'. The value for TEXT is after any translation has been done, so if any of the replacement text also needs translation, that should be done by the filter function. INPUT is either the input supplied to argp_parse, or NULL, if argp_help was called directly. / char (help_filter) (int __key, const char __text, void __input); / If non-zero the strings used in the argp library are translated using the domain described by this string. Otherwise the currently installed default domain is used. / const char argp_domain; }; /* Possible KEY arguments to a help filter function. / #define ARGP_KEY_HELP_PRE_DOC 0x2000001 / Help text preceding options. / #define ARGP_KEY_HELP_POST_DOC 0x2000002 / Help text following options. / #define ARGP_KEY_HELP_HEADER 0x2000003 / Option header string. / #define ARGP_KEY_HELP_EXTRA 0x2000004 / After all other documentation; TEXT is NULL for this key. / / Explanatory note emitted when duplicate option arguments have been suppressed. / #define ARGP_KEY_HELP_DUP_ARGS_NOTE 0x2000005 #define ARGP_KEY_HELP_ARGS_DOC 0x2000006 / Argument doc string. / / When an argp has a non-zero CHILDREN field, it should point to a vector of argp_child structures, each of which describes a subsidiary argp. / struct argp_child { / The child parser. / const struct argp argp; /* Flags for this child. / int flags; / If non-zero, an optional header to be printed in help output before the child options. As a side-effect, a non-zero value forces the child options to be grouped together; to achieve this effect without actually printing a header string, use a value of "". / const char header; /* Where to group the child options relative to the other (`consolidated') options in the parent argp; the values are the same as the GROUP field in argp_option structs, but all child-groupings follow parent options at a particular group level. If both this field and HEADER are zero, then they aren't grouped at all, but rather merged with the parent options (merging the child's grouping levels with the parents). / int group; }; / Parsing state. This is provided to parsing functions called by argp, which may examine and, as noted, modify fields. / struct argp_state { / The top level ARGP being parsed. / const struct argp root_argp; /* The argument vector being parsed. May be modified. / int argc; char argv; / The index in ARGV of the next arg that to be parsed. May be modified. / int next; / The flags supplied to argp_parse. May be modified. / unsigned flags; / While calling a parsing function with a key of ARGP_KEY_ARG, this is the number of the current arg, starting at zero, and incremented after each such call returns. At all other times, this is the number of such arguments that have been processed. / unsigned arg_num; / If non-zero, the index in ARGV of the first argument following a special `--' argument (which prevents anything following being interpreted as an option). Only set once argument parsing has proceeded past this point. / int quoted; / An arbitrary pointer passed in from the user. / void input; /* Values to pass to child parsers. This vector will be the same length as the number of children for the current parser. / void child_inputs; / For the parser's use. Initialized to 0. / void hook; /* The name used when printing messages. This is initialized to ARGV[0], or PROGRAM_INVOCATION_NAME if that is unavailable. / char name; /* Streams used when argp prints something. / FILE err_stream; /* For errors; initialized to stderr. / FILE out_stream; /* For information; initialized to stdout. / void pstate; /* Private, for use by argp. / }; / Flags for argp_parse (note that the defaults are those that are convenient for program command line parsing): / / Don't ignore the first element of ARGV. Normally (and always unless ARGP_NO_ERRS is set) the first element of the argument vector is skipped for option parsing purposes, as it corresponds to the program name in a command line. / #define ARGP_PARSE_ARGV0 0x01 / Don't print error messages for unknown options to stderr; unless this flag is set, ARGP_PARSE_ARGV0 is ignored, as ARGV[0] is used as the program name in the error messages. This flag implies ARGP_NO_EXIT (on the assumption that silent exiting upon errors is bad behaviour). / #define ARGP_NO_ERRS 0x02 / Don't parse any non-option args. Normally non-option args are parsed by calling the parse functions with a key of ARGP_KEY_ARG, and the actual arg as the value. Since it's impossible to know which parse function wants to handle it, each one is called in turn, until one returns 0 or an error other than ARGP_ERR_UNKNOWN; if an argument is handled by no one, the argp_parse returns prematurely (but with a return value of 0). If all args have been parsed without error, all parsing functions are called one last time with a key of ARGP_KEY_END. This flag needn't normally be set, as the normal behavior is to stop parsing as soon as some argument can't be handled. / #define ARGP_NO_ARGS 0x04 / Parse options and arguments in the same order they occur on the command line -- normally they're rearranged so that all options come first. / #define ARGP_IN_ORDER 0x08 / Don't provide the standard long option --help, which causes usage and option help information to be output to stdout, and exit (0) called. / #define ARGP_NO_HELP 0x10 / Don't exit on errors (they may still result in error messages). / #define ARGP_NO_EXIT 0x20 / Use the gnu getopt `long-only' rules for parsing arguments. / #define ARGP_LONG_ONLY 0x40 / Turns off any message-printing/exiting options. / #define ARGP_SILENT (ARGP_NO_EXIT \| ARGP_NO_ERRS \| ARGP_NO_HELP) / Parse the options strings in ARGC & ARGV according to the options in ARGP. FLAGS is one of the ARGP_ flags above. If ARG_INDEX is non-NULL, the index in ARGV of the first unparsed option is returned in it. If an unknown option is present, ARGP_ERR_UNKNOWN is returned; if some parser routine returned a non-zero value, it is returned; otherwise 0 is returned. This function may also call exit unless the ARGP_NO_HELP flag is set. INPUT is a pointer to a value to be passed in to the parser. / extern error_t argp_parse (const struct argp __restrict __argp, int __argc, char *__restrict __argv, unsigned __flags, int __restrict __arg_index, void __restrict __input); extern error_t __argp_parse (const struct argp __restrict __argp, int __argc, char *__restrict __argv, unsigned __flags, int __restrict __arg_index, void __restrict __input); / Global variables. / / If defined or set by the user program to a non-zero value, then a default option --version is added (unless the ARGP_NO_HELP flag is used), which will print this string followed by a newline and exit (unless the ARGP_NO_EXIT flag is used). Overridden by ARGP_PROGRAM_VERSION_HOOK. / extern const char argp_program_version; /* If defined or set by the user program to a non-zero value, then a default option --version is added (unless the ARGP_NO_HELP flag is used), which calls this function with a stream to print the version to and a pointer to the current parsing state, and then exits (unless the ARGP_NO_EXIT flag is used). This variable takes precedent over ARGP_PROGRAM_VERSION. / extern void (argp_program_version_hook) (FILE __restrict __stream, struct argp_state __restrict __state); /* If defined or set by the user program, it should point to string that is the bug-reporting address for the program. It will be printed by argp_help if the ARGP_HELP_BUG_ADDR flag is set (as it is by various standard help messages), embedded in a sentence that says something like `Report bugs to ADDR.'. / extern const char argp_program_bug_address; /* The exit status that argp will use when exiting due to a parsing error. If not defined or set by the user program, this defaults to EX_USAGE from <sysexits.h>. / extern error_t argp_err_exit_status; / Flags for argp_help. / #define ARGP_HELP_USAGE 0x01 / a Usage: message. / #define ARGP_HELP_SHORT_USAGE 0x02 / " but don't actually print options. / #define ARGP_HELP_SEE 0x04 / a `Try ... for more help' message. / #define ARGP_HELP_LONG 0x08 / a long help message. / #define ARGP_HELP_PRE_DOC 0x10 / doc string preceding long help. / #define ARGP_HELP_POST_DOC 0x20 / doc string following long help. / #define ARGP_HELP_DOC (ARGP_HELP_PRE_DOC \| ARGP_HELP_POST_DOC) #define ARGP_HELP_BUG_ADDR 0x40 / bug report address / #define ARGP_HELP_LONG_ONLY 0x80 / modify output appropriately to reflect ARGP_LONG_ONLY mode. / / These ARGP_HELP flags are only understood by argp_state_help. / #define ARGP_HELP_EXIT_ERR 0x100 / Call exit(1) instead of returning. / #define ARGP_HELP_EXIT_OK 0x200 / Call exit(0) instead of returning. / / The standard thing to do after a program command line parsing error, if an error message has already been printed. / #define ARGP_HELP_STD_ERR \ (ARGP_HELP_SEE \| ARGP_HELP_EXIT_ERR) / The standard thing to do after a program command line parsing error, if no more specific error message has been printed. / #define ARGP_HELP_STD_USAGE \ (ARGP_HELP_SHORT_USAGE \| ARGP_HELP_SEE \| ARGP_HELP_EXIT_ERR) / The standard thing to do in response to a --help option. / #define ARGP_HELP_STD_HELP \ (ARGP_HELP_SHORT_USAGE \| ARGP_HELP_LONG \| ARGP_HELP_EXIT_OK \ \| ARGP_HELP_DOC \| ARGP_HELP_BUG_ADDR) / Output a usage message for ARGP to STREAM. FLAGS are from the set ARGP_HELP_. / extern void argp_help (const struct argp __restrict __argp, FILE __restrict __stream, unsigned __flags, char __restrict __name); extern void __argp_help (const struct argp __restrict __argp, FILE __restrict __stream, unsigned __flags, char __name); /* The following routines are intended to be called from within an argp parsing routine (thus taking an argp_state structure as the first argument). They may or may not print an error message and exit, depending on the flags in STATE -- in any case, the caller should be prepared for them not to exit, and should return an appropriate error after calling them. [argp_usage & argp_error should probably be called argp_state_..., but they're used often enough that they should be short] / / Output, if appropriate, a usage message for STATE to STREAM. FLAGS are from the set ARGP_HELP_. / extern void argp_state_help (const struct argp_state __restrict __state, FILE __restrict __stream, unsigned int __flags); extern void __argp_state_help (const struct argp_state __restrict __state, FILE __restrict __stream, unsigned int __flags); /* Possibly output the standard usage message for ARGP to stderr and exit. / extern void argp_usage (const struct argp_state __state); extern void __argp_usage (const struct argp_state __state); / If appropriate, print the printf string FMT and following args, preceded by the program name and `:', to stderr, and followed by a `Try ... --help' message, then exit (1). / extern void argp_error (const struct argp_state __restrict __state, const char __restrict __fmt, ...) __attribute__ ((__format__ (__printf__, 2, 3))); extern void __argp_error (const struct argp_state __restrict __state, const char __restrict __fmt, ...) __attribute__ ((__format__ (__printf__, 2, 3))); / Similar to the standard gnu error-reporting function error(), but will respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print to STATE->err_stream. This is useful for argument parsing code that is shared between program startup (when exiting is desired) and runtime option parsing (when typically an error code is returned instead). The difference between this function and argp_error is that the latter is for parsing errors, and the former is for other problems that occur during parsing but don't reflect a (syntactic) problem with the input. / extern void argp_failure (const struct argp_state __restrict __state, int __status, int __errnum, const char __restrict __fmt, ...) __attribute__ ((__format__ (__printf__, 4, 5))); extern void __argp_failure (const struct argp_state __restrict __state, int __status, int __errnum, const char __restrict __fmt, ...) __attribute__ ((__format__ (__printf__, 4, 5))); / Returns true if the option OPT is a valid short option. / extern int _option_is_short (const struct argp_option __opt) __THROW; extern int __option_is_short (const struct argp_option __opt) __THROW; / Returns true if the option OPT is in fact the last (unused) entry in an options array. / extern int _option_is_end (const struct argp_option __opt) __THROW; extern int __option_is_end (const struct argp_option __opt) __THROW; / Return the input field for ARGP in the parser corresponding to STATE; used by the help routines. / extern void _argp_input (const struct argp __restrict __argp, const struct argp_state __restrict __state) __THROW; extern void __argp_input (const struct argp __restrict __argp, const struct argp_state __restrict __state) __THROW; #ifdef __USE_EXTERN_INLINES # if !(defined _LIBC && _LIBC) # define __argp_usage argp_usage # define __argp_state_help argp_state_help # define __option_is_short _option_is_short # define __option_is_end _option_is_end # endif # ifndef ARGP_EI # define ARGP_EI __extern_inline # endif ARGP_EI void __argp_usage (const struct argp_state __state) { __argp_state_help (__state, stderr, ARGP_HELP_STD_USAGE); } ARGP_EI int __NTH (__option_is_short (const struct argp_option __opt)) { if (__opt->flags & OPTION_DOC) return 0; else { int __key = __opt->key; return __key > 0 && __key <= UCHAR_MAX && isprint (__key); } } ARGP_EI int __NTH (__option_is_end (const struct argp_option __opt)) { return !__opt->key && !__opt->name && !__opt->doc && !__opt->group; } # if !(defined _LIBC && _LIBC) # undef __argp_usage # undef __argp_state_help # undef __option_is_short # undef __option_is_end # endif #endif /* Use extern inlines. / #include <bits/floatn.h> #if defined __LDBL_COMPAT \|\| __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 # include <bits/argp-ldbl.h> #endif __END_DECLS #endif / argp.h */	24.95 KB	2026-02-17 11:02
📄 argz.h /* Routines for dealing with '\0' separated arg vectors. Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _ARGZ_H #define _ARGZ_H 1 #include <features.h> #include <errno.h> #include <string.h> / Need size_t, and strchr is called below. / __BEGIN_DECLS / error_t may or may not be available from errno.h, depending on the operating system. / #ifndef __error_t_defined # define __error_t_defined 1 typedef int error_t; #endif / Make a '\0' separated arg vector from a unix argv vector, returning it in ARGZ, and the total length in LEN. If a memory allocation error occurs, ENOMEM is returned, otherwise 0. The result can be destroyed using free. / extern error_t __argz_create (char const __argv[], char *__restrict __argz, size_t __restrict __len) __THROW; extern error_t argz_create (char const __argv[], char __restrict __argz, size_t __restrict __len) __THROW; /* Make a '\0' separated arg vector from a SEP separated list in STRING, returning it in ARGZ, and the total length in LEN. If a memory allocation error occurs, ENOMEM is returned, otherwise 0. The result can be destroyed using free. / extern error_t argz_create_sep (const char __restrict __string, int __sep, char *__restrict __argz, size_t __restrict __len) __THROW; /* Returns the number of strings in ARGZ. / extern size_t __argz_count (const char __argz, size_t __len) __THROW __attribute_pure__; extern size_t argz_count (const char __argz, size_t __len) __THROW __attribute_pure__; / Puts pointers to each string in ARGZ into ARGV, which must be large enough to hold them all. / extern void __argz_extract (const char __restrict __argz, size_t __len, char *__restrict __argv) __THROW; extern void argz_extract (const char __restrict __argz, size_t __len, char *__restrict __argv) __THROW; / Make '\0' separated arg vector ARGZ printable by converting all the '\0's except the last into the character SEP. / extern void __argz_stringify (char __argz, size_t __len, int __sep) __THROW; extern void argz_stringify (char __argz, size_t __len, int __sep) __THROW; / Append BUF, of length BUF_LEN to the argz vector in ARGZ & ARGZ_LEN. / extern error_t argz_append (char __restrict __argz, size_t __restrict __argz_len, const char __restrict __buf, size_t __buf_len) __THROW; / Append STR to the argz vector in ARGZ & ARGZ_LEN. / extern error_t argz_add (char __restrict __argz, size_t __restrict __argz_len, const char __restrict __str) __THROW; / Append SEP separated list in STRING to the argz vector in ARGZ & ARGZ_LEN. / extern error_t argz_add_sep (char __restrict __argz, size_t __restrict __argz_len, const char __restrict __string, int __delim) __THROW; / Delete ENTRY from ARGZ & ARGZ_LEN, if it appears there. / extern void argz_delete (char __restrict __argz, size_t __restrict __argz_len, char __restrict __entry) __THROW; / Insert ENTRY into ARGZ & ARGZ_LEN before BEFORE, which should be an existing entry in ARGZ; if BEFORE is NULL, ENTRY is appended to the end. Since ARGZ's first entry is the same as ARGZ, argz_insert (ARGZ, ARGZ_LEN, ARGZ, ENTRY) will insert ENTRY at the beginning of ARGZ. If BEFORE is not in ARGZ, EINVAL is returned, else if memory can't be allocated for the new ARGZ, ENOMEM is returned, else 0. / extern error_t argz_insert (char __restrict __argz, size_t __restrict __argz_len, char __restrict __before, const char __restrict __entry) __THROW; /* Replace any occurrences of the string STR in ARGZ with WITH, reallocating ARGZ as necessary. If REPLACE_COUNT is non-zero, REPLACE_COUNT will be incremented by number of replacements performed. / extern error_t argz_replace (char *__restrict __argz, size_t __restrict __argz_len, const char __restrict __str, const char __restrict __with, unsigned int __restrict __replace_count); / Returns the next entry in ARGZ & ARGZ_LEN after ENTRY, or NULL if there are no more. If entry is NULL, then the first entry is returned. This behavior allows two convenient iteration styles: char entry = 0; while ((entry = argz_next (argz, argz_len, entry))) ...; or char entry; for (entry = argz; entry; entry = argz_next (argz, argz_len, entry)) ...; / extern char __argz_next (const char __restrict __argz, size_t __argz_len, const char __restrict __entry) __THROW; extern char argz_next (const char __restrict __argz, size_t __argz_len, const char __restrict __entry) __THROW; #ifdef __USE_EXTERN_INLINES __extern_inline char __NTH (__argz_next (const char __argz, size_t __argz_len, const char __entry)) { if (__entry) { if (__entry < __argz + __argz_len) __entry = strchr (__entry, '\0') + 1; return __entry >= __argz + __argz_len ? (char ) NULL : (char ) __entry; } else return __argz_len > 0 ? (char ) __argz : 0; } __extern_inline char __NTH (argz_next (const char __argz, size_t __argz_len, const char __entry)) { return __argz_next (__argz, __argz_len, __entry); } #endif /* Use extern inlines. / __END_DECLS #endif / argz.h */	5.91 KB	2026-02-17 11:01
📁 arpa	-	2026-03-21 15:44
📁 asm	-	2026-03-27 02:43
📁 asm-generic	-	2026-03-27 02:43
📄 assert.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99 Standard: 7.2 Diagnostics <assert.h> / #ifdef _ASSERT_H # undef _ASSERT_H # undef assert # undef __ASSERT_VOID_CAST # ifdef __USE_GNU # undef assert_perror # endif #endif / assert.h / #define _ASSERT_H 1 #include <features.h> #if defined __cplusplus && __GNUC_PREREQ (2,95) # define __ASSERT_VOID_CAST static_cast<void> #else # define __ASSERT_VOID_CAST (void) #endif / void assert (int expression); If NDEBUG is defined, do nothing. If not, and EXPRESSION is zero, print an error message and abort. / #ifdef NDEBUG # define assert(expr) (__ASSERT_VOID_CAST (0)) / void assert_perror (int errnum); If NDEBUG is defined, do nothing. If not, and ERRNUM is not zero, print an error message with the error text for ERRNUM and abort. (This is a GNU extension.) / # ifdef __USE_GNU # define assert_perror(errnum) (__ASSERT_VOID_CAST (0)) # endif #else / Not NDEBUG. / __BEGIN_DECLS / This prints an "Assertion failed" message and aborts. / extern void __assert_fail (const char __assertion, const char __file, unsigned int __line, const char __function) __THROW __attribute__ ((__noreturn__)); /* Likewise, but prints the error text for ERRNUM. / extern void __assert_perror_fail (int __errnum, const char __file, unsigned int __line, const char __function) __THROW __attribute__ ((__noreturn__)); / The following is not at all used here but needed for standard compliance. / extern void __assert (const char __assertion, const char __file, int __line) __THROW __attribute__ ((__noreturn__)); __END_DECLS / When possible, define assert so that it does not add extra parentheses around EXPR. Otherwise, those added parentheses would suppress warnings we'd expect to be detected by gcc's -Wparentheses. / # if defined __cplusplus # define assert(expr) \ (static_cast <bool> (expr) \ ? void (0) \ : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION)) # elif !defined __GNUC__ \|\| defined __STRICT_ANSI__ # define assert(expr) \ ((expr) \ ? __ASSERT_VOID_CAST (0) \ : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION)) # else / The first occurrence of EXPR is not evaluated due to the sizeof, but will trigger any pedantic warnings masked by the __extension__ for the second occurrence. The ternary operator is required to support function pointers and bit fields in this context, and to suppress the evaluation of variable length arrays. / # define assert(expr) \ ((void) sizeof ((expr) ? 1 : 0), __extension__ ({ \ if (expr) \ ; / empty / \ else \ __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION); \ })) # endif # ifdef __USE_GNU # define assert_perror(errnum) \ (!(errnum) \ ? __ASSERT_VOID_CAST (0) \ : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION)) # endif / Version 2.4 and later of GCC define a magical variable `__PRETTY_FUNCTION__' which contains the name of the function currently being defined. This is broken in G++ before version 2.6. C9x has a similar variable called __func__, but prefer the GCC one since it demangles C++ function names. / # if defined __cplusplus ? __GNUC_PREREQ (2, 6) : __GNUC_PREREQ (2, 4) # define __ASSERT_FUNCTION __extension__ __PRETTY_FUNCTION__ # else # if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L # define __ASSERT_FUNCTION __func__ # else # define __ASSERT_FUNCTION ((const char ) 0) # endif # endif #endif /* NDEBUG. */ #if defined __USE_ISOC11 && !defined __cplusplus # undef static_assert # define static_assert _Static_assert #endif	4.46 KB	2026-02-17 11:01
📁 bits	-	2026-03-21 15:44
📁 bsock	-	2025-05-25 12:31
📄 byteswap.h /* Swap byte order for 16, 32 and 64 bit values Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _BYTESWAP_H #define _BYTESWAP_H 1 #include <features.h> / Get the machine specific, optimized definitions. / #include <bits/byteswap.h> / The following definitions must all be macros, otherwise some of the possible optimizations are not possible. / / Return a value with both bytes in the 16 bit argument swapped. / #define bswap_16(x) __bswap_16 (x) / Return a value with all bytes in the 32 bit argument swapped. / #define bswap_32(x) __bswap_32 (x) / Return a value with all bytes in the 64 bit argument swapped. / #define bswap_64(x) __bswap_64 (x) #endif / byteswap.h */	1.42 KB	2026-02-17 11:01
📁 c++	-	2025-09-15 15:41
📄 com_err.h /* * Header file for common error description library. * * Copyright 1988, Student Information Processing Board of the * Massachusetts Institute of Technology. * * For copyright and distribution info, see the documentation supplied * with this package. / #if !defined(__COM_ERR_H) && !defined(__COM_ERR_H__) #ifdef __GNUC__ #define COM_ERR_ATTR(x) __attribute__(x) #else #define COM_ERR_ATTR(x) #endif #include <stddef.h> #include <stdarg.h> typedef long errcode_t; struct error_table { char const const * msgs; long base; int n_msgs; }; struct et_list; extern void com_err (const char , long, const char , ...) COM_ERR_ATTR((format(printf, 3, 4))); extern void com_err_va (const char whoami, errcode_t code, const char fmt, va_list args) COM_ERR_ATTR((format(printf, 3, 0))); extern char const error_message (long); extern void (com_err_hook) (const char , long, const char , va_list); extern void (set_com_err_hook (void () (const char , long, const char , va_list))) (const char , long, const char , va_list); extern void (reset_com_err_hook (void)) (const char , long, const char , va_list); extern int init_error_table(const char const msgs, long base, int count); extern char (set_com_err_gettext (char () (const char ))) (const char ); extern errcode_t add_error_table(const struct error_table et); extern errcode_t remove_error_table(const struct error_table * et); extern void add_to_error_table(struct et_list new_table); / Provided for Heimdall compatibility / extern const char com_right(struct et_list list, long code); extern const char com_right_r(struct et_list list, long code, char str, size_t len); extern void initialize_error_table_r(struct et_list list, const char messages, int num_errors, long base); extern void free_error_table(struct et_list et); / Provided for compatibility with other com_err libraries / extern int et_list_lock(void); extern int et_list_unlock(void); #define __COM_ERR_H #define __COM_ERR_H__ #endif / !defined(__COM_ERR_H) && !defined(__COM_ERR_H__)*/	2.07 KB	2021-12-30 05:54
📄 complex.h /* Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99: 7.3 Complex arithmetic <complex.h> / #ifndef _COMPLEX_H #define _COMPLEX_H 1 #define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION #include <bits/libc-header-start.h> / Get general and ISO C99 specific information. / #include <bits/mathdef.h> / Gather machine-dependent _FloatN type support. / #include <bits/floatn.h> __BEGIN_DECLS / We might need to add support for more compilers here. But since ISO C99 is out hopefully all maintained compilers will soon provide the data types `float complex' and `double complex'. / #if __GNUC_PREREQ (2, 7) && !__GNUC_PREREQ (2, 97) # define _Complex __complex__ #endif #define complex _Complex / Narrowest imaginary unit. This depends on the floating-point evaluation method. XXX This probably has to go into a gcc related file. / #define _Complex_I (__extension__ 1.0iF) / Another more descriptive name is `I'. XXX Once we have the imaginary support switch this to _Imaginary_I. / #undef I #define I _Complex_I #if defined __USE_ISOC11 && __GNUC_PREREQ (4, 7) / Macros to expand into expression of specified complex type. / # 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 #if __HAVE_FLOAT16 && __GLIBC_USE (IEC_60559_TYPES_EXT) # define CMPLXF16(x, y) __builtin_complex ((_Float16) (x), (_Float16) (y)) #endif #if __HAVE_FLOAT32 && __GLIBC_USE (IEC_60559_TYPES_EXT) # define CMPLXF32(x, y) __builtin_complex ((_Float32) (x), (_Float32) (y)) #endif #if __HAVE_FLOAT64 && __GLIBC_USE (IEC_60559_TYPES_EXT) # define CMPLXF64(x, y) __builtin_complex ((_Float64) (x), (_Float64) (y)) #endif #if __HAVE_FLOAT128 && __GLIBC_USE (IEC_60559_TYPES_EXT) # define CMPLXF128(x, y) __builtin_complex ((_Float128) (x), (_Float128) (y)) #endif #if __HAVE_FLOAT32X && __GLIBC_USE (IEC_60559_TYPES_EXT) # define CMPLXF32X(x, y) __builtin_complex ((_Float32x) (x), (_Float32x) (y)) #endif #if __HAVE_FLOAT64X && __GLIBC_USE (IEC_60559_TYPES_EXT) # define CMPLXF64X(x, y) __builtin_complex ((_Float64x) (x), (_Float64x) (y)) #endif #if __HAVE_FLOAT128X && __GLIBC_USE (IEC_60559_TYPES_EXT) # define CMPLXF128X(x, y) \ __builtin_complex ((_Float128x) (x), (_Float128x) (y)) #endif / The file <bits/cmathcalls.h> contains the prototypes for all the actual math functions. These macros are used for those prototypes, so we can easily declare each function as both `name' and `__name', and can declare the float versions `namef' and `__namef'. / #define __MATHCALL(function, args) \ __MATHDECL (_Mdouble_complex_,function, args) #define __MATHDECL_IMPL(type, function, args) \ __MATHDECL_1(type, function, args); \ __MATHDECL_1(type, __CONCAT(__,function), args) #define __MATHDECL(type, function, args) \ __MATHDECL_IMPL(type, function, args) #define __MATHDECL_1_IMPL(type, function, args) \ extern type __MATH_PRECNAME(function) args __THROW #define __MATHDECL_1(type, function, args) \ __MATHDECL_1_IMPL(type, function, args) #define _Mdouble_ double #define __MATH_PRECNAME(name) name #include <bits/cmathcalls.h> #undef _Mdouble_ #undef __MATH_PRECNAME / Now the float versions. / #define _Mdouble_ float #define __MATH_PRECNAME(name) name##f #include <bits/cmathcalls.h> #undef _Mdouble_ #undef __MATH_PRECNAME / And the long double versions. It is non-critical to define them here unconditionally since `long double' is required in ISO C99. / #if !(defined __NO_LONG_DOUBLE_MATH && defined _LIBC) \ \|\| defined __LDBL_COMPAT # ifdef __LDBL_COMPAT # undef __MATHDECL_1 # define __MATHDECL_1(type, function, args) \ extern type __REDIRECT_NTH(__MATH_PRECNAME(function), args, function) # elif __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 # undef __MATHDECL_1 # undef __MATHDECL # define __REDIR_TO(function) \ __ ## function ## ieee128 # define __MATHDECL_1(type, function, alias, args) \ extern type __REDIRECT_NTH(__MATH_PRECNAME(function), args, alias) #define __MATHDECL(type, function, args) \ __MATHDECL_1(type, function, __REDIR_TO(function), args); \ __MATHDECL_1(type, __CONCAT(__,function), __REDIR_TO(function), args) # endif # define _Mdouble_ long double # define __MATH_PRECNAME(name) name##l # include <bits/cmathcalls.h> # if defined __LDBL_COMPAT \ \|\| __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 # undef __REDIR_TO # undef __MATHDECL_1 # undef __MATHDECL #define __MATHDECL(type, function, args) \ __MATHDECL_IMPL(type, function, args) # define __MATHDECL_1(type, function, args) \ __MATHDECL_1_IMPL(type, function, args) # endif #endif #undef _Mdouble_ #undef __MATH_PRECNAME #if (__HAVE_DISTINCT_FLOAT16 \|\| (__HAVE_FLOAT16 && !defined _LIBC)) \ && __GLIBC_USE (IEC_60559_TYPES_EXT) # undef _Mdouble_complex_ # define _Mdouble_complex_ __CFLOAT16 # define _Mdouble_ _Float16 # define __MATH_PRECNAME(name) name##f16 # include <bits/cmathcalls.h> # undef _Mdouble_ # undef __MATH_PRECNAME # undef _Mdouble_complex_ #endif #if (__HAVE_DISTINCT_FLOAT32 \|\| (__HAVE_FLOAT32 && !defined _LIBC)) \ && __GLIBC_USE (IEC_60559_TYPES_EXT) # undef _Mdouble_complex_ # define _Mdouble_complex_ __CFLOAT32 # define _Mdouble_ _Float32 # define __MATH_PRECNAME(name) name##f32 # include <bits/cmathcalls.h> # undef _Mdouble_ # undef __MATH_PRECNAME # undef _Mdouble_complex_ #endif #if (__HAVE_DISTINCT_FLOAT64 \|\| (__HAVE_FLOAT64 && !defined _LIBC)) \ && __GLIBC_USE (IEC_60559_TYPES_EXT) # undef _Mdouble_complex_ # define _Mdouble_complex_ __CFLOAT64 # define _Mdouble_ _Float64 # define __MATH_PRECNAME(name) name##f64 # include <bits/cmathcalls.h> # undef _Mdouble_ # undef __MATH_PRECNAME # undef _Mdouble_complex_ #endif #if (__HAVE_DISTINCT_FLOAT128 \|\| (__HAVE_FLOAT128 && !defined _LIBC)) \ && __GLIBC_USE (IEC_60559_TYPES_EXT) # undef _Mdouble_complex_ # define _Mdouble_complex_ __CFLOAT128 # define _Mdouble_ _Float128 # define __MATH_PRECNAME(name) name##f128 # include <bits/cmathcalls.h> # undef _Mdouble_ # undef __MATH_PRECNAME # undef _Mdouble_complex_ #endif #if (__HAVE_DISTINCT_FLOAT32X \|\| (__HAVE_FLOAT32X && !defined _LIBC)) \ && __GLIBC_USE (IEC_60559_TYPES_EXT) # undef _Mdouble_complex_ # define _Mdouble_complex_ __CFLOAT32X # define _Mdouble_ _Float32x # define __MATH_PRECNAME(name) name##f32x # include <bits/cmathcalls.h> # undef _Mdouble_ # undef __MATH_PRECNAME # undef _Mdouble_complex_ #endif #if (__HAVE_DISTINCT_FLOAT64X \|\| (__HAVE_FLOAT64X && !defined _LIBC)) \ && __GLIBC_USE (IEC_60559_TYPES_EXT) # undef _Mdouble_complex_ # define _Mdouble_complex_ __CFLOAT64X # define _Mdouble_ _Float64x # define __MATH_PRECNAME(name) name##f64x # include <bits/cmathcalls.h> # undef _Mdouble_ # undef __MATH_PRECNAME # undef _Mdouble_complex_ #endif #if (__HAVE_DISTINCT_FLOAT128X \|\| (__HAVE_FLOAT128X && !defined _LIBC)) \ && __GLIBC_USE (IEC_60559_TYPES_EXT) # undef _Mdouble_complex_ # define _Mdouble_complex_ __CFLOAT128X # define _Mdouble_ _Float128x # define __MATH_PRECNAME(name) name##f128x # include <bits/cmathcalls.h> # undef _Mdouble_ # undef __MATH_PRECNAME # undef _Mdouble_complex_ #endif #undef __MATHDECL_1_IMPL #undef __MATHDECL_1 #undef __MATHDECL #undef __MATHCALL __END_DECLS #endif / complex.h */	7.95 KB	2026-02-17 11:01
📄 cpio.h /* Extended cpio format from POSIX.1. This file is part of the GNU C Library. Copyright (C) 1992-2021 Free Software Foundation, Inc. NOTE: The canonical source of this file is maintained with the GNU cpio. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _CPIO_H #define _CPIO_H 1 / A cpio archive consists of a sequence of files. Each file has a 76 byte header, a variable length, NUL terminated filename, and variable length file data. A header for a filename "TRAILER!!!" indicates the end of the archive. / / All the fields in the header are ISO 646 (approximately ASCII) strings of octal numbers, left padded, not NUL terminated. Field Name Length in Bytes Notes c_magic 6 must be "070707" c_dev 6 c_ino 6 c_mode 6 see below for value c_uid 6 c_gid 6 c_nlink 6 c_rdev 6 only valid for chr and blk special files c_mtime 11 c_namesize 6 count includes terminating NUL in pathname c_filesize 11 must be 0 for FIFOs and directories / / Value for the field `c_magic'. / #define MAGIC "070707" / Values for c_mode, OR'd together: / #define C_IRUSR 000400 #define C_IWUSR 000200 #define C_IXUSR 000100 #define C_IRGRP 000040 #define C_IWGRP 000020 #define C_IXGRP 000010 #define C_IROTH 000004 #define C_IWOTH 000002 #define C_IXOTH 000001 #define C_ISUID 004000 #define C_ISGID 002000 #define C_ISVTX 001000 #define C_ISBLK 060000 #define C_ISCHR 020000 #define C_ISDIR 040000 #define C_ISFIFO 010000 #define C_ISSOCK 0140000 #define C_ISLNK 0120000 #define C_ISCTG 0110000 #define C_ISREG 0100000 #endif / cpio.h */	2.21 KB	2026-02-17 11:01
📄 cpuidle.h /* SPDX-License-Identifier: GPL-2.0 / #ifndef __CPUPOWER_CPUIDLE_H__ #define __CPUPOWER_CPUIDLE_H__ int cpuidle_is_state_disabled(unsigned int cpu, unsigned int idlestate); int cpuidle_state_disable(unsigned int cpu, unsigned int idlestate, unsigned int disable); unsigned long cpuidle_state_latency(unsigned int cpu, unsigned int idlestate); unsigned long cpuidle_state_residency(unsigned int cpu, unsigned int idlestate); unsigned long cpuidle_state_usage(unsigned int cpu, unsigned int idlestate); unsigned long long cpuidle_state_time(unsigned int cpu, unsigned int idlestate); char cpuidle_state_name(unsigned int cpu, unsigned int idlestate); char cpuidle_state_desc(unsigned int cpu, unsigned int idlestate); unsigned int cpuidle_state_count(unsigned int cpu); char cpuidle_get_governor(void); char cpuidle_get_driver(void); #endif / __CPUPOWER_HELPERS_SYSFS_H__ */	931 B	2026-03-24 10:02
📄 crypt.h /* High-level libcrypt interfaces. Copyright (C) 1991-2017 Free Software Foundation, Inc. This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _CRYPT_H #define _CRYPT_H 1 #include <sys/cdefs.h> __BEGIN_DECLS / The strings returned by crypt, crypt_r, crypt_rn, and crypt_ra will be no longer than this, counting the terminating NUL. (Existing algorithms all produce much shorter strings, but we have reserved generous space for future expansion.) This is NOT the appropriate size to use in allocating the buffer supplied to crypt_rn; use sizeof (struct crypt_data) instead. / #define CRYPT_OUTPUT_SIZE 384 / Passphrases longer than this (counting the terminating NUL) are not supported. Note that some hash algorithms have lower limits. / #define CRYPT_MAX_PASSPHRASE_SIZE 512 / The strings returned by crypt_gensalt, crypt_gensalt_rn, and crypt_gensalt_ra will be no longer than this. This IS the appropriate size to use when allocating the buffer supplied to crypt_gensalt_rn. (Again, existing algorithms all produce much shorter strings, but we have reserved generous space for future expansion.) / #define CRYPT_GENSALT_OUTPUT_SIZE 192 / One-way hash the passphrase PHRASE as specified by SETTING, and return a string suitable for storage in a Unix-style "passwd" file. If SETTING is a previously hashed passphrase, the string returned will be equal to SETTING if and only if PHRASE is the same as the passphrase that was previously hashed. See the documentation for other ways to use this function. The string returned by this function is stored in a statically- allocated buffer, and will be overwritten if the function is called again. It is not safe to call this function from multiple threads concurrently. If an error occurs (such as SETTING being nonsense or unsupported) the string returned will begin with '', and will not be equal to SETTING nor to any valid hashed passphrase. Otherwise, the string will not begin with ''. / extern char crypt (const char __phrase, const char __setting) __THROW; /* These sizes are chosen to make sizeof (struct crypt_data) add up to exactly 32768 bytes. / #define CRYPT_DATA_RESERVED_SIZE 767 #define CRYPT_DATA_INTERNAL_SIZE 30720 / Memory area used by crypt_r. / struct crypt_data { / crypt_r writes the hashed password to this field of its 'data' argument. crypt_rn and crypt_ra do the same, treating the untyped data area they are supplied with as this struct. / char output[CRYPT_OUTPUT_SIZE]; / Applications are encouraged, but not required, to use this field to store the "setting" string that must be passed to crypt_. Future extensions to the API may make this more ergonomic. A valid "setting" is either previously hashed password or the string produced by one of the crypt_gensalt functions; see the crypt_gensalt documentation for further details. / char setting[CRYPT_OUTPUT_SIZE]; /* Applications are encouraged, but not required, to use this field to store the unhashed passphrase they will pass to crypt_. Future extensions to the API may make this more ergonomic. / char input[CRYPT_MAX_PASSPHRASE_SIZE]; /* Reserved for future application-visible fields. For maximum forward compatibility, applications should set this field to all bytes zero before calling crypt_r, crypt_rn, or crypt_ra for the first time with a just-allocated 'struct crypt_data'. Future extensions to the API may make this more ergonomic. / char reserved[CRYPT_DATA_RESERVED_SIZE]; / This field should be set to 0 before calling crypt_r, crypt_rn, or crypt_ra for the first time with a just-allocated 'struct crypt_data'. This is not required if crypt_ra is allowed to do the allocation itself (i.e. if the DATA argument is a null pointer). Future extensions to the API may make this more ergonomic. / char initialized; /* Scratch space used internally. Applications should not read or write this field. All data written to this area is erased before returning from the library. / char internal[CRYPT_DATA_INTERNAL_SIZE]; }; / Thread-safe version of crypt. Instead of writing to a static storage area, the string returned by this function will be within DATA->output. Otherwise, behaves exactly the same as crypt. / extern char crypt_r (const char __phrase, const char __setting, struct crypt_data __restrict __data) __THROW; / Another thread-safe version of crypt. Instead of writing to a static storage area, the string returned by this function will be somewhere within the space provided at DATA, which is of length SIZE bytes. SIZE must be at least sizeof (struct crypt_data). Also, if an error occurs, this function returns a null pointer, not a special string. (However, the string returned on success still will never begin with ''.) / extern char crypt_rn (const char __phrase, const char __setting, void __data, int __size) __THROW; /* Yet a third thread-safe version of crypt; this one works like getline(3). DATA must be either 0 or a pointer to memory allocated by malloc, and SIZE must be the size of the allocation. This space will be allocated or reallocated as necessary and the values updated. The string returned by this function will be somewhere within the space at DATA. It is safe to deallocate this space with free when it is no longer needed. Like crypt_rn, this function returns a null pointer on failure, not a special string. / extern char crypt_ra (const char __phrase, const char __setting, void __data, int __size) __THROW; /* Generate a string suitable for use as the setting when hashing a new passphrase. PREFIX controls which hash function will be used, COUNT controls the computational cost of the hash (for functions where this is tunable), and RBYTES should point to NRBYTES bytes of random data. If PREFIX is a null pointer, the current best default is used; if RBYTES is a null pointer, random data will be retrieved from the operating system if possible. (Caution: setting PREFIX to an empty string selects the use of the oldest and least secure hash in the library. Don't do that.) The string returned is stored in a statically-allocated buffer, and will be overwritten if the function is called again. It is not safe to call this function from multiple threads concurrently. However, within a single thread, it is safe to pass the string as the SETTING argument to crypt without copying it first; the two functions use separate buffers. If an error occurs (e.g. a prefix that does not correspond to a supported hash function, or an inadequate amount of random data), this function returns a null pointer. / extern char crypt_gensalt (const char __prefix, unsigned long __count, const char __rbytes, int __nrbytes) __THROW; /* Thread-safe version of crypt_gensalt; instead of a statically-allocated buffer, the generated setting string is written to OUTPUT, which is OUTPUT_SIZE bytes long. OUTPUT_SIZE must be at least CRYPT_GENSALT_OUTPUT_SIZE (see above). If an error occurs, this function returns a null pointer and writes a string that does not correspond to any valid setting into OUTPUT. / extern char crypt_gensalt_rn (const char __prefix, unsigned long __count, const char __rbytes, int __nrbytes, char __output, int __output_size) __THROW; / Kept for code compatibility with libxcrypt (v3.1.1 and earlier). We intentionally declare the function using a macro here, since we actually want to link compiled applications against the identical crypt_gensalt_rn function. / #ifndef IN_LIBCRYPT / Defined when building libxcrypt. / # ifdef __REDIRECT_NTH extern char __REDIRECT_NTH (crypt_gensalt_r, (const char __prefix, unsigned long __count, const char __rbytes, int __nrbytes, char __output, int __output_size), crypt_gensalt_rn); # else # define crypt_gensalt_r crypt_gensalt_rn # endif #endif / Another thread-safe version of crypt_gensalt; the generated setting string is in storage allocated by malloc, and should be deallocated with free when it is no longer needed. / extern char crypt_gensalt_ra (const char __prefix, unsigned long __count, const char __rbytes, int __nrbytes) __THROW; /* Checks whether the given setting is a supported method. The return value is 0 if there is nothing wrong with this setting. Otherwise, it is one of the following constants. / extern int crypt_checksalt (const char __setting); /* Constants for checking the return value of the crypt_checksalt function. / #define CRYPT_SALT_OK 0 #define CRYPT_SALT_INVALID 1 #define CRYPT_SALT_METHOD_DISABLED 2 / NOT implemented, yet. / #define CRYPT_SALT_METHOD_LEGACY 3 / NOT implemented, yet. / #define CRYPT_SALT_TOO_CHEAP 4 / NOT implemented, yet. / / Convenience function to get the prefix of the preferred hash method, which is also used by the crypt_gensalt functions, if their given prefix parameter is NULL. The return value is string that equals the prefix of the preferred hash method. Otherwise, it is NULL. / extern const char crypt_preferred_method (void); /* These macros could be checked by portable users of crypt_gensalt* functions to find out whether null pointers could be specified as PREFIX and RBYTES arguments. / #define CRYPT_GENSALT_IMPLEMENTS_DEFAULT_PREFIX 1 #define CRYPT_GENSALT_IMPLEMENTS_AUTO_ENTROPY 1 / These macros can be checked by portable users of libxcrypt to find out whether the function is implemented. / #define CRYPT_CHECKSALT_AVAILABLE 1 #define CRYPT_PREFERRED_METHOD_AVAILABLE 1 / Version number split in single integers. / #define XCRYPT_VERSION_MAJOR 4 #define XCRYPT_VERSION_MINOR 4 / Version number coded into an integer. / #define XCRYPT_VERSION_NUM ((XCRYPT_VERSION_MAJOR << 16) \| \ XCRYPT_VERSION_MINOR) / Version number as a string constant. / #define XCRYPT_VERSION_STR "4.4.18" __END_DECLS #endif / crypt.h */	10.9 KB	2022-02-10 04:05
📄 ctype.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99 Standard 7.4: Character handling <ctype.h> / #ifndef _CTYPE_H #define _CTYPE_H 1 #include <features.h> #include <bits/types.h> __BEGIN_DECLS #ifndef _ISbit / These are all the characteristics of characters. If there get to be more than 16 distinct characteristics, many things must be changed that use `unsigned short int's. The characteristics are stored always in network byte order (big endian). We define the bit value interpretations here dependent on the machine's byte order. / # include <bits/endian.h> # if __BYTE_ORDER == __BIG_ENDIAN # define _ISbit(bit) (1 << (bit)) # else / __BYTE_ORDER == __LITTLE_ENDIAN / # define _ISbit(bit) ((bit) < 8 ? ((1 << (bit)) << 8) : ((1 << (bit)) >> 8)) # endif enum { _ISupper = _ISbit (0), / UPPERCASE. / _ISlower = _ISbit (1), / lowercase. / _ISalpha = _ISbit (2), / Alphabetic. / _ISdigit = _ISbit (3), / Numeric. / _ISxdigit = _ISbit (4), / Hexadecimal numeric. / _ISspace = _ISbit (5), / Whitespace. / _ISprint = _ISbit (6), / Printing. / _ISgraph = _ISbit (7), / Graphical. / _ISblank = _ISbit (8), / Blank (usually SPC and TAB). / _IScntrl = _ISbit (9), / Control character. / _ISpunct = _ISbit (10), / Punctuation. / _ISalnum = _ISbit (11) / Alphanumeric. / }; #endif / ! _ISbit / / These are defined in ctype-info.c. The declarations here must match those in localeinfo.h. In the thread-specific locale model (see `uselocale' in <locale.h>) we cannot use global variables for these as was done in the past. Instead, the following accessor functions return the address of each variable, which is local to the current thread if multithreaded. These point into arrays of 384, so they can be indexed by any `unsigned char' value [0,255]; by EOF (-1); or by any `signed char' value [-128,-1). ISO C requires that the ctype functions work for `unsigned char' values and for EOF; we also support negative `signed char' values for broken old programs. The case conversion arrays are of `int's rather than `unsigned char's because tolower (EOF) must be EOF, which doesn't fit into an `unsigned char'. But today more important is that the arrays are also used for multi-byte character sets. / extern const unsigned short int __ctype_b_loc (void) __THROW __attribute__ ((__const__)); extern const __int32_t __ctype_tolower_loc (void) __THROW __attribute__ ((__const__)); extern const __int32_t __ctype_toupper_loc (void) __THROW __attribute__ ((__const__)); #ifndef __cplusplus # define __isctype(c, type) \ ((__ctype_b_loc ())[(int) (c)] & (unsigned short int) type) #elif defined __USE_EXTERN_INLINES # define __isctype_f(type) \ __extern_inline int \ is##type (int __c) __THROW \ { \ return (__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _IS##type; \ } #endif #define __isascii(c) (((c) & ~0x7f) == 0) / If C is a 7 bit value. / #define __toascii(c) ((c) & 0x7f) / Mask off high bits. / #define __exctype(name) extern int name (int) __THROW / The following names are all functions: int isCHARACTERISTIC(int c); which return nonzero iff C has CHARACTERISTIC. For the meaning of the characteristic names, see the `enum' above. / __exctype (isalnum); __exctype (isalpha); __exctype (iscntrl); __exctype (isdigit); __exctype (islower); __exctype (isgraph); __exctype (isprint); __exctype (ispunct); __exctype (isspace); __exctype (isupper); __exctype (isxdigit); / Return the lowercase version of C. / extern int tolower (int __c) __THROW; / Return the uppercase version of C. / extern int toupper (int __c) __THROW; / ISO C99 introduced one new function. / #ifdef __USE_ISOC99 __exctype (isblank); #endif #ifdef __USE_GNU / Test C for a set of character classes according to MASK. / extern int isctype (int __c, int __mask) __THROW; #endif #if defined __USE_MISC \|\| defined __USE_XOPEN / Return nonzero iff C is in the ASCII set (i.e., is no more than 7 bits wide). / extern int isascii (int __c) __THROW; / Return the part of C that is in the ASCII set (i.e., the low-order 7 bits of C). / extern int toascii (int __c) __THROW; / These are the same as `toupper' and `tolower' except that they do not check the argument for being in the range of a `char'. / __exctype (_toupper); __exctype (_tolower); #endif / Use X/Open or use misc. / / This code is needed for the optimized mapping functions. / #define __tobody(c, f, a, args) \ (__extension__ \ ({ int __res; \ if (sizeof (c) > 1) \ { \ if (__builtin_constant_p (c)) \ { \ int __c = (c); \ __res = __c < -128 \|\| __c > 255 ? __c : (a)[__c]; \ } \ else \ __res = f args; \ } \ else \ __res = (a)[(int) (c)]; \ __res; })) #if !defined __NO_CTYPE # ifdef __isctype_f __isctype_f (alnum) __isctype_f (alpha) __isctype_f (cntrl) __isctype_f (digit) __isctype_f (lower) __isctype_f (graph) __isctype_f (print) __isctype_f (punct) __isctype_f (space) __isctype_f (upper) __isctype_f (xdigit) # ifdef __USE_ISOC99 __isctype_f (blank) # endif # elif defined __isctype # define isalnum(c) __isctype((c), _ISalnum) # define isalpha(c) __isctype((c), _ISalpha) # define iscntrl(c) __isctype((c), _IScntrl) # define isdigit(c) __isctype((c), _ISdigit) # define islower(c) __isctype((c), _ISlower) # define isgraph(c) __isctype((c), _ISgraph) # define isprint(c) __isctype((c), _ISprint) # define ispunct(c) __isctype((c), _ISpunct) # define isspace(c) __isctype((c), _ISspace) # define isupper(c) __isctype((c), _ISupper) # define isxdigit(c) __isctype((c), _ISxdigit) # ifdef __USE_ISOC99 # define isblank(c) __isctype((c), _ISblank) # endif # endif # ifdef __USE_EXTERN_INLINES __extern_inline int __NTH (tolower (int __c)) { return __c >= -128 && __c < 256 ? (__ctype_tolower_loc ())[__c] : __c; } __extern_inline int __NTH (toupper (int __c)) { return __c >= -128 && __c < 256 ? (__ctype_toupper_loc ())[__c] : __c; } # endif # if __GNUC__ >= 2 && defined __OPTIMIZE__ && !defined __cplusplus # define tolower(c) __tobody (c, tolower, __ctype_tolower_loc (), (c)) # define toupper(c) __tobody (c, toupper, __ctype_toupper_loc (), (c)) # endif / Optimizing gcc / # if defined __USE_MISC \|\| defined __USE_XOPEN # define isascii(c) __isascii (c) # define toascii(c) __toascii (c) # define _tolower(c) ((int) (__ctype_tolower_loc ())[(int) (c)]) # define _toupper(c) ((int) (__ctype_toupper_loc ())[(int) (c)]) # endif #endif / Not __NO_CTYPE. / #ifdef __USE_XOPEN2K8 / POSIX.1-2008 extended locale interface (see locale.h). / # include <bits/types/locale_t.h> / These definitions are similar to the ones above but all functions take as an argument a handle for the locale which shall be used. / # define __isctype_l(c, type, locale) \ ((locale)->__ctype_b[(int) (c)] & (unsigned short int) type) # define __exctype_l(name) \ extern int name (int, locale_t) __THROW / The following names are all functions: int isCHARACTERISTIC(int c, locale_t locale); which return nonzero iff C has CHARACTERISTIC. For the meaning of the characteristic names, see the `enum' above. / __exctype_l (isalnum_l); __exctype_l (isalpha_l); __exctype_l (iscntrl_l); __exctype_l (isdigit_l); __exctype_l (islower_l); __exctype_l (isgraph_l); __exctype_l (isprint_l); __exctype_l (ispunct_l); __exctype_l (isspace_l); __exctype_l (isupper_l); __exctype_l (isxdigit_l); __exctype_l (isblank_l); /* Return the lowercase version of C in locale L. / extern int __tolower_l (int __c, locale_t __l) __THROW; extern int tolower_l (int __c, locale_t __l) __THROW; / Return the uppercase version of C. / extern int __toupper_l (int __c, locale_t __l) __THROW; extern int toupper_l (int __c, locale_t __l) __THROW; # if __GNUC__ >= 2 && defined __OPTIMIZE__ && !defined __cplusplus # define __tolower_l(c, locale) \ __tobody (c, __tolower_l, (locale)->__ctype_tolower, (c, locale)) # define __toupper_l(c, locale) \ __tobody (c, __toupper_l, (locale)->__ctype_toupper, (c, locale)) # define tolower_l(c, locale) __tolower_l ((c), (locale)) # define toupper_l(c, locale) __toupper_l ((c), (locale)) # endif / Optimizing gcc / # ifndef __NO_CTYPE # define __isalnum_l(c,l) __isctype_l((c), _ISalnum, (l)) # define __isalpha_l(c,l) __isctype_l((c), _ISalpha, (l)) # define __iscntrl_l(c,l) __isctype_l((c), _IScntrl, (l)) # define __isdigit_l(c,l) __isctype_l((c), _ISdigit, (l)) # define __islower_l(c,l) __isctype_l((c), _ISlower, (l)) # define __isgraph_l(c,l) __isctype_l((c), _ISgraph, (l)) # define __isprint_l(c,l) __isctype_l((c), _ISprint, (l)) # define __ispunct_l(c,l) __isctype_l((c), _ISpunct, (l)) # define __isspace_l(c,l) __isctype_l((c), _ISspace, (l)) # define __isupper_l(c,l) __isctype_l((c), _ISupper, (l)) # define __isxdigit_l(c,l) __isctype_l((c), _ISxdigit, (l)) # define __isblank_l(c,l) __isctype_l((c), _ISblank, (l)) # ifdef __USE_MISC # define __isascii_l(c,l) ((l), __isascii (c)) # define __toascii_l(c,l) ((l), __toascii (c)) # endif # define isalnum_l(c,l) __isalnum_l ((c), (l)) # define isalpha_l(c,l) __isalpha_l ((c), (l)) # define iscntrl_l(c,l) __iscntrl_l ((c), (l)) # define isdigit_l(c,l) __isdigit_l ((c), (l)) # define islower_l(c,l) __islower_l ((c), (l)) # define isgraph_l(c,l) __isgraph_l ((c), (l)) # define isprint_l(c,l) __isprint_l ((c), (l)) # define ispunct_l(c,l) __ispunct_l ((c), (l)) # define isspace_l(c,l) __isspace_l ((c), (l)) # define isupper_l(c,l) __isupper_l ((c), (l)) # define isxdigit_l(c,l) __isxdigit_l ((c), (l)) # define isblank_l(c,l) __isblank_l ((c), (l)) # ifdef __USE_MISC # define isascii_l(c,l) __isascii_l ((c), (l)) # define toascii_l(c,l) __toascii_l ((c), (l)) # endif # endif / Not __NO_CTYPE. / #endif / Use POSIX 2008. / __END_DECLS #endif / ctype.h */	10.71 KB	2026-02-17 11:01
📁 curl	-	2026-03-21 15:45
📄 dirent.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * POSIX Standard: 5.1.2 Directory Operations <dirent.h> / #ifndef _DIRENT_H #define _DIRENT_H 1 #include <features.h> __BEGIN_DECLS #include <bits/types.h> #ifdef __USE_XOPEN # ifndef __ino_t_defined # ifndef __USE_FILE_OFFSET64 typedef __ino_t ino_t; # else typedef __ino64_t ino_t; # endif # define __ino_t_defined # endif # if defined __USE_LARGEFILE64 && !defined __ino64_t_defined typedef __ino64_t ino64_t; # define __ino64_t_defined # endif #endif / This file defines `struct dirent'. It defines the macro `_DIRENT_HAVE_D_NAMLEN' iff there is a `d_namlen' member that gives the length of `d_name'. It defines the macro `_DIRENT_HAVE_D_RECLEN' iff there is a `d_reclen' member that gives the size of the entire directory entry. It defines the macro `_DIRENT_HAVE_D_OFF' iff there is a `d_off' member that gives the file offset of the next directory entry. It defines the macro `_DIRENT_HAVE_D_TYPE' iff there is a `d_type' member that gives the type of the file. / #include <bits/dirent.h> #if defined __USE_MISC && !defined d_fileno # define d_ino d_fileno / Backward compatibility. / #endif / These macros extract size information from a `struct dirent '. They may evaluate their argument multiple times, so it must not have side effects. Each of these may involve a relatively costly call to `strlen' on some systems, so these values should be cached. _D_EXACT_NAMLEN (DP) returns the length of DP->d_name, not including its terminating null character. _D_ALLOC_NAMLEN (DP) returns a size at least (_D_EXACT_NAMLEN (DP) + 1); that is, the allocation size needed to hold the DP->d_name string. Use this macro when you don't need the exact length, just an upper bound. This macro is less likely to require calling `strlen' than _D_EXACT_NAMLEN. / #ifdef _DIRENT_HAVE_D_NAMLEN # define _D_EXACT_NAMLEN(d) ((d)->d_namlen) # define _D_ALLOC_NAMLEN(d) (_D_EXACT_NAMLEN (d) + 1) #else # define _D_EXACT_NAMLEN(d) (strlen ((d)->d_name)) # ifdef _DIRENT_HAVE_D_RECLEN # define _D_ALLOC_NAMLEN(d) (((char ) (d) + (d)->d_reclen) - &(d)->d_name[0]) # else # define _D_ALLOC_NAMLEN(d) (sizeof (d)->d_name > 1 ? sizeof (d)->d_name \ : _D_EXACT_NAMLEN (d) + 1) # endif #endif #ifdef __USE_MISC / File types for `d_type'. / enum { DT_UNKNOWN = 0, # define DT_UNKNOWN DT_UNKNOWN DT_FIFO = 1, # define DT_FIFO DT_FIFO DT_CHR = 2, # define DT_CHR DT_CHR DT_DIR = 4, # define DT_DIR DT_DIR DT_BLK = 6, # define DT_BLK DT_BLK DT_REG = 8, # define DT_REG DT_REG DT_LNK = 10, # define DT_LNK DT_LNK DT_SOCK = 12, # define DT_SOCK DT_SOCK DT_WHT = 14 # define DT_WHT DT_WHT }; / Convert between stat structure types and directory types. / # define IFTODT(mode) (((mode) & 0170000) >> 12) # define DTTOIF(dirtype) ((dirtype) << 12) #endif / This is the data type of directory stream objects. The actual structure is opaque to users. / typedef struct __dirstream DIR; / Close the directory stream DIRP. Return 0 if successful, -1 if not. This function is a possible cancellation point and therefore not marked with __THROW. / extern int closedir (DIR __dirp) __nonnull ((1)); /* Open a directory stream on NAME. Return a DIR stream on the directory, or NULL if it could not be opened. This function is a possible cancellation point and therefore not marked with __THROW. / extern DIR opendir (const char __name) __nonnull ((1)) __attribute_malloc__ __attr_dealloc (closedir, 1); #ifdef __USE_XOPEN2K8 / Same as opendir, but open the stream on the file descriptor FD. This function is a possible cancellation point and therefore not marked with __THROW. / extern DIR fdopendir (int __fd) __attribute_malloc__ __attr_dealloc (closedir, 1); #endif /* Read a directory entry from DIRP. Return a pointer to a `struct dirent' describing the entry, or NULL for EOF or error. The storage returned may be overwritten by a later readdir call on the same DIR stream. If the Large File Support API is selected we have to use the appropriate interface. This function is a possible cancellation point and therefore not marked with __THROW. / #ifndef __USE_FILE_OFFSET64 extern struct dirent readdir (DIR __dirp) __nonnull ((1)); #else # ifdef __REDIRECT extern struct dirent __REDIRECT (readdir, (DIR __dirp), readdir64) __nonnull ((1)); # else # define readdir readdir64 # endif #endif #ifdef __USE_LARGEFILE64 extern struct dirent64 readdir64 (DIR __dirp) __nonnull ((1)); #endif #ifdef __USE_POSIX / Reentrant version of `readdir'. Return in RESULT a pointer to the next entry. This function is a possible cancellation point and therefore not marked with __THROW. / # ifndef __USE_FILE_OFFSET64 extern int readdir_r (DIR __restrict __dirp, struct dirent __restrict __entry, struct dirent __restrict __result) __nonnull ((1, 2, 3)) __attribute_deprecated__; # else # ifdef __REDIRECT extern int __REDIRECT (readdir_r, (DIR __restrict __dirp, struct dirent __restrict __entry, struct dirent __restrict __result), readdir64_r) __nonnull ((1, 2, 3)) __attribute_deprecated__; # else # define readdir_r readdir64_r # endif # endif # ifdef __USE_LARGEFILE64 extern int readdir64_r (DIR __restrict __dirp, struct dirent64 __restrict __entry, struct dirent64 __restrict __result) __nonnull ((1, 2, 3)) __attribute_deprecated__; # endif #endif / POSIX or misc / / Rewind DIRP to the beginning of the directory. / extern void rewinddir (DIR __dirp) __THROW __nonnull ((1)); #if defined __USE_MISC \|\| defined __USE_XOPEN # include <bits/types.h> /* Seek to position POS on DIRP. / extern void seekdir (DIR __dirp, long int __pos) __THROW __nonnull ((1)); /* Return the current position of DIRP. / extern long int telldir (DIR __dirp) __THROW __nonnull ((1)); #endif #ifdef __USE_XOPEN2K8 /* Return the file descriptor used by DIRP. / extern int dirfd (DIR __dirp) __THROW __nonnull ((1)); # if defined __OPTIMIZE__ && defined _DIR_dirfd # define dirfd(dirp) _DIR_dirfd (dirp) # endif # ifdef __USE_MISC # ifndef MAXNAMLEN /* Get the definitions of the POSIX.1 limits. / # include <bits/posix1_lim.h> / `MAXNAMLEN' is the BSD name for what POSIX calls `NAME_MAX'. / # ifdef NAME_MAX # define MAXNAMLEN NAME_MAX # else # define MAXNAMLEN 255 # endif # endif # endif # define __need_size_t # include <stddef.h> / Scan the directory DIR, calling SELECTOR on each directory entry. Entries for which SELECT returns nonzero are individually malloc'd, sorted using qsort with CMP, and collected in a malloc'd array in NAMELIST. Returns the number of entries selected, or -1 on error. This function is a cancellation point and therefore not marked with __THROW. / # ifndef __USE_FILE_OFFSET64 extern int scandir (const char __restrict __dir, struct dirent *__restrict __namelist, int (__selector) (const struct dirent ), int (__cmp) (const struct dirent , const struct dirent )) __nonnull ((1, 2)); # else # ifdef __REDIRECT extern int __REDIRECT (scandir, (const char __restrict __dir, struct dirent *__restrict __namelist, int (__selector) (const struct dirent ), int (__cmp) (const struct dirent , const struct dirent )), scandir64) __nonnull ((1, 2)); # else # define scandir scandir64 # endif # endif # if defined __USE_GNU && defined __USE_LARGEFILE64 /* This function is like `scandir' but it uses the 64bit dirent structure. Please note that the CMP function must now work with struct dirent64 *. / extern int scandir64 (const char __restrict __dir, struct dirent64 *__restrict __namelist, int (__selector) (const struct dirent64 ), int (__cmp) (const struct dirent64 , const struct dirent64 )) __nonnull ((1, 2)); # endif # ifdef __USE_GNU /* Similar to `scandir' but a relative DIR name is interpreted relative to the directory for which DFD is a descriptor. This function is a cancellation point and therefore not marked with __THROW. / # ifndef __USE_FILE_OFFSET64 extern int scandirat (int __dfd, const char __restrict __dir, struct dirent **__restrict __namelist, int (__selector) (const struct dirent ), int (__cmp) (const struct dirent , const struct dirent )) __nonnull ((2, 3)); # else # ifdef __REDIRECT extern int __REDIRECT (scandirat, (int __dfd, const char __restrict __dir, struct dirent *__restrict __namelist, int (__selector) (const struct dirent ), int (__cmp) (const struct dirent , const struct dirent )), scandirat64) __nonnull ((2, 3)); # else # define scandirat scandirat64 # endif # endif /* This function is like `scandir' but it uses the 64bit dirent structure. Please note that the CMP function must now work with struct dirent64 *. / extern int scandirat64 (int __dfd, const char __restrict __dir, struct dirent64 *__restrict __namelist, int (__selector) (const struct dirent64 ), int (__cmp) (const struct dirent64 , const struct dirent64 )) __nonnull ((2, 3)); # endif /* Function to compare two `struct dirent's alphabetically. / # ifndef __USE_FILE_OFFSET64 extern int alphasort (const struct dirent __e1, const struct dirent __e2) __THROW __attribute_pure__ __nonnull ((1, 2)); # else # ifdef __REDIRECT extern int __REDIRECT_NTH (alphasort, (const struct dirent __e1, const struct dirent __e2), alphasort64) __attribute_pure__ __nonnull ((1, 2)); # else # define alphasort alphasort64 # endif # endif # if defined __USE_GNU && defined __USE_LARGEFILE64 extern int alphasort64 (const struct dirent64 __e1, const struct dirent64 __e2) __THROW __attribute_pure__ __nonnull ((1, 2)); # endif #endif / Use XPG7. / #ifdef __USE_MISC / Read directory entries from FD into BUF, reading at most NBYTES. Reading starts at offset BASEP, and BASEP is updated with the new position after reading. Returns the number of bytes read; zero when at end of directory; or -1 for errors. / # ifndef __USE_FILE_OFFSET64 extern __ssize_t getdirentries (int __fd, char __restrict __buf, size_t __nbytes, __off_t __restrict __basep) __THROW __nonnull ((2, 4)); # else # ifdef __REDIRECT extern __ssize_t __REDIRECT_NTH (getdirentries, (int __fd, char __restrict __buf, size_t __nbytes, __off64_t __restrict __basep), getdirentries64) __nonnull ((2, 4)); # else # define getdirentries getdirentries64 # endif # endif # ifdef __USE_LARGEFILE64 extern __ssize_t getdirentries64 (int __fd, char __restrict __buf, size_t __nbytes, __off64_t __restrict __basep) __THROW __nonnull ((2, 4)); # endif #endif / Use misc. / #ifdef __USE_GNU / Function to compare two `struct dirent's by name & version. / # ifndef __USE_FILE_OFFSET64 extern int versionsort (const struct dirent __e1, const struct dirent __e2) __THROW __attribute_pure__ __nonnull ((1, 2)); # else # ifdef __REDIRECT extern int __REDIRECT_NTH (versionsort, (const struct dirent __e1, const struct dirent __e2), versionsort64) __attribute_pure__ __nonnull ((1, 2)); # else # define versionsort versionsort64 # endif # endif # ifdef __USE_LARGEFILE64 extern int versionsort64 (const struct dirent64 __e1, const struct dirent64 __e2) __THROW __attribute_pure__ __nonnull ((1, 2)); # endif #endif / Use GNU. / __END_DECLS #include <bits/dirent_ext.h> #endif / dirent.h */	12.32 KB	2026-02-17 11:01
📄 dlfcn.h /* User functions for run-time dynamic loading. Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _DLFCN_H #define _DLFCN_H 1 #include <features.h> #define __need_size_t #include <stddef.h> / Collect various system dependent definitions and declarations. / #include <bits/dlfcn.h> #ifdef __USE_GNU #include <bits/dl_find_object.h> / If the first argument of `dlsym' or `dlvsym' is set to RTLD_NEXT the run-time address of the symbol called NAME in the next shared object is returned. The "next" relation is defined by the order the shared objects were loaded. / # define RTLD_NEXT ((void ) -1l) /* If the first argument to `dlsym' or `dlvsym' is set to RTLD_DEFAULT the run-time address of the symbol called NAME in the global scope is returned. / # define RTLD_DEFAULT ((void ) 0) /* Type for namespace indices. / typedef long int Lmid_t; / Special namespace ID values. / # define LM_ID_BASE 0 / Initial namespace. / # define LM_ID_NEWLM -1 / For dlmopen: request new namespace. / #endif __BEGIN_DECLS / Open the shared object FILE and map it in; return a handle that can be passed to `dlsym' to get symbol values from it. / extern void dlopen (const char __file, int __mode) __THROWNL; / Unmap and close a shared object opened by `dlopen'. The handle cannot be used again after calling `dlclose'. / extern int dlclose (void __handle) __THROWNL __nonnull ((1)); /* Find the run-time address in the shared object HANDLE refers to of the symbol called NAME. / extern void dlsym (void __restrict __handle, const char __restrict __name) __THROW __nonnull ((2)); #ifdef __USE_GNU /* Like `dlopen', but request object to be allocated in a new namespace. / extern void dlmopen (Lmid_t __nsid, const char __file, int __mode) __THROWNL; / Find the run-time address in the shared object HANDLE refers to of the symbol called NAME with VERSION. / extern void dlvsym (void __restrict __handle, const char __restrict __name, const char __restrict __version) __THROW __nonnull ((2, 3)); #endif / When any of the above functions fails, call this function to return a string describing the error. Each call resets the error string so that a following call returns null. / extern char dlerror (void) __THROW; #ifdef __USE_GNU /* Structure containing information about object searched using `dladdr'. / typedef struct { const char dli_fname; /* File name of defining object. / void dli_fbase; /* Load address of that object. / const char dli_sname; /* Name of nearest symbol. / void dli_saddr; /* Exact value of nearest symbol. / } Dl_info; / Fill in INFO with the following information about ADDRESS. Returns 0 iff no shared object's segments contain that address. / extern int dladdr (const void __address, Dl_info __info) __THROW __nonnull ((2)); /* Same as `dladdr', but additionally sets EXTRA_INFO according to FLAGS. / extern int dladdr1 (const void __address, Dl_info __info, void *__extra_info, int __flags) __THROW __nonnull ((2)); / These are the possible values for the FLAGS argument to `dladdr1'. This indicates what extra information is stored at EXTRA_INFO. It may also be zero, in which case the EXTRA_INFO argument is not used. / enum { /* Matching symbol table entry (const ElfNN_Sym ). / RTLD_DL_SYMENT = 1, /* The object containing the address (struct link_map ). / RTLD_DL_LINKMAP = 2 }; /* Get information about the shared object HANDLE refers to. REQUEST is from among the values below, and determines the use of ARG. On success, returns zero. On failure, returns -1 and records an error message to be fetched with `dlerror'. / extern int dlinfo (void __restrict __handle, int __request, void __restrict __arg) __THROW __nonnull ((1, 3)); / These are the possible values for the REQUEST argument to `dlinfo'. / enum { / Treat ARG as `lmid_t '; store namespace ID for HANDLE there. / RTLD_DI_LMID = 1, /* Treat ARG as `struct link_map *'; store the `struct link_map ' for HANDLE there. / RTLD_DI_LINKMAP = 2, RTLD_DI_CONFIGADDR = 3, / Unsupported, defined by Solaris. / / Treat ARG as `Dl_serinfo ' (see below), and fill in to describe the directories that will be searched for dependencies of this object. RTLD_DI_SERINFOSIZE fills in just the `dls_cnt' and `dls_size' entries to indicate the size of the buffer that must be passed to RTLD_DI_SERINFO to fill in the full information. / RTLD_DI_SERINFO = 4, RTLD_DI_SERINFOSIZE = 5, /* Treat ARG as `char ', and store there the directory name used to expand $ORIGIN in this shared object's dependency file names. / RTLD_DI_ORIGIN = 6, RTLD_DI_PROFILENAME = 7, /* Unsupported, defined by Solaris. / RTLD_DI_PROFILEOUT = 8, / Unsupported, defined by Solaris. / / Treat ARG as `size_t ', and store there the TLS module ID of this object's PT_TLS segment, as used in TLS relocations; store zero if this object does not define a PT_TLS segment. / RTLD_DI_TLS_MODID = 9, /* Treat ARG as `void *', and store there a pointer to the calling thread's TLS block corresponding to this object's PT_TLS segment. Store a null pointer if this object does not define a PT_TLS segment, or if the calling thread has not allocated a block for it. / RTLD_DI_TLS_DATA = 10, /* Treat ARG as const ElfW(Phdr) *, and store the address of the program header array at that location. The dlinfo call returns the number of program headers in the array. / RTLD_DI_PHDR = 11, RTLD_DI_MAX = 11 }; /* This is the type of elements in `Dl_serinfo', below. The `dls_name' member points to space in the buffer passed to `dlinfo'. / typedef struct { char dls_name; /* Name of library search path directory. / unsigned int dls_flags; / Indicates where this directory came from. / } Dl_serpath; / This is the structure that must be passed (by reference) to `dlinfo' for the RTLD_DI_SERINFO and RTLD_DI_SERINFOSIZE requests. / typedef struct { size_t dls_size; / Size in bytes of the whole buffer. / unsigned int dls_cnt; / Number of elements in `dls_serpath'. / # if __GNUC_PREREQ (3, 0) / The zero-length array avoids an unwanted array subscript check by the compiler, while the surrounding anonymous union preserves the historic size of the type. At the time of writing, GNU C does not support structs with flexible array members in unions. / __extension__ union { Dl_serpath dls_serpath[0]; / Actually longer, dls_cnt elements. / Dl_serpath __dls_serpath_pad[1]; }; # else Dl_serpath dls_serpath[1]; / Actually longer, dls_cnt elements. / # endif } Dl_serinfo; struct dl_find_object { __extension__ unsigned long long int dlfo_flags; void dlfo_map_start; /* Beginning of mapping containing address. / void dlfo_map_end; /* End of mapping. / struct link_map dlfo_link_map; void dlfo_eh_frame; / Exception handling data of the object. / # if DLFO_STRUCT_HAS_EH_DBASE void dlfo_eh_dbase; /* Base address for DW_EH_PE_datarel. / # if __WORDSIZE == 32 unsigned int __dlfo_eh_dbase_pad; # endif # endif # if DLFO_STRUCT_HAS_EH_COUNT int dlfo_eh_count; / Number of exception handling entries. / unsigned int __dlfo_eh_count_pad; # endif __extension__ unsigned long long int __dflo_reserved[7]; }; / If ADDRESS is found in an object, fill in RESULT and return 0. Otherwise, return -1. / int _dl_find_object (void __address, struct dl_find_object __result) __THROW; #endif /* __USE_GNU / __END_DECLS #endif / dlfcn.h */	8.38 KB	2026-02-17 11:01
📁 drm	-	2026-03-27 02:43
📄 elf.h /* This file defines standard ELF types, structures, and macros. Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _ELF_H #define _ELF_H 1 / Standard ELF types. / #include <stdint.h> / Type for a 16-bit quantity. / typedef uint16_t Elf32_Half; typedef uint16_t Elf64_Half; / Types for signed and unsigned 32-bit quantities. / typedef uint32_t Elf32_Word; typedef int32_t Elf32_Sword; typedef uint32_t Elf64_Word; typedef int32_t Elf64_Sword; / Types for signed and unsigned 64-bit quantities. / typedef uint64_t Elf32_Xword; typedef int64_t Elf32_Sxword; typedef uint64_t Elf64_Xword; typedef int64_t Elf64_Sxword; / Type of addresses. / typedef uint32_t Elf32_Addr; typedef uint64_t Elf64_Addr; / Type of file offsets. / typedef uint32_t Elf32_Off; typedef uint64_t Elf64_Off; / Type for section indices, which are 16-bit quantities. / typedef uint16_t Elf32_Section; typedef uint16_t Elf64_Section; / Type for version symbol information. / typedef Elf32_Half Elf32_Versym; typedef Elf64_Half Elf64_Versym; / The ELF file header. This appears at the start of every ELF file. / #define EI_NIDENT (16) typedef struct { unsigned char e_ident[EI_NIDENT]; / Magic number and other info / Elf32_Half e_type; / Object file type / Elf32_Half e_machine; / Architecture / Elf32_Word e_version; / Object file version / Elf32_Addr e_entry; / Entry point virtual address / Elf32_Off e_phoff; / Program header table file offset / Elf32_Off e_shoff; / Section header table file offset / Elf32_Word e_flags; / Processor-specific flags / Elf32_Half e_ehsize; / ELF header size in bytes / Elf32_Half e_phentsize; / Program header table entry size / Elf32_Half e_phnum; / Program header table entry count / Elf32_Half e_shentsize; / Section header table entry size / Elf32_Half e_shnum; / Section header table entry count / Elf32_Half e_shstrndx; / Section header string table index / } Elf32_Ehdr; typedef struct { unsigned char e_ident[EI_NIDENT]; / Magic number and other info / Elf64_Half e_type; / Object file type / Elf64_Half e_machine; / Architecture / Elf64_Word e_version; / Object file version / Elf64_Addr e_entry; / Entry point virtual address / Elf64_Off e_phoff; / Program header table file offset / Elf64_Off e_shoff; / Section header table file offset / Elf64_Word e_flags; / Processor-specific flags / Elf64_Half e_ehsize; / ELF header size in bytes / Elf64_Half e_phentsize; / Program header table entry size / Elf64_Half e_phnum; / Program header table entry count / Elf64_Half e_shentsize; / Section header table entry size / Elf64_Half e_shnum; / Section header table entry count / Elf64_Half e_shstrndx; / Section header string table index / } Elf64_Ehdr; / Fields in the e_ident array. The EI_* macros are indices into the array. The macros under each EI_* macro are the values the byte may have. / #define EI_MAG0 0 / File identification byte 0 index / #define ELFMAG0 0x7f / Magic number byte 0 / #define EI_MAG1 1 / File identification byte 1 index / #define ELFMAG1 'E' / Magic number byte 1 / #define EI_MAG2 2 / File identification byte 2 index / #define ELFMAG2 'L' / Magic number byte 2 / #define EI_MAG3 3 / File identification byte 3 index / #define ELFMAG3 'F' / Magic number byte 3 / / Conglomeration of the identification bytes, for easy testing as a word. / #define ELFMAG "\177ELF" #define SELFMAG 4 #define EI_CLASS 4 / File class byte index / #define ELFCLASSNONE 0 / Invalid class / #define ELFCLASS32 1 / 32-bit objects / #define ELFCLASS64 2 / 64-bit objects / #define ELFCLASSNUM 3 #define EI_DATA 5 / Data encoding byte index / #define ELFDATANONE 0 / Invalid data encoding / #define ELFDATA2LSB 1 / 2's complement, little endian / #define ELFDATA2MSB 2 / 2's complement, big endian / #define ELFDATANUM 3 #define EI_VERSION 6 / File version byte index / / Value must be EV_CURRENT / #define EI_OSABI 7 / OS ABI identification / #define ELFOSABI_NONE 0 / UNIX System V ABI / #define ELFOSABI_SYSV 0 / Alias. / #define ELFOSABI_HPUX 1 / HP-UX / #define ELFOSABI_NETBSD 2 / NetBSD. / #define ELFOSABI_GNU 3 / Object uses GNU ELF extensions. / #define ELFOSABI_LINUX ELFOSABI_GNU / Compatibility alias. / #define ELFOSABI_SOLARIS 6 / Sun Solaris. / #define ELFOSABI_AIX 7 / IBM AIX. / #define ELFOSABI_IRIX 8 / SGI Irix. / #define ELFOSABI_FREEBSD 9 / FreeBSD. / #define ELFOSABI_TRU64 10 / Compaq TRU64 UNIX. / #define ELFOSABI_MODESTO 11 / Novell Modesto. / #define ELFOSABI_OPENBSD 12 / OpenBSD. / #define ELFOSABI_ARM_AEABI 64 / ARM EABI / #define ELFOSABI_ARM 97 / ARM / #define ELFOSABI_STANDALONE 255 / Standalone (embedded) application / #define EI_ABIVERSION 8 / ABI version / #define EI_PAD 9 / Byte index of padding bytes / / Legal values for e_type (object file type). / #define ET_NONE 0 / No file type / #define ET_REL 1 / Relocatable file / #define ET_EXEC 2 / Executable file / #define ET_DYN 3 / Shared object file / #define ET_CORE 4 / Core file / #define ET_NUM 5 / Number of defined types / #define ET_LOOS 0xfe00 / OS-specific range start / #define ET_HIOS 0xfeff / OS-specific range end / #define ET_LOPROC 0xff00 / Processor-specific range start / #define ET_HIPROC 0xffff / Processor-specific range end / / Legal values for e_machine (architecture). / #define EM_NONE 0 / No machine / #define EM_M32 1 / AT&T WE 32100 / #define EM_SPARC 2 / SUN SPARC / #define EM_386 3 / Intel 80386 / #define EM_68K 4 / Motorola m68k family / #define EM_88K 5 / Motorola m88k family / #define EM_IAMCU 6 / Intel MCU / #define EM_860 7 / Intel 80860 / #define EM_MIPS 8 / MIPS R3000 big-endian / #define EM_S370 9 / IBM System/370 / #define EM_MIPS_RS3_LE 10 / MIPS R3000 little-endian / / reserved 11-14 / #define EM_PARISC 15 / HPPA / / reserved 16 / #define EM_VPP500 17 / Fujitsu VPP500 / #define EM_SPARC32PLUS 18 / Sun's "v8plus" / #define EM_960 19 / Intel 80960 / #define EM_PPC 20 / PowerPC / #define EM_PPC64 21 / PowerPC 64-bit / #define EM_S390 22 / IBM S390 / #define EM_SPU 23 / IBM SPU/SPC / / reserved 24-35 / #define EM_V800 36 / NEC V800 series / #define EM_FR20 37 / Fujitsu FR20 / #define EM_RH32 38 / TRW RH-32 / #define EM_RCE 39 / Motorola RCE / #define EM_ARM 40 / ARM / #define EM_FAKE_ALPHA 41 / Digital Alpha / #define EM_SH 42 / Hitachi SH / #define EM_SPARCV9 43 / SPARC v9 64-bit / #define EM_TRICORE 44 / Siemens Tricore / #define EM_ARC 45 / Argonaut RISC Core / #define EM_H8_300 46 / Hitachi H8/300 / #define EM_H8_300H 47 / Hitachi H8/300H / #define EM_H8S 48 / Hitachi H8S / #define EM_H8_500 49 / Hitachi H8/500 / #define EM_IA_64 50 / Intel Merced / #define EM_MIPS_X 51 / Stanford MIPS-X / #define EM_COLDFIRE 52 / Motorola Coldfire / #define EM_68HC12 53 / Motorola M68HC12 / #define EM_MMA 54 / Fujitsu MMA Multimedia Accelerator / #define EM_PCP 55 / Siemens PCP / #define EM_NCPU 56 / Sony nCPU embeeded RISC / #define EM_NDR1 57 / Denso NDR1 microprocessor / #define EM_STARCORE 58 / Motorola StartCore processor / #define EM_ME16 59 /* Toyota ME16 processor / #define EM_ST100 60 / STMicroelectronic ST100 processor / #define EM_TINYJ 61 / Advanced Logic Corp. Tinyj emb.fam / #define EM_X86_64 62 / AMD x86-64 architecture / #define EM_PDSP 63 / Sony DSP Processor / #define EM_PDP10 64 / Digital PDP-10 / #define EM_PDP11 65 / Digital PDP-11 / #define EM_FX66 66 / Siemens FX66 microcontroller / #define EM_ST9PLUS 67 / STMicroelectronics ST9+ 8/16 mc / #define EM_ST7 68 / STmicroelectronics ST7 8 bit mc / #define EM_68HC16 69 / Motorola MC68HC16 microcontroller / #define EM_68HC11 70 / Motorola MC68HC11 microcontroller / #define EM_68HC08 71 / Motorola MC68HC08 microcontroller / #define EM_68HC05 72 / Motorola MC68HC05 microcontroller / #define EM_SVX 73 / Silicon Graphics SVx / #define EM_ST19 74 / STMicroelectronics ST19 8 bit mc / #define EM_VAX 75 / Digital VAX / #define EM_CRIS 76 / Axis Communications 32-bit emb.proc / #define EM_JAVELIN 77 / Infineon Technologies 32-bit emb.proc / #define EM_FIREPATH 78 / Element 14 64-bit DSP Processor / #define EM_ZSP 79 / LSI Logic 16-bit DSP Processor / #define EM_MMIX 80 / Donald Knuth's educational 64-bit proc / #define EM_HUANY 81 / Harvard University machine-independent object files / #define EM_PRISM 82 / SiTera Prism / #define EM_AVR 83 / Atmel AVR 8-bit microcontroller / #define EM_FR30 84 / Fujitsu FR30 / #define EM_D10V 85 / Mitsubishi D10V / #define EM_D30V 86 / Mitsubishi D30V / #define EM_V850 87 / NEC v850 / #define EM_M32R 88 / Mitsubishi M32R / #define EM_MN10300 89 / Matsushita MN10300 / #define EM_MN10200 90 / Matsushita MN10200 / #define EM_PJ 91 / picoJava / #define EM_OPENRISC 92 / OpenRISC 32-bit embedded processor / #define EM_ARC_COMPACT 93 / ARC International ARCompact / #define EM_XTENSA 94 / Tensilica Xtensa Architecture / #define EM_VIDEOCORE 95 / Alphamosaic VideoCore / #define EM_TMM_GPP 96 / Thompson Multimedia General Purpose Proc / #define EM_NS32K 97 / National Semi. 32000 / #define EM_TPC 98 / Tenor Network TPC / #define EM_SNP1K 99 / Trebia SNP 1000 / #define EM_ST200 100 / STMicroelectronics ST200 / #define EM_IP2K 101 / Ubicom IP2xxx / #define EM_MAX 102 / MAX processor / #define EM_CR 103 / National Semi. CompactRISC / #define EM_F2MC16 104 / Fujitsu F2MC16 / #define EM_MSP430 105 / Texas Instruments msp430 / #define EM_BLACKFIN 106 / Analog Devices Blackfin DSP / #define EM_SE_C33 107 / Seiko Epson S1C33 family / #define EM_SEP 108 / Sharp embedded microprocessor / #define EM_ARCA 109 / Arca RISC / #define EM_UNICORE 110 / PKU-Unity & MPRC Peking Uni. mc series / #define EM_EXCESS 111 / eXcess configurable cpu / #define EM_DXP 112 / Icera Semi. Deep Execution Processor / #define EM_ALTERA_NIOS2 113 / Altera Nios II / #define EM_CRX 114 / National Semi. CompactRISC CRX / #define EM_XGATE 115 / Motorola XGATE / #define EM_C166 116 / Infineon C16x/XC16x / #define EM_M16C 117 / Renesas M16C / #define EM_DSPIC30F 118 / Microchip Technology dsPIC30F / #define EM_CE 119 / Freescale Communication Engine RISC / #define EM_M32C 120 / Renesas M32C / / reserved 121-130 / #define EM_TSK3000 131 / Altium TSK3000 / #define EM_RS08 132 / Freescale RS08 / #define EM_SHARC 133 / Analog Devices SHARC family / #define EM_ECOG2 134 / Cyan Technology eCOG2 / #define EM_SCORE7 135 / Sunplus S+core7 RISC / #define EM_DSP24 136 / New Japan Radio (NJR) 24-bit DSP / #define EM_VIDEOCORE3 137 / Broadcom VideoCore III / #define EM_LATTICEMICO32 138 / RISC for Lattice FPGA / #define EM_SE_C17 139 / Seiko Epson C17 / #define EM_TI_C6000 140 / Texas Instruments TMS320C6000 DSP / #define EM_TI_C2000 141 / Texas Instruments TMS320C2000 DSP / #define EM_TI_C5500 142 / Texas Instruments TMS320C55x DSP / #define EM_TI_ARP32 143 / Texas Instruments App. Specific RISC / #define EM_TI_PRU 144 / Texas Instruments Prog. Realtime Unit / / reserved 145-159 / #define EM_MMDSP_PLUS 160 / STMicroelectronics 64bit VLIW DSP / #define EM_CYPRESS_M8C 161 / Cypress M8C / #define EM_R32C 162 / Renesas R32C / #define EM_TRIMEDIA 163 / NXP Semi. TriMedia / #define EM_QDSP6 164 / QUALCOMM DSP6 / #define EM_8051 165 / Intel 8051 and variants / #define EM_STXP7X 166 / STMicroelectronics STxP7x / #define EM_NDS32 167 / Andes Tech. compact code emb. RISC / #define EM_ECOG1X 168 / Cyan Technology eCOG1X / #define EM_MAXQ30 169 / Dallas Semi. MAXQ30 mc / #define EM_XIMO16 170 / New Japan Radio (NJR) 16-bit DSP / #define EM_MANIK 171 / M2000 Reconfigurable RISC / #define EM_CRAYNV2 172 / Cray NV2 vector architecture / #define EM_RX 173 / Renesas RX / #define EM_METAG 174 / Imagination Tech. META / #define EM_MCST_ELBRUS 175 / MCST Elbrus / #define EM_ECOG16 176 / Cyan Technology eCOG16 / #define EM_CR16 177 / National Semi. CompactRISC CR16 / #define EM_ETPU 178 / Freescale Extended Time Processing Unit / #define EM_SLE9X 179 / Infineon Tech. SLE9X / #define EM_L10M 180 / Intel L10M / #define EM_K10M 181 / Intel K10M / / reserved 182 / #define EM_AARCH64 183 / ARM AARCH64 / / reserved 184 / #define EM_AVR32 185 / Amtel 32-bit microprocessor / #define EM_STM8 186 / STMicroelectronics STM8 / #define EM_TILE64 187 / Tilera TILE64 / #define EM_TILEPRO 188 / Tilera TILEPro / #define EM_MICROBLAZE 189 / Xilinx MicroBlaze / #define EM_CUDA 190 / NVIDIA CUDA / #define EM_TILEGX 191 / Tilera TILE-Gx / #define EM_CLOUDSHIELD 192 / CloudShield / #define EM_COREA_1ST 193 / KIPO-KAIST Core-A 1st gen. / #define EM_COREA_2ND 194 / KIPO-KAIST Core-A 2nd gen. / #define EM_ARCV2 195 / Synopsys ARCv2 ISA. / #define EM_OPEN8 196 / Open8 RISC / #define EM_RL78 197 / Renesas RL78 / #define EM_VIDEOCORE5 198 / Broadcom VideoCore V / #define EM_78KOR 199 / Renesas 78KOR / #define EM_56800EX 200 / Freescale 56800EX DSC / #define EM_BA1 201 / Beyond BA1 / #define EM_BA2 202 / Beyond BA2 / #define EM_XCORE 203 / XMOS xCORE / #define EM_MCHP_PIC 204 / Microchip 8-bit PIC(r) / #define EM_INTELGT 205 / Intel Graphics Technology / / reserved 206-209 / #define EM_KM32 210 / KM211 KM32 / #define EM_KMX32 211 / KM211 KMX32 / #define EM_EMX16 212 / KM211 KMX16 / #define EM_EMX8 213 / KM211 KMX8 / #define EM_KVARC 214 / KM211 KVARC / #define EM_CDP 215 / Paneve CDP / #define EM_COGE 216 / Cognitive Smart Memory Processor / #define EM_COOL 217 / Bluechip CoolEngine / #define EM_NORC 218 / Nanoradio Optimized RISC / #define EM_CSR_KALIMBA 219 / CSR Kalimba / #define EM_Z80 220 / Zilog Z80 / #define EM_VISIUM 221 / Controls and Data Services VISIUMcore / #define EM_FT32 222 / FTDI Chip FT32 / #define EM_MOXIE 223 / Moxie processor / #define EM_AMDGPU 224 / AMD GPU / / reserved 225-242 / #define EM_RISCV 243 / RISC-V / #define EM_BPF 247 / Linux BPF -- in-kernel virtual machine / #define EM_CSKY 252 / C-SKY / #define EM_NUM 253 / Old spellings/synonyms. / #define EM_ARC_A5 EM_ARC_COMPACT / If it is necessary to assign new unofficial EM_* values, please pick large random numbers (0x8523, 0xa7f2, etc.) to minimize the chances of collision with official or non-GNU unofficial values. / #define EM_ALPHA 0x9026 / Legal values for e_version (version). / #define EV_NONE 0 / Invalid ELF version / #define EV_CURRENT 1 / Current version / #define EV_NUM 2 / Section header. / typedef struct { Elf32_Word sh_name; / Section name (string tbl index) / Elf32_Word sh_type; / Section type / Elf32_Word sh_flags; / Section flags / Elf32_Addr sh_addr; / Section virtual addr at execution / Elf32_Off sh_offset; / Section file offset / Elf32_Word sh_size; / Section size in bytes / Elf32_Word sh_link; / Link to another section / Elf32_Word sh_info; / Additional section information / Elf32_Word sh_addralign; / Section alignment / Elf32_Word sh_entsize; / Entry size if section holds table / } Elf32_Shdr; typedef struct { Elf64_Word sh_name; / Section name (string tbl index) / Elf64_Word sh_type; / Section type / Elf64_Xword sh_flags; / Section flags / Elf64_Addr sh_addr; / Section virtual addr at execution / Elf64_Off sh_offset; / Section file offset / Elf64_Xword sh_size; / Section size in bytes / Elf64_Word sh_link; / Link to another section / Elf64_Word sh_info; / Additional section information / Elf64_Xword sh_addralign; / Section alignment / Elf64_Xword sh_entsize; / Entry size if section holds table / } Elf64_Shdr; / Special section indices. / #define SHN_UNDEF 0 / Undefined section / #define SHN_LORESERVE 0xff00 / Start of reserved indices / #define SHN_LOPROC 0xff00 / Start of processor-specific / #define SHN_BEFORE 0xff00 / Order section before all others (Solaris). / #define SHN_AFTER 0xff01 / Order section after all others (Solaris). / #define SHN_HIPROC 0xff1f / End of processor-specific / #define SHN_LOOS 0xff20 / Start of OS-specific / #define SHN_HIOS 0xff3f / End of OS-specific / #define SHN_ABS 0xfff1 / Associated symbol is absolute / #define SHN_COMMON 0xfff2 / Associated symbol is common / #define SHN_XINDEX 0xffff / Index is in extra table. / #define SHN_HIRESERVE 0xffff / End of reserved indices / / Legal values for sh_type (section type). / #define SHT_NULL 0 / Section header table entry unused / #define SHT_PROGBITS 1 / Program data / #define SHT_SYMTAB 2 / Symbol table / #define SHT_STRTAB 3 / String table / #define SHT_RELA 4 / Relocation entries with addends / #define SHT_HASH 5 / Symbol hash table / #define SHT_DYNAMIC 6 / Dynamic linking information / #define SHT_NOTE 7 / Notes / #define SHT_NOBITS 8 / Program space with no data (bss) / #define SHT_REL 9 / Relocation entries, no addends / #define SHT_SHLIB 10 / Reserved / #define SHT_DYNSYM 11 / Dynamic linker symbol table / #define SHT_INIT_ARRAY 14 / Array of constructors / #define SHT_FINI_ARRAY 15 / Array of destructors / #define SHT_PREINIT_ARRAY 16 / Array of pre-constructors / #define SHT_GROUP 17 / Section group / #define SHT_SYMTAB_SHNDX 18 / Extended section indices / #define SHT_NUM 19 / Number of defined types. / #define SHT_LOOS 0x60000000 / Start OS-specific. / #define SHT_GNU_ATTRIBUTES 0x6ffffff5 / Object attributes. / #define SHT_GNU_HASH 0x6ffffff6 / GNU-style hash table. / #define SHT_GNU_LIBLIST 0x6ffffff7 / Prelink library list / #define SHT_CHECKSUM 0x6ffffff8 / Checksum for DSO content. / #define SHT_LOSUNW 0x6ffffffa / Sun-specific low bound. / #define SHT_SUNW_move 0x6ffffffa #define SHT_SUNW_COMDAT 0x6ffffffb #define SHT_SUNW_syminfo 0x6ffffffc #define SHT_GNU_verdef 0x6ffffffd / Version definition section. / #define SHT_GNU_verneed 0x6ffffffe / Version needs section. / #define SHT_GNU_versym 0x6fffffff / Version symbol table. / #define SHT_HISUNW 0x6fffffff / Sun-specific high bound. / #define SHT_HIOS 0x6fffffff / End OS-specific type / #define SHT_LOPROC 0x70000000 / Start of processor-specific / #define SHT_HIPROC 0x7fffffff / End of processor-specific / #define SHT_LOUSER 0x80000000 / Start of application-specific / #define SHT_HIUSER 0x8fffffff / End of application-specific / / Legal values for sh_flags (section flags). / #define SHF_WRITE (1 << 0) / Writable / #define SHF_ALLOC (1 << 1) / Occupies memory during execution / #define SHF_EXECINSTR (1 << 2) / Executable / #define SHF_MERGE (1 << 4) / Might be merged / #define SHF_STRINGS (1 << 5) / Contains nul-terminated strings / #define SHF_INFO_LINK (1 << 6) / `sh_info' contains SHT index / #define SHF_LINK_ORDER (1 << 7) / Preserve order after combining / #define SHF_OS_NONCONFORMING (1 << 8) / Non-standard OS specific handling required / #define SHF_GROUP (1 << 9) / Section is member of a group. / #define SHF_TLS (1 << 10) / Section hold thread-local data. / #define SHF_COMPRESSED (1 << 11) / Section with compressed data. / #define SHF_MASKOS 0x0ff00000 / OS-specific. / #define SHF_MASKPROC 0xf0000000 / Processor-specific / #define SHF_GNU_RETAIN (1 << 21) / Not to be GCed by linker. / #define SHF_ORDERED (1 << 30) / Special ordering requirement (Solaris). / #define SHF_EXCLUDE (1U << 31) / Section is excluded unless referenced or allocated (Solaris)./ / Section compression header. Used when SHF_COMPRESSED is set. / typedef struct { Elf32_Word ch_type; / Compression format. / Elf32_Word ch_size; / Uncompressed data size. / Elf32_Word ch_addralign; / Uncompressed data alignment. / } Elf32_Chdr; typedef struct { Elf64_Word ch_type; / Compression format. / Elf64_Word ch_reserved; Elf64_Xword ch_size; / Uncompressed data size. / Elf64_Xword ch_addralign; / Uncompressed data alignment. / } Elf64_Chdr; / Legal values for ch_type (compression algorithm). / #define ELFCOMPRESS_ZLIB 1 / ZLIB/DEFLATE algorithm. / #define ELFCOMPRESS_LOOS 0x60000000 / Start of OS-specific. / #define ELFCOMPRESS_HIOS 0x6fffffff / End of OS-specific. / #define ELFCOMPRESS_LOPROC 0x70000000 / Start of processor-specific. / #define ELFCOMPRESS_HIPROC 0x7fffffff / End of processor-specific. / / Section group handling. / #define GRP_COMDAT 0x1 / Mark group as COMDAT. / / Symbol table entry. / typedef struct { Elf32_Word st_name; / Symbol name (string tbl index) / Elf32_Addr st_value; / Symbol value / Elf32_Word st_size; / Symbol size / unsigned char st_info; / Symbol type and binding / unsigned char st_other; / Symbol visibility / Elf32_Section st_shndx; / Section index / } Elf32_Sym; typedef struct { Elf64_Word st_name; / Symbol name (string tbl index) / unsigned char st_info; / Symbol type and binding / unsigned char st_other; / Symbol visibility / Elf64_Section st_shndx; / Section index / Elf64_Addr st_value; / Symbol value / Elf64_Xword st_size; / Symbol size / } Elf64_Sym; / The syminfo section if available contains additional information about every dynamic symbol. / typedef struct { Elf32_Half si_boundto; / Direct bindings, symbol bound to / Elf32_Half si_flags; / Per symbol flags / } Elf32_Syminfo; typedef struct { Elf64_Half si_boundto; / Direct bindings, symbol bound to / Elf64_Half si_flags; / Per symbol flags / } Elf64_Syminfo; / Possible values for si_boundto. / #define SYMINFO_BT_SELF 0xffff / Symbol bound to self / #define SYMINFO_BT_PARENT 0xfffe / Symbol bound to parent / #define SYMINFO_BT_LOWRESERVE 0xff00 / Beginning of reserved entries / / Possible bitmasks for si_flags. / #define SYMINFO_FLG_DIRECT 0x0001 / Direct bound symbol / #define SYMINFO_FLG_PASSTHRU 0x0002 / Pass-thru symbol for translator / #define SYMINFO_FLG_COPY 0x0004 / Symbol is a copy-reloc / #define SYMINFO_FLG_LAZYLOAD 0x0008 / Symbol bound to object to be lazy loaded / / Syminfo version values. / #define SYMINFO_NONE 0 #define SYMINFO_CURRENT 1 #define SYMINFO_NUM 2 / How to extract and insert information held in the st_info field. / #define ELF32_ST_BIND(val) (((unsigned char) (val)) >> 4) #define ELF32_ST_TYPE(val) ((val) & 0xf) #define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf)) / Both Elf32_Sym and Elf64_Sym use the same one-byte st_info field. / #define ELF64_ST_BIND(val) ELF32_ST_BIND (val) #define ELF64_ST_TYPE(val) ELF32_ST_TYPE (val) #define ELF64_ST_INFO(bind, type) ELF32_ST_INFO ((bind), (type)) / Legal values for ST_BIND subfield of st_info (symbol binding). / #define STB_LOCAL 0 / Local symbol / #define STB_GLOBAL 1 / Global symbol / #define STB_WEAK 2 / Weak symbol / #define STB_NUM 3 / Number of defined types. / #define STB_LOOS 10 / Start of OS-specific / #define STB_GNU_UNIQUE 10 / Unique symbol. / #define STB_HIOS 12 / End of OS-specific / #define STB_LOPROC 13 / Start of processor-specific / #define STB_HIPROC 15 / End of processor-specific / / Legal values for ST_TYPE subfield of st_info (symbol type). / #define STT_NOTYPE 0 / Symbol type is unspecified / #define STT_OBJECT 1 / Symbol is a data object / #define STT_FUNC 2 / Symbol is a code object / #define STT_SECTION 3 / Symbol associated with a section / #define STT_FILE 4 / Symbol's name is file name / #define STT_COMMON 5 / Symbol is a common data object / #define STT_TLS 6 / Symbol is thread-local data object/ #define STT_NUM 7 / Number of defined types. / #define STT_LOOS 10 / Start of OS-specific / #define STT_GNU_IFUNC 10 / Symbol is indirect code object / #define STT_HIOS 12 / End of OS-specific / #define STT_LOPROC 13 / Start of processor-specific / #define STT_HIPROC 15 / End of processor-specific / / Symbol table indices are found in the hash buckets and chain table of a symbol hash table section. This special index value indicates the end of a chain, meaning no further symbols are found in that bucket. / #define STN_UNDEF 0 / End of a chain. / / How to extract and insert information held in the st_other field. / #define ELF32_ST_VISIBILITY(o) ((o) & 0x03) / For ELF64 the definitions are the same. / #define ELF64_ST_VISIBILITY(o) ELF32_ST_VISIBILITY (o) / Symbol visibility specification encoded in the st_other field. / #define STV_DEFAULT 0 / Default symbol visibility rules / #define STV_INTERNAL 1 / Processor specific hidden class / #define STV_HIDDEN 2 / Sym unavailable in other modules / #define STV_PROTECTED 3 / Not preemptible, not exported / / Relocation table entry without addend (in section of type SHT_REL). / typedef struct { Elf32_Addr r_offset; / Address / Elf32_Word r_info; / Relocation type and symbol index / } Elf32_Rel; / I have seen two different definitions of the Elf64_Rel and Elf64_Rela structures, so we'll leave them out until Novell (or whoever) gets their act together. / / The following, at least, is used on Sparc v9, MIPS, and Alpha. / typedef struct { Elf64_Addr r_offset; / Address / Elf64_Xword r_info; / Relocation type and symbol index / } Elf64_Rel; / Relocation table entry with addend (in section of type SHT_RELA). / typedef struct { Elf32_Addr r_offset; / Address / Elf32_Word r_info; / Relocation type and symbol index / Elf32_Sword r_addend; / Addend / } Elf32_Rela; typedef struct { Elf64_Addr r_offset; / Address / Elf64_Xword r_info; / Relocation type and symbol index / Elf64_Sxword r_addend; / Addend / } Elf64_Rela; / How to extract and insert information held in the r_info field. / #define ELF32_R_SYM(val) ((val) >> 8) #define ELF32_R_TYPE(val) ((val) & 0xff) #define ELF32_R_INFO(sym, type) (((sym) << 8) + ((type) & 0xff)) #define ELF64_R_SYM(i) ((i) >> 32) #define ELF64_R_TYPE(i) ((i) & 0xffffffff) #define ELF64_R_INFO(sym,type) ((((Elf64_Xword) (sym)) << 32) + (type)) / Program segment header. / typedef struct { Elf32_Word p_type; / Segment type / Elf32_Off p_offset; / Segment file offset / Elf32_Addr p_vaddr; / Segment virtual address / Elf32_Addr p_paddr; / Segment physical address / Elf32_Word p_filesz; / Segment size in file / Elf32_Word p_memsz; / Segment size in memory / Elf32_Word p_flags; / Segment flags / Elf32_Word p_align; / Segment alignment / } Elf32_Phdr; typedef struct { Elf64_Word p_type; / Segment type / Elf64_Word p_flags; / Segment flags / Elf64_Off p_offset; / Segment file offset / Elf64_Addr p_vaddr; / Segment virtual address / Elf64_Addr p_paddr; / Segment physical address / Elf64_Xword p_filesz; / Segment size in file / Elf64_Xword p_memsz; / Segment size in memory / Elf64_Xword p_align; / Segment alignment / } Elf64_Phdr; / Special value for e_phnum. This indicates that the real number of program headers is too large to fit into e_phnum. Instead the real value is in the field sh_info of section 0. / #define PN_XNUM 0xffff / Legal values for p_type (segment type). / #define PT_NULL 0 / Program header table entry unused / #define PT_LOAD 1 / Loadable program segment / #define PT_DYNAMIC 2 / Dynamic linking information / #define PT_INTERP 3 / Program interpreter / #define PT_NOTE 4 / Auxiliary information / #define PT_SHLIB 5 / Reserved / #define PT_PHDR 6 / Entry for header table itself / #define PT_TLS 7 / Thread-local storage segment / #define PT_NUM 8 / Number of defined types / #define PT_LOOS 0x60000000 / Start of OS-specific / #define PT_GNU_EH_FRAME 0x6474e550 / GCC .eh_frame_hdr segment / #define PT_GNU_STACK 0x6474e551 / Indicates stack executability / #define PT_GNU_RELRO 0x6474e552 / Read-only after relocation / #define PT_GNU_PROPERTY 0x6474e553 / GNU property / #define PT_LOSUNW 0x6ffffffa #define PT_SUNWBSS 0x6ffffffa / Sun Specific segment / #define PT_SUNWSTACK 0x6ffffffb / Stack segment / #define PT_HISUNW 0x6fffffff #define PT_HIOS 0x6fffffff / End of OS-specific / #define PT_LOPROC 0x70000000 / Start of processor-specific / #define PT_HIPROC 0x7fffffff / End of processor-specific / / Legal values for p_flags (segment flags). / #define PF_X (1 << 0) / Segment is executable / #define PF_W (1 << 1) / Segment is writable / #define PF_R (1 << 2) / Segment is readable / #define PF_MASKOS 0x0ff00000 / OS-specific / #define PF_MASKPROC 0xf0000000 / Processor-specific / / Legal values for note segment descriptor types for core files. / #define NT_PRSTATUS 1 / Contains copy of prstatus struct / #define NT_PRFPREG 2 / Contains copy of fpregset struct. / #define NT_FPREGSET 2 / Contains copy of fpregset struct / #define NT_PRPSINFO 3 / Contains copy of prpsinfo struct / #define NT_PRXREG 4 / Contains copy of prxregset struct / #define NT_TASKSTRUCT 4 / Contains copy of task structure / #define NT_PLATFORM 5 / String from sysinfo(SI_PLATFORM) / #define NT_AUXV 6 / Contains copy of auxv array / #define NT_GWINDOWS 7 / Contains copy of gwindows struct / #define NT_ASRS 8 / Contains copy of asrset struct / #define NT_PSTATUS 10 / Contains copy of pstatus struct / #define NT_PSINFO 13 / Contains copy of psinfo struct / #define NT_PRCRED 14 / Contains copy of prcred struct / #define NT_UTSNAME 15 / Contains copy of utsname struct / #define NT_LWPSTATUS 16 / Contains copy of lwpstatus struct / #define NT_LWPSINFO 17 / Contains copy of lwpinfo struct / #define NT_PRFPXREG 20 / Contains copy of fprxregset struct / #define NT_SIGINFO 0x53494749 / Contains copy of siginfo_t, size might increase / #define NT_FILE 0x46494c45 / Contains information about mapped files / #define NT_PRXFPREG 0x46e62b7f / Contains copy of user_fxsr_struct / #define NT_PPC_VMX 0x100 / PowerPC Altivec/VMX registers / #define NT_PPC_SPE 0x101 / PowerPC SPE/EVR registers / #define NT_PPC_VSX 0x102 / PowerPC VSX registers / #define NT_PPC_TAR 0x103 / Target Address Register / #define NT_PPC_PPR 0x104 / Program Priority Register / #define NT_PPC_DSCR 0x105 / Data Stream Control Register / #define NT_PPC_EBB 0x106 / Event Based Branch Registers / #define NT_PPC_PMU 0x107 / Performance Monitor Registers / #define NT_PPC_TM_CGPR 0x108 / TM checkpointed GPR Registers / #define NT_PPC_TM_CFPR 0x109 / TM checkpointed FPR Registers / #define NT_PPC_TM_CVMX 0x10a / TM checkpointed VMX Registers / #define NT_PPC_TM_CVSX 0x10b / TM checkpointed VSX Registers / #define NT_PPC_TM_SPR 0x10c / TM Special Purpose Registers / #define NT_PPC_TM_CTAR 0x10d / TM checkpointed Target Address Register / #define NT_PPC_TM_CPPR 0x10e / TM checkpointed Program Priority Register / #define NT_PPC_TM_CDSCR 0x10f / TM checkpointed Data Stream Control Register / #define NT_PPC_PKEY 0x110 / Memory Protection Keys registers. / #define NT_386_TLS 0x200 / i386 TLS slots (struct user_desc) / #define NT_386_IOPERM 0x201 / x86 io permission bitmap (1=deny) / #define NT_X86_XSTATE 0x202 / x86 extended state using xsave / #define NT_S390_HIGH_GPRS 0x300 / s390 upper register halves / #define NT_S390_TIMER 0x301 / s390 timer register / #define NT_S390_TODCMP 0x302 / s390 TOD clock comparator register / #define NT_S390_TODPREG 0x303 / s390 TOD programmable register / #define NT_S390_CTRS 0x304 / s390 control registers / #define NT_S390_PREFIX 0x305 / s390 prefix register / #define NT_S390_LAST_BREAK 0x306 / s390 breaking event address / #define NT_S390_SYSTEM_CALL 0x307 / s390 system call restart data / #define NT_S390_TDB 0x308 / s390 transaction diagnostic block / #define NT_S390_VXRS_LOW 0x309 / s390 vector registers 0-15 upper half. / #define NT_S390_VXRS_HIGH 0x30a / s390 vector registers 16-31. / #define NT_S390_GS_CB 0x30b / s390 guarded storage registers. / #define NT_S390_GS_BC 0x30c / s390 guarded storage broadcast control block. / #define NT_S390_RI_CB 0x30d / s390 runtime instrumentation. / #define NT_ARM_VFP 0x400 / ARM VFP/NEON registers / #define NT_ARM_TLS 0x401 / ARM TLS register / #define NT_ARM_HW_BREAK 0x402 / ARM hardware breakpoint registers / #define NT_ARM_HW_WATCH 0x403 / ARM hardware watchpoint registers / #define NT_ARM_SYSTEM_CALL 0x404 / ARM system call number / #define NT_ARM_SVE 0x405 / ARM Scalable Vector Extension registers / #define NT_ARM_PAC_MASK 0x406 / ARM pointer authentication code masks. / #define NT_ARM_PACA_KEYS 0x407 / ARM pointer authentication address keys. / #define NT_ARM_PACG_KEYS 0x408 / ARM pointer authentication generic key. / #define NT_ARM_TAGGED_ADDR_CTRL 0x409 / AArch64 tagged address control. / #define NT_ARM_PAC_ENABLED_KEYS 0x40a / AArch64 pointer authentication enabled keys. / #define NT_VMCOREDD 0x700 / Vmcore Device Dump Note. / #define NT_MIPS_DSP 0x800 / MIPS DSP ASE registers. / #define NT_MIPS_FP_MODE 0x801 / MIPS floating-point mode. / #define NT_MIPS_MSA 0x802 / MIPS SIMD registers. / / Legal values for the note segment descriptor types for object files. / #define NT_VERSION 1 / Contains a version string. / / Dynamic section entry. / typedef struct { Elf32_Sword d_tag; / Dynamic entry type / union { Elf32_Word d_val; / Integer value / Elf32_Addr d_ptr; / Address value / } d_un; } Elf32_Dyn; typedef struct { Elf64_Sxword d_tag; / Dynamic entry type / union { Elf64_Xword d_val; / Integer value / Elf64_Addr d_ptr; / Address value / } d_un; } Elf64_Dyn; / Legal values for d_tag (dynamic entry type). / #define DT_NULL 0 / Marks end of dynamic section / #define DT_NEEDED 1 / Name of needed library / #define DT_PLTRELSZ 2 / Size in bytes of PLT relocs / #define DT_PLTGOT 3 / Processor defined value / #define DT_HASH 4 / Address of symbol hash table / #define DT_STRTAB 5 / Address of string table / #define DT_SYMTAB 6 / Address of symbol table / #define DT_RELA 7 / Address of Rela relocs / #define DT_RELASZ 8 / Total size of Rela relocs / #define DT_RELAENT 9 / Size of one Rela reloc / #define DT_STRSZ 10 / Size of string table / #define DT_SYMENT 11 / Size of one symbol table entry / #define DT_INIT 12 / Address of init function / #define DT_FINI 13 / Address of termination function / #define DT_SONAME 14 / Name of shared object / #define DT_RPATH 15 / Library search path (deprecated) / #define DT_SYMBOLIC 16 / Start symbol search here / #define DT_REL 17 / Address of Rel relocs / #define DT_RELSZ 18 / Total size of Rel relocs / #define DT_RELENT 19 / Size of one Rel reloc / #define DT_PLTREL 20 / Type of reloc in PLT / #define DT_DEBUG 21 / For debugging; unspecified / #define DT_TEXTREL 22 / Reloc might modify .text / #define DT_JMPREL 23 / Address of PLT relocs / #define DT_BIND_NOW 24 / Process relocations of object / #define DT_INIT_ARRAY 25 / Array with addresses of init fct / #define DT_FINI_ARRAY 26 / Array with addresses of fini fct / #define DT_INIT_ARRAYSZ 27 / Size in bytes of DT_INIT_ARRAY / #define DT_FINI_ARRAYSZ 28 / Size in bytes of DT_FINI_ARRAY / #define DT_RUNPATH 29 / Library search path / #define DT_FLAGS 30 / Flags for the object being loaded / #define DT_ENCODING 32 / Start of encoded range / #define DT_PREINIT_ARRAY 32 / Array with addresses of preinit fct/ #define DT_PREINIT_ARRAYSZ 33 / size in bytes of DT_PREINIT_ARRAY / #define DT_SYMTAB_SHNDX 34 / Address of SYMTAB_SHNDX section / #define DT_NUM 35 / Number used / #define DT_LOOS 0x6000000d / Start of OS-specific / #define DT_HIOS 0x6ffff000 / End of OS-specific / #define DT_LOPROC 0x70000000 / Start of processor-specific / #define DT_HIPROC 0x7fffffff / End of processor-specific / #define DT_PROCNUM DT_MIPS_NUM / Most used by any processor / / DT_* entries which fall between DT_VALRNGHI & DT_VALRNGLO use the Dyn.d_un.d_val field of the Elf_Dyn structure. This follows Sun's approach. / #define DT_VALRNGLO 0x6ffffd00 #define DT_GNU_PRELINKED 0x6ffffdf5 /* Prelinking timestamp / #define DT_GNU_CONFLICTSZ 0x6ffffdf6 / Size of conflict section / #define DT_GNU_LIBLISTSZ 0x6ffffdf7 / Size of library list / #define DT_CHECKSUM 0x6ffffdf8 #define DT_PLTPADSZ 0x6ffffdf9 #define DT_MOVEENT 0x6ffffdfa #define DT_MOVESZ 0x6ffffdfb #define DT_FEATURE_1 0x6ffffdfc / Feature selection (DTF_). / #define DT_POSFLAG_1 0x6ffffdfd /* Flags for DT_* entries, effecting the following DT_* entry. / #define DT_SYMINSZ 0x6ffffdfe / Size of syminfo table (in bytes) / #define DT_SYMINENT 0x6ffffdff / Entry size of syminfo / #define DT_VALRNGHI 0x6ffffdff #define DT_VALTAGIDX(tag) (DT_VALRNGHI - (tag)) / Reverse order! / #define DT_VALNUM 12 / DT_* entries which fall between DT_ADDRRNGHI & DT_ADDRRNGLO use the Dyn.d_un.d_ptr field of the Elf_Dyn structure. If any adjustment is made to the ELF object after it has been built these entries will need to be adjusted. / #define DT_ADDRRNGLO 0x6ffffe00 #define DT_GNU_HASH 0x6ffffef5 /* GNU-style hash table. / #define DT_TLSDESC_PLT 0x6ffffef6 #define DT_TLSDESC_GOT 0x6ffffef7 #define DT_GNU_CONFLICT 0x6ffffef8 / Start of conflict section / #define DT_GNU_LIBLIST 0x6ffffef9 / Library list / #define DT_CONFIG 0x6ffffefa / Configuration information. / #define DT_DEPAUDIT 0x6ffffefb / Dependency auditing. / #define DT_AUDIT 0x6ffffefc / Object auditing. / #define DT_PLTPAD 0x6ffffefd / PLT padding. / #define DT_MOVETAB 0x6ffffefe / Move table. / #define DT_SYMINFO 0x6ffffeff / Syminfo table. / #define DT_ADDRRNGHI 0x6ffffeff #define DT_ADDRTAGIDX(tag) (DT_ADDRRNGHI - (tag)) / Reverse order! / #define DT_ADDRNUM 11 / The versioning entry types. The next are defined as part of the GNU extension. / #define DT_VERSYM 0x6ffffff0 #define DT_RELACOUNT 0x6ffffff9 #define DT_RELCOUNT 0x6ffffffa / These were chosen by Sun. / #define DT_FLAGS_1 0x6ffffffb / State flags, see DF_1_* below. / #define DT_VERDEF 0x6ffffffc / Address of version definition table / #define DT_VERDEFNUM 0x6ffffffd / Number of version definitions / #define DT_VERNEED 0x6ffffffe / Address of table with needed versions / #define DT_VERNEEDNUM 0x6fffffff / Number of needed versions / #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) / Reverse order! / #define DT_VERSIONTAGNUM 16 / Sun added these machine-independent extensions in the "processor-specific" range. Be compatible. / #define DT_AUXILIARY 0x7ffffffd / Shared object to load before self / #define DT_FILTER 0x7fffffff / Shared object to get values from / #define DT_EXTRATAGIDX(tag) ((Elf32_Word)-((Elf32_Sword) (tag) <<1>>1)-1) #define DT_EXTRANUM 3 / Values of `d_un.d_val' in the DT_FLAGS entry. / #define DF_ORIGIN 0x00000001 / Object may use DF_ORIGIN / #define DF_SYMBOLIC 0x00000002 / Symbol resolutions starts here / #define DF_TEXTREL 0x00000004 / Object contains text relocations / #define DF_BIND_NOW 0x00000008 / No lazy binding for this object / #define DF_STATIC_TLS 0x00000010 / Module uses the static TLS model / / State flags selectable in the `d_un.d_val' element of the DT_FLAGS_1 entry in the dynamic section. / #define DF_1_NOW 0x00000001 / Set RTLD_NOW for this object. / #define DF_1_GLOBAL 0x00000002 / Set RTLD_GLOBAL for this object. / #define DF_1_GROUP 0x00000004 / Set RTLD_GROUP for this object. / #define DF_1_NODELETE 0x00000008 / Set RTLD_NODELETE for this object./ #define DF_1_LOADFLTR 0x00000010 / Trigger filtee loading at runtime./ #define DF_1_INITFIRST 0x00000020 / Set RTLD_INITFIRST for this object/ #define DF_1_NOOPEN 0x00000040 / Set RTLD_NOOPEN for this object. / #define DF_1_ORIGIN 0x00000080 / $ORIGIN must be handled. / #define DF_1_DIRECT 0x00000100 / Direct binding enabled. / #define DF_1_TRANS 0x00000200 #define DF_1_INTERPOSE 0x00000400 / Object is used to interpose. / #define DF_1_NODEFLIB 0x00000800 / Ignore default lib search path. / #define DF_1_NODUMP 0x00001000 / Object can't be dldump'ed. / #define DF_1_CONFALT 0x00002000 / Configuration alternative created./ #define DF_1_ENDFILTEE 0x00004000 / Filtee terminates filters search. / #define DF_1_DISPRELDNE 0x00008000 / Disp reloc applied at build time. / #define DF_1_DISPRELPND 0x00010000 / Disp reloc applied at run-time. / #define DF_1_NODIRECT 0x00020000 / Object has no-direct binding. / #define DF_1_IGNMULDEF 0x00040000 #define DF_1_NOKSYMS 0x00080000 #define DF_1_NOHDR 0x00100000 #define DF_1_EDITED 0x00200000 / Object is modified after built. / #define DF_1_NORELOC 0x00400000 #define DF_1_SYMINTPOSE 0x00800000 / Object has individual interposers. / #define DF_1_GLOBAUDIT 0x01000000 / Global auditing required. / #define DF_1_SINGLETON 0x02000000 / Singleton symbols are used. / #define DF_1_STUB 0x04000000 #define DF_1_PIE 0x08000000 #define DF_1_KMOD 0x10000000 #define DF_1_WEAKFILTER 0x20000000 #define DF_1_NOCOMMON 0x40000000 / Flags for the feature selection in DT_FEATURE_1. / #define DTF_1_PARINIT 0x00000001 #define DTF_1_CONFEXP 0x00000002 / Flags in the DT_POSFLAG_1 entry effecting only the next DT_* entry. / #define DF_P1_LAZYLOAD 0x00000001 / Lazyload following object. / #define DF_P1_GROUPPERM 0x00000002 / Symbols from next object are not generally available. / / Version definition sections. / typedef struct { Elf32_Half vd_version; / Version revision / Elf32_Half vd_flags; / Version information / Elf32_Half vd_ndx; / Version Index / Elf32_Half vd_cnt; / Number of associated aux entries / Elf32_Word vd_hash; / Version name hash value / Elf32_Word vd_aux; / Offset in bytes to verdaux array / Elf32_Word vd_next; / Offset in bytes to next verdef entry / } Elf32_Verdef; typedef struct { Elf64_Half vd_version; / Version revision / Elf64_Half vd_flags; / Version information / Elf64_Half vd_ndx; / Version Index / Elf64_Half vd_cnt; / Number of associated aux entries / Elf64_Word vd_hash; / Version name hash value / Elf64_Word vd_aux; / Offset in bytes to verdaux array / Elf64_Word vd_next; / Offset in bytes to next verdef entry / } Elf64_Verdef; / Legal values for vd_version (version revision). / #define VER_DEF_NONE 0 / No version / #define VER_DEF_CURRENT 1 / Current version / #define VER_DEF_NUM 2 / Given version number / / Legal values for vd_flags (version information flags). / #define VER_FLG_BASE 0x1 / Version definition of file itself / #define VER_FLG_WEAK 0x2 / Weak version identifier / / Versym symbol index values. / #define VER_NDX_LOCAL 0 / Symbol is local. / #define VER_NDX_GLOBAL 1 / Symbol is global. / #define VER_NDX_LORESERVE 0xff00 / Beginning of reserved entries. / #define VER_NDX_ELIMINATE 0xff01 / Symbol is to be eliminated. / / Auxiliary version information. / typedef struct { Elf32_Word vda_name; / Version or dependency names / Elf32_Word vda_next; / Offset in bytes to next verdaux entry / } Elf32_Verdaux; typedef struct { Elf64_Word vda_name; / Version or dependency names / Elf64_Word vda_next; / Offset in bytes to next verdaux entry / } Elf64_Verdaux; / Version dependency section. / typedef struct { Elf32_Half vn_version; / Version of structure / Elf32_Half vn_cnt; / Number of associated aux entries / Elf32_Word vn_file; / Offset of filename for this dependency / Elf32_Word vn_aux; / Offset in bytes to vernaux array / Elf32_Word vn_next; / Offset in bytes to next verneed entry / } Elf32_Verneed; typedef struct { Elf64_Half vn_version; / Version of structure / Elf64_Half vn_cnt; / Number of associated aux entries / Elf64_Word vn_file; / Offset of filename for this dependency / Elf64_Word vn_aux; / Offset in bytes to vernaux array / Elf64_Word vn_next; / Offset in bytes to next verneed entry / } Elf64_Verneed; / Legal values for vn_version (version revision). / #define VER_NEED_NONE 0 / No version / #define VER_NEED_CURRENT 1 / Current version / #define VER_NEED_NUM 2 / Given version number / / Auxiliary needed version information. / typedef struct { Elf32_Word vna_hash; / Hash value of dependency name / Elf32_Half vna_flags; / Dependency specific information / Elf32_Half vna_other; / Unused / Elf32_Word vna_name; / Dependency name string offset / Elf32_Word vna_next; / Offset in bytes to next vernaux entry / } Elf32_Vernaux; typedef struct { Elf64_Word vna_hash; / Hash value of dependency name / Elf64_Half vna_flags; / Dependency specific information / Elf64_Half vna_other; / Unused / Elf64_Word vna_name; / Dependency name string offset / Elf64_Word vna_next; / Offset in bytes to next vernaux entry / } Elf64_Vernaux; / Legal values for vna_flags. / #define VER_FLG_WEAK 0x2 / Weak version identifier / / Auxiliary vector. / / This vector is normally only used by the program interpreter. The usual definition in an ABI supplement uses the name auxv_t. The vector is not usually defined in a standard <elf.h> file, but it can't hurt. We rename it to avoid conflicts. The sizes of these types are an arrangement between the exec server and the program interpreter, so we don't fully specify them here. / typedef struct { uint32_t a_type; / Entry type / union { uint32_t a_val; / Integer value / / We use to have pointer elements added here. We cannot do that, though, since it does not work when using 32-bit definitions on 64-bit platforms and vice versa. / } a_un; } Elf32_auxv_t; typedef struct { uint64_t a_type; / Entry type / union { uint64_t a_val; / Integer value / / We use to have pointer elements added here. We cannot do that, though, since it does not work when using 32-bit definitions on 64-bit platforms and vice versa. / } a_un; } Elf64_auxv_t; / Legal values for a_type (entry type). / #define AT_NULL 0 / End of vector / #define AT_IGNORE 1 / Entry should be ignored / #define AT_EXECFD 2 / File descriptor of program / #define AT_PHDR 3 / Program headers for program / #define AT_PHENT 4 / Size of program header entry / #define AT_PHNUM 5 / Number of program headers / #define AT_PAGESZ 6 / System page size / #define AT_BASE 7 / Base address of interpreter / #define AT_FLAGS 8 / Flags / #define AT_ENTRY 9 / Entry point of program / #define AT_NOTELF 10 / Program is not ELF / #define AT_UID 11 / Real uid / #define AT_EUID 12 / Effective uid / #define AT_GID 13 / Real gid / #define AT_EGID 14 / Effective gid / #define AT_CLKTCK 17 / Frequency of times() / / Some more special a_type values describing the hardware. / #define AT_PLATFORM 15 / String identifying platform. / #define AT_HWCAP 16 / Machine-dependent hints about processor capabilities. / / This entry gives some information about the FPU initialization performed by the kernel. / #define AT_FPUCW 18 / Used FPU control word. / / Cache block sizes. / #define AT_DCACHEBSIZE 19 / Data cache block size. / #define AT_ICACHEBSIZE 20 / Instruction cache block size. / #define AT_UCACHEBSIZE 21 / Unified cache block size. / / A special ignored value for PPC, used by the kernel to control the interpretation of the AUXV. Must be > 16. / #define AT_IGNOREPPC 22 / Entry should be ignored. / #define AT_SECURE 23 / Boolean, was exec setuid-like? / #define AT_BASE_PLATFORM 24 / String identifying real platforms./ #define AT_RANDOM 25 / Address of 16 random bytes. / #define AT_HWCAP2 26 / More machine-dependent hints about processor capabilities. / #define AT_RSEQ_FEATURE_SIZE 27 / rseq supported feature size. / #define AT_RSEQ_ALIGN 28 / rseq allocation alignment. / #define AT_EXECFN 31 / Filename of executable. / / Pointer to the global system page used for system calls and other nice things. / #define AT_SYSINFO 32 #define AT_SYSINFO_EHDR 33 / Shapes of the caches. Bits 0-3 contains associativity; bits 4-7 contains log2 of line size; mask those to get cache size. / #define AT_L1I_CACHESHAPE 34 #define AT_L1D_CACHESHAPE 35 #define AT_L2_CACHESHAPE 36 #define AT_L3_CACHESHAPE 37 / Shapes of the caches, with more room to describe them. GEOMETRY are comprised of cache line size in bytes in the bottom 16 bits and the cache associativity in the next 16 bits. / #define AT_L1I_CACHESIZE 40 #define AT_L1I_CACHEGEOMETRY 41 #define AT_L1D_CACHESIZE 42 #define AT_L1D_CACHEGEOMETRY 43 #define AT_L2_CACHESIZE 44 #define AT_L2_CACHEGEOMETRY 45 #define AT_L3_CACHESIZE 46 #define AT_L3_CACHEGEOMETRY 47 #define AT_MINSIGSTKSZ 51 /* Stack needed for signal delivery (AArch64). / / Note section contents. Each entry in the note section begins with a header of a fixed form. / typedef struct { Elf32_Word n_namesz; / Length of the note's name. / Elf32_Word n_descsz; / Length of the note's descriptor. / Elf32_Word n_type; / Type of the note. / } Elf32_Nhdr; typedef struct { Elf64_Word n_namesz; / Length of the note's name. / Elf64_Word n_descsz; / Length of the note's descriptor. / Elf64_Word n_type; / Type of the note. / } Elf64_Nhdr; / Known names of notes. / / Solaris entries in the note section have this name. / #define ELF_NOTE_SOLARIS "SUNW Solaris" / Note entries for GNU systems have this name. / #define ELF_NOTE_GNU "GNU" / Defined types of notes for Solaris. / / Value of descriptor (one word) is desired pagesize for the binary. / #define ELF_NOTE_PAGESIZE_HINT 1 / Defined note types for GNU systems. / / ABI information. The descriptor consists of words: word 0: OS descriptor word 1: major version of the ABI word 2: minor version of the ABI word 3: subminor version of the ABI / #define NT_GNU_ABI_TAG 1 #define ELF_NOTE_ABI NT_GNU_ABI_TAG / Old name. / / Known OSes. These values can appear in word 0 of an NT_GNU_ABI_TAG note section entry. / #define ELF_NOTE_OS_LINUX 0 #define ELF_NOTE_OS_GNU 1 #define ELF_NOTE_OS_SOLARIS2 2 #define ELF_NOTE_OS_FREEBSD 3 / Synthetic hwcap information. The descriptor begins with two words: word 0: number of entries word 1: bitmask of enabled entries Then follow variable-length entries, one byte followed by a '\0'-terminated hwcap name string. The byte gives the bit number to test if enabled, (1U << bit) & bitmask. / #define NT_GNU_HWCAP 2 / Build ID bits as generated by ld --build-id. The descriptor consists of any nonzero number of bytes. / #define NT_GNU_BUILD_ID 3 / Version note generated by GNU gold containing a version string. / #define NT_GNU_GOLD_VERSION 4 / Program property. / #define NT_GNU_PROPERTY_TYPE_0 5 / Note section name of program property. / #define NOTE_GNU_PROPERTY_SECTION_NAME ".note.gnu.property" / Values used in GNU .note.gnu.property notes (NT_GNU_PROPERTY_TYPE_0). / / Stack size. / #define GNU_PROPERTY_STACK_SIZE 1 / No copy relocation on protected data symbol. / #define GNU_PROPERTY_NO_COPY_ON_PROTECTED 2 / Processor-specific semantics, lo / #define GNU_PROPERTY_LOPROC 0xc0000000 / Processor-specific semantics, hi / #define GNU_PROPERTY_HIPROC 0xdfffffff / Application-specific semantics, lo / #define GNU_PROPERTY_LOUSER 0xe0000000 / Application-specific semantics, hi / #define GNU_PROPERTY_HIUSER 0xffffffff / AArch64 specific GNU properties. / #define GNU_PROPERTY_AARCH64_FEATURE_1_AND 0xc0000000 #define GNU_PROPERTY_AARCH64_FEATURE_1_BTI (1U << 0) #define GNU_PROPERTY_AARCH64_FEATURE_1_PAC (1U << 1) / The x86 instruction sets indicated by the corresponding bits are used in program. Their support in the hardware is optional. / #define GNU_PROPERTY_X86_ISA_1_USED 0xc0010002 / The x86 instruction sets indicated by the corresponding bits are used in program and they must be supported by the hardware. / #define GNU_PROPERTY_X86_ISA_1_NEEDED 0xc0008002 / X86 processor-specific features used in program. / #define GNU_PROPERTY_X86_FEATURE_1_AND 0xc0000002 / GNU_PROPERTY_X86_ISA_1_BASELINE: CMOV, CX8 (cmpxchg8b), FPU (fld), MMX, OSFXSR (fxsave), SCE (syscall), SSE and SSE2. / #define GNU_PROPERTY_X86_ISA_1_BASELINE (1U << 0) / GNU_PROPERTY_X86_ISA_1_V2: GNU_PROPERTY_X86_ISA_1_BASELINE, CMPXCHG16B (cmpxchg16b), LAHF-SAHF (lahf), POPCNT (popcnt), SSE3, SSSE3, SSE4.1 and SSE4.2. / #define GNU_PROPERTY_X86_ISA_1_V2 (1U << 1) / GNU_PROPERTY_X86_ISA_1_V3: GNU_PROPERTY_X86_ISA_1_V2, AVX, AVX2, BMI1, BMI2, F16C, FMA, LZCNT, MOVBE, XSAVE. / #define GNU_PROPERTY_X86_ISA_1_V3 (1U << 2) / GNU_PROPERTY_X86_ISA_1_V4: GNU_PROPERTY_X86_ISA_1_V3, AVX512F, AVX512BW, AVX512CD, AVX512DQ and AVX512VL. / #define GNU_PROPERTY_X86_ISA_1_V4 (1U << 3) / This indicates that all executable sections are compatible with IBT. / #define GNU_PROPERTY_X86_FEATURE_1_IBT (1U << 0) / This indicates that all executable sections are compatible with SHSTK. / #define GNU_PROPERTY_X86_FEATURE_1_SHSTK (1U << 1) / Move records. / typedef struct { Elf32_Xword m_value; / Symbol value. / Elf32_Word m_info; / Size and index. / Elf32_Word m_poffset; / Symbol offset. / Elf32_Half m_repeat; / Repeat count. / Elf32_Half m_stride; / Stride info. / } Elf32_Move; typedef struct { Elf64_Xword m_value; / Symbol value. / Elf64_Xword m_info; / Size and index. / Elf64_Xword m_poffset; / Symbol offset. / Elf64_Half m_repeat; / Repeat count. / Elf64_Half m_stride; / Stride info. / } Elf64_Move; / Macro to construct move records. / #define ELF32_M_SYM(info) ((info) >> 8) #define ELF32_M_SIZE(info) ((unsigned char) (info)) #define ELF32_M_INFO(sym, size) (((sym) << 8) + (unsigned char) (size)) #define ELF64_M_SYM(info) ELF32_M_SYM (info) #define ELF64_M_SIZE(info) ELF32_M_SIZE (info) #define ELF64_M_INFO(sym, size) ELF32_M_INFO (sym, size) / Motorola 68k specific definitions. / / Values for Elf32_Ehdr.e_flags. / #define EF_CPU32 0x00810000 / m68k relocs. / #define R_68K_NONE 0 / No reloc / #define R_68K_32 1 / Direct 32 bit / #define R_68K_16 2 / Direct 16 bit / #define R_68K_8 3 / Direct 8 bit / #define R_68K_PC32 4 / PC relative 32 bit / #define R_68K_PC16 5 / PC relative 16 bit / #define R_68K_PC8 6 / PC relative 8 bit / #define R_68K_GOT32 7 / 32 bit PC relative GOT entry / #define R_68K_GOT16 8 / 16 bit PC relative GOT entry / #define R_68K_GOT8 9 / 8 bit PC relative GOT entry / #define R_68K_GOT32O 10 / 32 bit GOT offset / #define R_68K_GOT16O 11 / 16 bit GOT offset / #define R_68K_GOT8O 12 / 8 bit GOT offset / #define R_68K_PLT32 13 / 32 bit PC relative PLT address / #define R_68K_PLT16 14 / 16 bit PC relative PLT address / #define R_68K_PLT8 15 / 8 bit PC relative PLT address / #define R_68K_PLT32O 16 / 32 bit PLT offset / #define R_68K_PLT16O 17 / 16 bit PLT offset / #define R_68K_PLT8O 18 / 8 bit PLT offset / #define R_68K_COPY 19 / Copy symbol at runtime / #define R_68K_GLOB_DAT 20 / Create GOT entry / #define R_68K_JMP_SLOT 21 / Create PLT entry / #define R_68K_RELATIVE 22 / Adjust by program base / #define R_68K_TLS_GD32 25 / 32 bit GOT offset for GD / #define R_68K_TLS_GD16 26 / 16 bit GOT offset for GD / #define R_68K_TLS_GD8 27 / 8 bit GOT offset for GD / #define R_68K_TLS_LDM32 28 / 32 bit GOT offset for LDM / #define R_68K_TLS_LDM16 29 / 16 bit GOT offset for LDM / #define R_68K_TLS_LDM8 30 / 8 bit GOT offset for LDM / #define R_68K_TLS_LDO32 31 / 32 bit module-relative offset / #define R_68K_TLS_LDO16 32 / 16 bit module-relative offset / #define R_68K_TLS_LDO8 33 / 8 bit module-relative offset / #define R_68K_TLS_IE32 34 / 32 bit GOT offset for IE / #define R_68K_TLS_IE16 35 / 16 bit GOT offset for IE / #define R_68K_TLS_IE8 36 / 8 bit GOT offset for IE / #define R_68K_TLS_LE32 37 / 32 bit offset relative to static TLS block / #define R_68K_TLS_LE16 38 / 16 bit offset relative to static TLS block / #define R_68K_TLS_LE8 39 / 8 bit offset relative to static TLS block / #define R_68K_TLS_DTPMOD32 40 / 32 bit module number / #define R_68K_TLS_DTPREL32 41 / 32 bit module-relative offset / #define R_68K_TLS_TPREL32 42 / 32 bit TP-relative offset / / Keep this the last entry. / #define R_68K_NUM 43 / Intel 80386 specific definitions. / / i386 relocs. / #define R_386_NONE 0 / No reloc / #define R_386_32 1 / Direct 32 bit / #define R_386_PC32 2 / PC relative 32 bit / #define R_386_GOT32 3 / 32 bit GOT entry / #define R_386_PLT32 4 / 32 bit PLT address / #define R_386_COPY 5 / Copy symbol at runtime / #define R_386_GLOB_DAT 6 / Create GOT entry / #define R_386_JMP_SLOT 7 / Create PLT entry / #define R_386_RELATIVE 8 / Adjust by program base / #define R_386_GOTOFF 9 / 32 bit offset to GOT / #define R_386_GOTPC 10 / 32 bit PC relative offset to GOT / #define R_386_32PLT 11 #define R_386_TLS_TPOFF 14 / Offset in static TLS block / #define R_386_TLS_IE 15 / Address of GOT entry for static TLS block offset / #define R_386_TLS_GOTIE 16 / GOT entry for static TLS block offset / #define R_386_TLS_LE 17 / Offset relative to static TLS block / #define R_386_TLS_GD 18 / Direct 32 bit for GNU version of general dynamic thread local data / #define R_386_TLS_LDM 19 / Direct 32 bit for GNU version of local dynamic thread local data in LE code / #define R_386_16 20 #define R_386_PC16 21 #define R_386_8 22 #define R_386_PC8 23 #define R_386_TLS_GD_32 24 / Direct 32 bit for general dynamic thread local data / #define R_386_TLS_GD_PUSH 25 / Tag for pushl in GD TLS code / #define R_386_TLS_GD_CALL 26 / Relocation for call to __tls_get_addr() / #define R_386_TLS_GD_POP 27 / Tag for popl in GD TLS code / #define R_386_TLS_LDM_32 28 / Direct 32 bit for local dynamic thread local data in LE code / #define R_386_TLS_LDM_PUSH 29 / Tag for pushl in LDM TLS code / #define R_386_TLS_LDM_CALL 30 / Relocation for call to __tls_get_addr() in LDM code / #define R_386_TLS_LDM_POP 31 / Tag for popl in LDM TLS code / #define R_386_TLS_LDO_32 32 / Offset relative to TLS block / #define R_386_TLS_IE_32 33 / GOT entry for negated static TLS block offset / #define R_386_TLS_LE_32 34 / Negated offset relative to static TLS block / #define R_386_TLS_DTPMOD32 35 / ID of module containing symbol / #define R_386_TLS_DTPOFF32 36 / Offset in TLS block / #define R_386_TLS_TPOFF32 37 / Negated offset in static TLS block / #define R_386_SIZE32 38 / 32-bit symbol size / #define R_386_TLS_GOTDESC 39 / GOT offset for TLS descriptor. / #define R_386_TLS_DESC_CALL 40 / Marker of call through TLS descriptor for relaxation. / #define R_386_TLS_DESC 41 / TLS descriptor containing pointer to code and to argument, returning the TLS offset for the symbol. / #define R_386_IRELATIVE 42 / Adjust indirectly by program base / #define R_386_GOT32X 43 / Load from 32 bit GOT entry, relaxable. / / Keep this the last entry. / #define R_386_NUM 44 / SUN SPARC specific definitions. / / Legal values for ST_TYPE subfield of st_info (symbol type). / #define STT_SPARC_REGISTER 13 / Global register reserved to app. / / Values for Elf64_Ehdr.e_flags. / #define EF_SPARCV9_MM 3 #define EF_SPARCV9_TSO 0 #define EF_SPARCV9_PSO 1 #define EF_SPARCV9_RMO 2 #define EF_SPARC_LEDATA 0x800000 / little endian data / #define EF_SPARC_EXT_MASK 0xFFFF00 #define EF_SPARC_32PLUS 0x000100 / generic V8+ features / #define EF_SPARC_SUN_US1 0x000200 / Sun UltraSPARC1 extensions / #define EF_SPARC_HAL_R1 0x000400 / HAL R1 extensions / #define EF_SPARC_SUN_US3 0x000800 / Sun UltraSPARCIII extensions / / SPARC relocs. / #define R_SPARC_NONE 0 / No reloc / #define R_SPARC_8 1 / Direct 8 bit / #define R_SPARC_16 2 / Direct 16 bit / #define R_SPARC_32 3 / Direct 32 bit / #define R_SPARC_DISP8 4 / PC relative 8 bit / #define R_SPARC_DISP16 5 / PC relative 16 bit / #define R_SPARC_DISP32 6 / PC relative 32 bit / #define R_SPARC_WDISP30 7 / PC relative 30 bit shifted / #define R_SPARC_WDISP22 8 / PC relative 22 bit shifted / #define R_SPARC_HI22 9 / High 22 bit / #define R_SPARC_22 10 / Direct 22 bit / #define R_SPARC_13 11 / Direct 13 bit / #define R_SPARC_LO10 12 / Truncated 10 bit / #define R_SPARC_GOT10 13 / Truncated 10 bit GOT entry / #define R_SPARC_GOT13 14 / 13 bit GOT entry / #define R_SPARC_GOT22 15 / 22 bit GOT entry shifted / #define R_SPARC_PC10 16 / PC relative 10 bit truncated / #define R_SPARC_PC22 17 / PC relative 22 bit shifted / #define R_SPARC_WPLT30 18 / 30 bit PC relative PLT address / #define R_SPARC_COPY 19 / Copy symbol at runtime / #define R_SPARC_GLOB_DAT 20 / Create GOT entry / #define R_SPARC_JMP_SLOT 21 / Create PLT entry / #define R_SPARC_RELATIVE 22 / Adjust by program base / #define R_SPARC_UA32 23 / Direct 32 bit unaligned / / Additional Sparc64 relocs. / #define R_SPARC_PLT32 24 / Direct 32 bit ref to PLT entry / #define R_SPARC_HIPLT22 25 / High 22 bit PLT entry / #define R_SPARC_LOPLT10 26 / Truncated 10 bit PLT entry / #define R_SPARC_PCPLT32 27 / PC rel 32 bit ref to PLT entry / #define R_SPARC_PCPLT22 28 / PC rel high 22 bit PLT entry / #define R_SPARC_PCPLT10 29 / PC rel trunc 10 bit PLT entry / #define R_SPARC_10 30 / Direct 10 bit / #define R_SPARC_11 31 / Direct 11 bit / #define R_SPARC_64 32 / Direct 64 bit / #define R_SPARC_OLO10 33 / 10bit with secondary 13bit addend / #define R_SPARC_HH22 34 / Top 22 bits of direct 64 bit / #define R_SPARC_HM10 35 / High middle 10 bits of ... / #define R_SPARC_LM22 36 / Low middle 22 bits of ... / #define R_SPARC_PC_HH22 37 / Top 22 bits of pc rel 64 bit / #define R_SPARC_PC_HM10 38 / High middle 10 bit of ... / #define R_SPARC_PC_LM22 39 / Low miggle 22 bits of ... / #define R_SPARC_WDISP16 40 / PC relative 16 bit shifted / #define R_SPARC_WDISP19 41 / PC relative 19 bit shifted / #define R_SPARC_GLOB_JMP 42 / was part of v9 ABI but was removed / #define R_SPARC_7 43 / Direct 7 bit / #define R_SPARC_5 44 / Direct 5 bit / #define R_SPARC_6 45 / Direct 6 bit / #define R_SPARC_DISP64 46 / PC relative 64 bit / #define R_SPARC_PLT64 47 / Direct 64 bit ref to PLT entry / #define R_SPARC_HIX22 48 / High 22 bit complemented / #define R_SPARC_LOX10 49 / Truncated 11 bit complemented / #define R_SPARC_H44 50 / Direct high 12 of 44 bit / #define R_SPARC_M44 51 / Direct mid 22 of 44 bit / #define R_SPARC_L44 52 / Direct low 10 of 44 bit / #define R_SPARC_REGISTER 53 / Global register usage / #define R_SPARC_UA64 54 / Direct 64 bit unaligned / #define R_SPARC_UA16 55 / Direct 16 bit unaligned / #define R_SPARC_TLS_GD_HI22 56 #define R_SPARC_TLS_GD_LO10 57 #define R_SPARC_TLS_GD_ADD 58 #define R_SPARC_TLS_GD_CALL 59 #define R_SPARC_TLS_LDM_HI22 60 #define R_SPARC_TLS_LDM_LO10 61 #define R_SPARC_TLS_LDM_ADD 62 #define R_SPARC_TLS_LDM_CALL 63 #define R_SPARC_TLS_LDO_HIX22 64 #define R_SPARC_TLS_LDO_LOX10 65 #define R_SPARC_TLS_LDO_ADD 66 #define R_SPARC_TLS_IE_HI22 67 #define R_SPARC_TLS_IE_LO10 68 #define R_SPARC_TLS_IE_LD 69 #define R_SPARC_TLS_IE_LDX 70 #define R_SPARC_TLS_IE_ADD 71 #define R_SPARC_TLS_LE_HIX22 72 #define R_SPARC_TLS_LE_LOX10 73 #define R_SPARC_TLS_DTPMOD32 74 #define R_SPARC_TLS_DTPMOD64 75 #define R_SPARC_TLS_DTPOFF32 76 #define R_SPARC_TLS_DTPOFF64 77 #define R_SPARC_TLS_TPOFF32 78 #define R_SPARC_TLS_TPOFF64 79 #define R_SPARC_GOTDATA_HIX22 80 #define R_SPARC_GOTDATA_LOX10 81 #define R_SPARC_GOTDATA_OP_HIX22 82 #define R_SPARC_GOTDATA_OP_LOX10 83 #define R_SPARC_GOTDATA_OP 84 #define R_SPARC_H34 85 #define R_SPARC_SIZE32 86 #define R_SPARC_SIZE64 87 #define R_SPARC_WDISP10 88 #define R_SPARC_JMP_IREL 248 #define R_SPARC_IRELATIVE 249 #define R_SPARC_GNU_VTINHERIT 250 #define R_SPARC_GNU_VTENTRY 251 #define R_SPARC_REV32 252 / Keep this the last entry. / #define R_SPARC_NUM 253 / For Sparc64, legal values for d_tag of Elf64_Dyn. / #define DT_SPARC_REGISTER 0x70000001 #define DT_SPARC_NUM 2 / MIPS R3000 specific definitions. / / Legal values for e_flags field of Elf32_Ehdr. / #define EF_MIPS_NOREORDER 1 / A .noreorder directive was used. / #define EF_MIPS_PIC 2 / Contains PIC code. / #define EF_MIPS_CPIC 4 / Uses PIC calling sequence. / #define EF_MIPS_XGOT 8 #define EF_MIPS_64BIT_WHIRL 16 #define EF_MIPS_ABI2 32 #define EF_MIPS_ABI_ON32 64 #define EF_MIPS_FP64 512 / Uses FP64 (12 callee-saved). / #define EF_MIPS_NAN2008 1024 / Uses IEEE 754-2008 NaN encoding. / #define EF_MIPS_ARCH 0xf0000000 / MIPS architecture level. / / Legal values for MIPS architecture level. / #define EF_MIPS_ARCH_1 0x00000000 / -mips1 code. / #define EF_MIPS_ARCH_2 0x10000000 / -mips2 code. / #define EF_MIPS_ARCH_3 0x20000000 / -mips3 code. / #define EF_MIPS_ARCH_4 0x30000000 / -mips4 code. / #define EF_MIPS_ARCH_5 0x40000000 / -mips5 code. / #define EF_MIPS_ARCH_32 0x50000000 / MIPS32 code. / #define EF_MIPS_ARCH_64 0x60000000 / MIPS64 code. / #define EF_MIPS_ARCH_32R2 0x70000000 / MIPS32r2 code. / #define EF_MIPS_ARCH_64R2 0x80000000 / MIPS64r2 code. / / The following are unofficial names and should not be used. / #define E_MIPS_ARCH_1 EF_MIPS_ARCH_1 #define E_MIPS_ARCH_2 EF_MIPS_ARCH_2 #define E_MIPS_ARCH_3 EF_MIPS_ARCH_3 #define E_MIPS_ARCH_4 EF_MIPS_ARCH_4 #define E_MIPS_ARCH_5 EF_MIPS_ARCH_5 #define E_MIPS_ARCH_32 EF_MIPS_ARCH_32 #define E_MIPS_ARCH_64 EF_MIPS_ARCH_64 / Special section indices. / #define SHN_MIPS_ACOMMON 0xff00 / Allocated common symbols. / #define SHN_MIPS_TEXT 0xff01 / Allocated test symbols. / #define SHN_MIPS_DATA 0xff02 / Allocated data symbols. / #define SHN_MIPS_SCOMMON 0xff03 / Small common symbols. / #define SHN_MIPS_SUNDEFINED 0xff04 / Small undefined symbols. / / Legal values for sh_type field of Elf32_Shdr. / #define SHT_MIPS_LIBLIST 0x70000000 / Shared objects used in link. / #define SHT_MIPS_MSYM 0x70000001 #define SHT_MIPS_CONFLICT 0x70000002 / Conflicting symbols. / #define SHT_MIPS_GPTAB 0x70000003 / Global data area sizes. / #define SHT_MIPS_UCODE 0x70000004 / Reserved for SGI/MIPS compilers / #define SHT_MIPS_DEBUG 0x70000005 / MIPS ECOFF debugging info. / #define SHT_MIPS_REGINFO 0x70000006 / Register usage information. / #define SHT_MIPS_PACKAGE 0x70000007 #define SHT_MIPS_PACKSYM 0x70000008 #define SHT_MIPS_RELD 0x70000009 #define SHT_MIPS_IFACE 0x7000000b #define SHT_MIPS_CONTENT 0x7000000c #define SHT_MIPS_OPTIONS 0x7000000d / Miscellaneous options. / #define SHT_MIPS_SHDR 0x70000010 #define SHT_MIPS_FDESC 0x70000011 #define SHT_MIPS_EXTSYM 0x70000012 #define SHT_MIPS_DENSE 0x70000013 #define SHT_MIPS_PDESC 0x70000014 #define SHT_MIPS_LOCSYM 0x70000015 #define SHT_MIPS_AUXSYM 0x70000016 #define SHT_MIPS_OPTSYM 0x70000017 #define SHT_MIPS_LOCSTR 0x70000018 #define SHT_MIPS_LINE 0x70000019 #define SHT_MIPS_RFDESC 0x7000001a #define SHT_MIPS_DELTASYM 0x7000001b #define SHT_MIPS_DELTAINST 0x7000001c #define SHT_MIPS_DELTACLASS 0x7000001d #define SHT_MIPS_DWARF 0x7000001e / DWARF debugging information. / #define SHT_MIPS_DELTADECL 0x7000001f #define SHT_MIPS_SYMBOL_LIB 0x70000020 #define SHT_MIPS_EVENTS 0x70000021 / Event section. / #define SHT_MIPS_TRANSLATE 0x70000022 #define SHT_MIPS_PIXIE 0x70000023 #define SHT_MIPS_XLATE 0x70000024 #define SHT_MIPS_XLATE_DEBUG 0x70000025 #define SHT_MIPS_WHIRL 0x70000026 #define SHT_MIPS_EH_REGION 0x70000027 #define SHT_MIPS_XLATE_OLD 0x70000028 #define SHT_MIPS_PDR_EXCEPTION 0x70000029 #define SHT_MIPS_XHASH 0x7000002b / Legal values for sh_flags field of Elf32_Shdr. / #define SHF_MIPS_GPREL 0x10000000 / Must be in global data area. / #define SHF_MIPS_MERGE 0x20000000 #define SHF_MIPS_ADDR 0x40000000 #define SHF_MIPS_STRINGS 0x80000000 #define SHF_MIPS_NOSTRIP 0x08000000 #define SHF_MIPS_LOCAL 0x04000000 #define SHF_MIPS_NAMES 0x02000000 #define SHF_MIPS_NODUPE 0x01000000 / Symbol tables. / / MIPS specific values for `st_other'. / #define STO_MIPS_DEFAULT 0x0 #define STO_MIPS_INTERNAL 0x1 #define STO_MIPS_HIDDEN 0x2 #define STO_MIPS_PROTECTED 0x3 #define STO_MIPS_PLT 0x8 #define STO_MIPS_SC_ALIGN_UNUSED 0xff / MIPS specific values for `st_info'. / #define STB_MIPS_SPLIT_COMMON 13 / Entries found in sections of type SHT_MIPS_GPTAB. / typedef union { struct { Elf32_Word gt_current_g_value; / -G value used for compilation. / Elf32_Word gt_unused; / Not used. / } gt_header; / First entry in section. / struct { Elf32_Word gt_g_value; / If this value were used for -G. / Elf32_Word gt_bytes; / This many bytes would be used. / } gt_entry; / Subsequent entries in section. / } Elf32_gptab; / Entry found in sections of type SHT_MIPS_REGINFO. / typedef struct { Elf32_Word ri_gprmask; / General registers used. / Elf32_Word ri_cprmask[4]; / Coprocessor registers used. / Elf32_Sword ri_gp_value; / $gp register value. / } Elf32_RegInfo; / Entries found in sections of type SHT_MIPS_OPTIONS. / typedef struct { unsigned char kind; / Determines interpretation of the variable part of descriptor. / unsigned char size; / Size of descriptor, including header. / Elf32_Section section; / Section header index of section affected, 0 for global options. / Elf32_Word info; / Kind-specific information. / } Elf_Options; / Values for `kind' field in Elf_Options. / #define ODK_NULL 0 / Undefined. / #define ODK_REGINFO 1 / Register usage information. / #define ODK_EXCEPTIONS 2 / Exception processing options. / #define ODK_PAD 3 / Section padding options. / #define ODK_HWPATCH 4 / Hardware workarounds performed / #define ODK_FILL 5 / record the fill value used by the linker. / #define ODK_TAGS 6 / reserve space for desktop tools to write. / #define ODK_HWAND 7 / HW workarounds. 'AND' bits when merging. / #define ODK_HWOR 8 / HW workarounds. 'OR' bits when merging. / / Values for `info' in Elf_Options for ODK_EXCEPTIONS entries. / #define OEX_FPU_MIN 0x1f / FPE's which MUST be enabled. / #define OEX_FPU_MAX 0x1f00 / FPE's which MAY be enabled. / #define OEX_PAGE0 0x10000 / page zero must be mapped. / #define OEX_SMM 0x20000 / Force sequential memory mode? / #define OEX_FPDBUG 0x40000 / Force floating point debug mode? / #define OEX_PRECISEFP OEX_FPDBUG #define OEX_DISMISS 0x80000 / Dismiss invalid address faults? / #define OEX_FPU_INVAL 0x10 #define OEX_FPU_DIV0 0x08 #define OEX_FPU_OFLO 0x04 #define OEX_FPU_UFLO 0x02 #define OEX_FPU_INEX 0x01 / Masks for `info' in Elf_Options for an ODK_HWPATCH entry. / #define OHW_R4KEOP 0x1 / R4000 end-of-page patch. / #define OHW_R8KPFETCH 0x2 / may need R8000 prefetch patch. / #define OHW_R5KEOP 0x4 / R5000 end-of-page patch. / #define OHW_R5KCVTL 0x8 / R5000 cvt.[ds].l bug. clean=1. / #define OPAD_PREFIX 0x1 #define OPAD_POSTFIX 0x2 #define OPAD_SYMBOL 0x4 / Entry found in `.options' section. / typedef struct { Elf32_Word hwp_flags1; / Extra flags. / Elf32_Word hwp_flags2; / Extra flags. / } Elf_Options_Hw; / Masks for `info' in ElfOptions for ODK_HWAND and ODK_HWOR entries. / #define OHWA0_R4KEOP_CHECKED 0x00000001 #define OHWA1_R4KEOP_CLEAN 0x00000002 / MIPS relocs. / #define R_MIPS_NONE 0 / No reloc / #define R_MIPS_16 1 / Direct 16 bit / #define R_MIPS_32 2 / Direct 32 bit / #define R_MIPS_REL32 3 / PC relative 32 bit / #define R_MIPS_26 4 / Direct 26 bit shifted / #define R_MIPS_HI16 5 / High 16 bit / #define R_MIPS_LO16 6 / Low 16 bit / #define R_MIPS_GPREL16 7 / GP relative 16 bit / #define R_MIPS_LITERAL 8 / 16 bit literal entry / #define R_MIPS_GOT16 9 / 16 bit GOT entry / #define R_MIPS_PC16 10 / PC relative 16 bit / #define R_MIPS_CALL16 11 / 16 bit GOT entry for function / #define R_MIPS_GPREL32 12 / GP relative 32 bit / #define R_MIPS_SHIFT5 16 #define R_MIPS_SHIFT6 17 #define R_MIPS_64 18 #define R_MIPS_GOT_DISP 19 #define R_MIPS_GOT_PAGE 20 #define R_MIPS_GOT_OFST 21 #define R_MIPS_GOT_HI16 22 #define R_MIPS_GOT_LO16 23 #define R_MIPS_SUB 24 #define R_MIPS_INSERT_A 25 #define R_MIPS_INSERT_B 26 #define R_MIPS_DELETE 27 #define R_MIPS_HIGHER 28 #define R_MIPS_HIGHEST 29 #define R_MIPS_CALL_HI16 30 #define R_MIPS_CALL_LO16 31 #define R_MIPS_SCN_DISP 32 #define R_MIPS_REL16 33 #define R_MIPS_ADD_IMMEDIATE 34 #define R_MIPS_PJUMP 35 #define R_MIPS_RELGOT 36 #define R_MIPS_JALR 37 #define R_MIPS_TLS_DTPMOD32 38 / Module number 32 bit / #define R_MIPS_TLS_DTPREL32 39 / Module-relative offset 32 bit / #define R_MIPS_TLS_DTPMOD64 40 / Module number 64 bit / #define R_MIPS_TLS_DTPREL64 41 / Module-relative offset 64 bit / #define R_MIPS_TLS_GD 42 / 16 bit GOT offset for GD / #define R_MIPS_TLS_LDM 43 / 16 bit GOT offset for LDM / #define R_MIPS_TLS_DTPREL_HI16 44 / Module-relative offset, high 16 bits / #define R_MIPS_TLS_DTPREL_LO16 45 / Module-relative offset, low 16 bits / #define R_MIPS_TLS_GOTTPREL 46 / 16 bit GOT offset for IE / #define R_MIPS_TLS_TPREL32 47 / TP-relative offset, 32 bit / #define R_MIPS_TLS_TPREL64 48 / TP-relative offset, 64 bit / #define R_MIPS_TLS_TPREL_HI16 49 / TP-relative offset, high 16 bits / #define R_MIPS_TLS_TPREL_LO16 50 / TP-relative offset, low 16 bits / #define R_MIPS_GLOB_DAT 51 #define R_MIPS_COPY 126 #define R_MIPS_JUMP_SLOT 127 / Keep this the last entry. / #define R_MIPS_NUM 128 / Legal values for p_type field of Elf32_Phdr. / #define PT_MIPS_REGINFO 0x70000000 / Register usage information. / #define PT_MIPS_RTPROC 0x70000001 / Runtime procedure table. / #define PT_MIPS_OPTIONS 0x70000002 #define PT_MIPS_ABIFLAGS 0x70000003 / FP mode requirement. / / Special program header types. / #define PF_MIPS_LOCAL 0x10000000 / Legal values for d_tag field of Elf32_Dyn. / #define DT_MIPS_RLD_VERSION 0x70000001 / Runtime linker interface version / #define DT_MIPS_TIME_STAMP 0x70000002 / Timestamp / #define DT_MIPS_ICHECKSUM 0x70000003 / Checksum / #define DT_MIPS_IVERSION 0x70000004 / Version string (string tbl index) / #define DT_MIPS_FLAGS 0x70000005 / Flags / #define DT_MIPS_BASE_ADDRESS 0x70000006 / Base address / #define DT_MIPS_MSYM 0x70000007 #define DT_MIPS_CONFLICT 0x70000008 / Address of CONFLICT section / #define DT_MIPS_LIBLIST 0x70000009 / Address of LIBLIST section / #define DT_MIPS_LOCAL_GOTNO 0x7000000a / Number of local GOT entries / #define DT_MIPS_CONFLICTNO 0x7000000b / Number of CONFLICT entries / #define DT_MIPS_LIBLISTNO 0x70000010 / Number of LIBLIST entries / #define DT_MIPS_SYMTABNO 0x70000011 / Number of DYNSYM entries / #define DT_MIPS_UNREFEXTNO 0x70000012 / First external DYNSYM / #define DT_MIPS_GOTSYM 0x70000013 / First GOT entry in DYNSYM / #define DT_MIPS_HIPAGENO 0x70000014 / Number of GOT page table entries / #define DT_MIPS_RLD_MAP 0x70000016 / Address of run time loader map. / #define DT_MIPS_DELTA_CLASS 0x70000017 / Delta C++ class definition. / #define DT_MIPS_DELTA_CLASS_NO 0x70000018 / Number of entries in DT_MIPS_DELTA_CLASS. / #define DT_MIPS_DELTA_INSTANCE 0x70000019 / Delta C++ class instances. / #define DT_MIPS_DELTA_INSTANCE_NO 0x7000001a / Number of entries in DT_MIPS_DELTA_INSTANCE. / #define DT_MIPS_DELTA_RELOC 0x7000001b / Delta relocations. / #define DT_MIPS_DELTA_RELOC_NO 0x7000001c / Number of entries in DT_MIPS_DELTA_RELOC. / #define DT_MIPS_DELTA_SYM 0x7000001d / Delta symbols that Delta relocations refer to. / #define DT_MIPS_DELTA_SYM_NO 0x7000001e / Number of entries in DT_MIPS_DELTA_SYM. / #define DT_MIPS_DELTA_CLASSSYM 0x70000020 / Delta symbols that hold the class declaration. / #define DT_MIPS_DELTA_CLASSSYM_NO 0x70000021 / Number of entries in DT_MIPS_DELTA_CLASSSYM. / #define DT_MIPS_CXX_FLAGS 0x70000022 / Flags indicating for C++ flavor. / #define DT_MIPS_PIXIE_INIT 0x70000023 #define DT_MIPS_SYMBOL_LIB 0x70000024 #define DT_MIPS_LOCALPAGE_GOTIDX 0x70000025 #define DT_MIPS_LOCAL_GOTIDX 0x70000026 #define DT_MIPS_HIDDEN_GOTIDX 0x70000027 #define DT_MIPS_PROTECTED_GOTIDX 0x70000028 #define DT_MIPS_OPTIONS 0x70000029 / Address of .options. / #define DT_MIPS_INTERFACE 0x7000002a / Address of .interface. / #define DT_MIPS_DYNSTR_ALIGN 0x7000002b #define DT_MIPS_INTERFACE_SIZE 0x7000002c / Size of the .interface section. / #define DT_MIPS_RLD_TEXT_RESOLVE_ADDR 0x7000002d / Address of rld_text_rsolve function stored in GOT. / #define DT_MIPS_PERF_SUFFIX 0x7000002e / Default suffix of dso to be added by rld on dlopen() calls. / #define DT_MIPS_COMPACT_SIZE 0x7000002f / (O32)Size of compact rel section. / #define DT_MIPS_GP_VALUE 0x70000030 / GP value for aux GOTs. / #define DT_MIPS_AUX_DYNAMIC 0x70000031 / Address of aux .dynamic. / / The address of .got.plt in an executable using the new non-PIC ABI. / #define DT_MIPS_PLTGOT 0x70000032 / The base of the PLT in an executable using the new non-PIC ABI if that PLT is writable. For a non-writable PLT, this is omitted or has a zero value. / #define DT_MIPS_RWPLT 0x70000034 / An alternative description of the classic MIPS RLD_MAP that is usable in a PIE as it stores a relative offset from the address of the tag rather than an absolute address. / #define DT_MIPS_RLD_MAP_REL 0x70000035 / GNU-style hash table with xlat. / #define DT_MIPS_XHASH 0x70000036 #define DT_MIPS_NUM 0x37 / Legal values for DT_MIPS_FLAGS Elf32_Dyn entry. / #define RHF_NONE 0 / No flags / #define RHF_QUICKSTART (1 << 0) / Use quickstart / #define RHF_NOTPOT (1 << 1) / Hash size not power of 2 / #define RHF_NO_LIBRARY_REPLACEMENT (1 << 2) / Ignore LD_LIBRARY_PATH / #define RHF_NO_MOVE (1 << 3) #define RHF_SGI_ONLY (1 << 4) #define RHF_GUARANTEE_INIT (1 << 5) #define RHF_DELTA_C_PLUS_PLUS (1 << 6) #define RHF_GUARANTEE_START_INIT (1 << 7) #define RHF_PIXIE (1 << 8) #define RHF_DEFAULT_DELAY_LOAD (1 << 9) #define RHF_REQUICKSTART (1 << 10) #define RHF_REQUICKSTARTED (1 << 11) #define RHF_CORD (1 << 12) #define RHF_NO_UNRES_UNDEF (1 << 13) #define RHF_RLD_ORDER_SAFE (1 << 14) / Entries found in sections of type SHT_MIPS_LIBLIST. / typedef struct { Elf32_Word l_name; / Name (string table index) / Elf32_Word l_time_stamp; / Timestamp / Elf32_Word l_checksum; / Checksum / Elf32_Word l_version; / Interface version / Elf32_Word l_flags; / Flags / } Elf32_Lib; typedef struct { Elf64_Word l_name; / Name (string table index) / Elf64_Word l_time_stamp; / Timestamp / Elf64_Word l_checksum; / Checksum / Elf64_Word l_version; / Interface version / Elf64_Word l_flags; / Flags / } Elf64_Lib; / Legal values for l_flags. / #define LL_NONE 0 #define LL_EXACT_MATCH (1 << 0) / Require exact match / #define LL_IGNORE_INT_VER (1 << 1) / Ignore interface version / #define LL_REQUIRE_MINOR (1 << 2) #define LL_EXPORTS (1 << 3) #define LL_DELAY_LOAD (1 << 4) #define LL_DELTA (1 << 5) / Entries found in sections of type SHT_MIPS_CONFLICT. / typedef Elf32_Addr Elf32_Conflict; typedef struct { / Version of flags structure. / Elf32_Half version; / The level of the ISA: 1-5, 32, 64. / unsigned char isa_level; / The revision of ISA: 0 for MIPS V and below, 1-n otherwise. / unsigned char isa_rev; / The size of general purpose registers. / unsigned char gpr_size; / The size of co-processor 1 registers. / unsigned char cpr1_size; / The size of co-processor 2 registers. / unsigned char cpr2_size; / The floating-point ABI. / unsigned char fp_abi; / Processor-specific extension. / Elf32_Word isa_ext; / Mask of ASEs used. / Elf32_Word ases; / Mask of general flags. / Elf32_Word flags1; Elf32_Word flags2; } Elf_MIPS_ABIFlags_v0; / Values for the register size bytes of an abi flags structure. / #define MIPS_AFL_REG_NONE 0x00 / No registers. / #define MIPS_AFL_REG_32 0x01 / 32-bit registers. / #define MIPS_AFL_REG_64 0x02 / 64-bit registers. / #define MIPS_AFL_REG_128 0x03 / 128-bit registers. / / Masks for the ases word of an ABI flags structure. / #define MIPS_AFL_ASE_DSP 0x00000001 / DSP ASE. / #define MIPS_AFL_ASE_DSPR2 0x00000002 / DSP R2 ASE. / #define MIPS_AFL_ASE_EVA 0x00000004 / Enhanced VA Scheme. / #define MIPS_AFL_ASE_MCU 0x00000008 / MCU (MicroController) ASE. / #define MIPS_AFL_ASE_MDMX 0x00000010 / MDMX ASE. / #define MIPS_AFL_ASE_MIPS3D 0x00000020 / MIPS-3D ASE. / #define MIPS_AFL_ASE_MT 0x00000040 / MT ASE. / #define MIPS_AFL_ASE_SMARTMIPS 0x00000080 / SmartMIPS ASE. / #define MIPS_AFL_ASE_VIRT 0x00000100 / VZ ASE. / #define MIPS_AFL_ASE_MSA 0x00000200 / MSA ASE. / #define MIPS_AFL_ASE_MIPS16 0x00000400 / MIPS16 ASE. / #define MIPS_AFL_ASE_MICROMIPS 0x00000800 / MICROMIPS ASE. / #define MIPS_AFL_ASE_XPA 0x00001000 / XPA ASE. / #define MIPS_AFL_ASE_MASK 0x00001fff / All ASEs. / / Values for the isa_ext word of an ABI flags structure. / #define MIPS_AFL_EXT_XLR 1 / RMI Xlr instruction. / #define MIPS_AFL_EXT_OCTEON2 2 / Cavium Networks Octeon2. / #define MIPS_AFL_EXT_OCTEONP 3 / Cavium Networks OcteonP. / #define MIPS_AFL_EXT_LOONGSON_3A 4 / Loongson 3A. / #define MIPS_AFL_EXT_OCTEON 5 / Cavium Networks Octeon. / #define MIPS_AFL_EXT_5900 6 / MIPS R5900 instruction. / #define MIPS_AFL_EXT_4650 7 / MIPS R4650 instruction. / #define MIPS_AFL_EXT_4010 8 / LSI R4010 instruction. / #define MIPS_AFL_EXT_4100 9 / NEC VR4100 instruction. / #define MIPS_AFL_EXT_3900 10 / Toshiba R3900 instruction. / #define MIPS_AFL_EXT_10000 11 / MIPS R10000 instruction. / #define MIPS_AFL_EXT_SB1 12 / Broadcom SB-1 instruction. / #define MIPS_AFL_EXT_4111 13 / NEC VR4111/VR4181 instruction. / #define MIPS_AFL_EXT_4120 14 / NEC VR4120 instruction. / #define MIPS_AFL_EXT_5400 15 / NEC VR5400 instruction. / #define MIPS_AFL_EXT_5500 16 / NEC VR5500 instruction. / #define MIPS_AFL_EXT_LOONGSON_2E 17 / ST Microelectronics Loongson 2E. / #define MIPS_AFL_EXT_LOONGSON_2F 18 / ST Microelectronics Loongson 2F. / / Masks for the flags1 word of an ABI flags structure. / #define MIPS_AFL_FLAGS1_ODDSPREG 1 / Uses odd single-precision registers. / / Object attribute values. / enum { / Not tagged or not using any ABIs affected by the differences. / Val_GNU_MIPS_ABI_FP_ANY = 0, / Using hard-float -mdouble-float. / Val_GNU_MIPS_ABI_FP_DOUBLE = 1, / Using hard-float -msingle-float. / Val_GNU_MIPS_ABI_FP_SINGLE = 2, / Using soft-float. / Val_GNU_MIPS_ABI_FP_SOFT = 3, / Using -mips32r2 -mfp64. / Val_GNU_MIPS_ABI_FP_OLD_64 = 4, / Using -mfpxx. / Val_GNU_MIPS_ABI_FP_XX = 5, / Using -mips32r2 -mfp64. / Val_GNU_MIPS_ABI_FP_64 = 6, / Using -mips32r2 -mfp64 -mno-odd-spreg. / Val_GNU_MIPS_ABI_FP_64A = 7, / Maximum allocated FP ABI value. / Val_GNU_MIPS_ABI_FP_MAX = 7 }; / HPPA specific definitions. / / Legal values for e_flags field of Elf32_Ehdr. / #define EF_PARISC_TRAPNIL 0x00010000 / Trap nil pointer dereference. / #define EF_PARISC_EXT 0x00020000 / Program uses arch. extensions. / #define EF_PARISC_LSB 0x00040000 / Program expects little endian. / #define EF_PARISC_WIDE 0x00080000 / Program expects wide mode. / #define EF_PARISC_NO_KABP 0x00100000 / No kernel assisted branch prediction. / #define EF_PARISC_LAZYSWAP 0x00400000 / Allow lazy swapping. / #define EF_PARISC_ARCH 0x0000ffff / Architecture version. / / Defined values for `e_flags & EF_PARISC_ARCH' are: / #define EFA_PARISC_1_0 0x020b / PA-RISC 1.0 big-endian. / #define EFA_PARISC_1_1 0x0210 / PA-RISC 1.1 big-endian. / #define EFA_PARISC_2_0 0x0214 / PA-RISC 2.0 big-endian. / / Additional section indices. / #define SHN_PARISC_ANSI_COMMON 0xff00 / Section for tentatively declared symbols in ANSI C. / #define SHN_PARISC_HUGE_COMMON 0xff01 / Common blocks in huge model. / / Legal values for sh_type field of Elf32_Shdr. / #define SHT_PARISC_EXT 0x70000000 / Contains product specific ext. / #define SHT_PARISC_UNWIND 0x70000001 / Unwind information. / #define SHT_PARISC_DOC 0x70000002 / Debug info for optimized code. / / Legal values for sh_flags field of Elf32_Shdr. / #define SHF_PARISC_SHORT 0x20000000 / Section with short addressing. / #define SHF_PARISC_HUGE 0x40000000 / Section far from gp. / #define SHF_PARISC_SBP 0x80000000 / Static branch prediction code. / / Legal values for ST_TYPE subfield of st_info (symbol type). / #define STT_PARISC_MILLICODE 13 / Millicode function entry point. / #define STT_HP_OPAQUE (STT_LOOS + 0x1) #define STT_HP_STUB (STT_LOOS + 0x2) / HPPA relocs. / #define R_PARISC_NONE 0 / No reloc. / #define R_PARISC_DIR32 1 / Direct 32-bit reference. / #define R_PARISC_DIR21L 2 / Left 21 bits of eff. address. / #define R_PARISC_DIR17R 3 / Right 17 bits of eff. address. / #define R_PARISC_DIR17F 4 / 17 bits of eff. address. / #define R_PARISC_DIR14R 6 / Right 14 bits of eff. address. / #define R_PARISC_PCREL32 9 / 32-bit rel. address. / #define R_PARISC_PCREL21L 10 / Left 21 bits of rel. address. / #define R_PARISC_PCREL17R 11 / Right 17 bits of rel. address. / #define R_PARISC_PCREL17F 12 / 17 bits of rel. address. / #define R_PARISC_PCREL14R 14 / Right 14 bits of rel. address. / #define R_PARISC_DPREL21L 18 / Left 21 bits of rel. address. / #define R_PARISC_DPREL14R 22 / Right 14 bits of rel. address. / #define R_PARISC_GPREL21L 26 / GP-relative, left 21 bits. / #define R_PARISC_GPREL14R 30 / GP-relative, right 14 bits. / #define R_PARISC_LTOFF21L 34 / LT-relative, left 21 bits. / #define R_PARISC_LTOFF14R 38 / LT-relative, right 14 bits. / #define R_PARISC_SECREL32 41 / 32 bits section rel. address. / #define R_PARISC_SEGBASE 48 / No relocation, set segment base. / #define R_PARISC_SEGREL32 49 / 32 bits segment rel. address. / #define R_PARISC_PLTOFF21L 50 / PLT rel. address, left 21 bits. / #define R_PARISC_PLTOFF14R 54 / PLT rel. address, right 14 bits. / #define R_PARISC_LTOFF_FPTR32 57 / 32 bits LT-rel. function pointer. / #define R_PARISC_LTOFF_FPTR21L 58 / LT-rel. fct ptr, left 21 bits. / #define R_PARISC_LTOFF_FPTR14R 62 / LT-rel. fct ptr, right 14 bits. / #define R_PARISC_FPTR64 64 / 64 bits function address. / #define R_PARISC_PLABEL32 65 / 32 bits function address. / #define R_PARISC_PLABEL21L 66 / Left 21 bits of fdesc address. / #define R_PARISC_PLABEL14R 70 / Right 14 bits of fdesc address. / #define R_PARISC_PCREL64 72 / 64 bits PC-rel. address. / #define R_PARISC_PCREL22F 74 / 22 bits PC-rel. address. / #define R_PARISC_PCREL14WR 75 / PC-rel. address, right 14 bits. / #define R_PARISC_PCREL14DR 76 / PC rel. address, right 14 bits. / #define R_PARISC_PCREL16F 77 / 16 bits PC-rel. address. / #define R_PARISC_PCREL16WF 78 / 16 bits PC-rel. address. / #define R_PARISC_PCREL16DF 79 / 16 bits PC-rel. address. / #define R_PARISC_DIR64 80 / 64 bits of eff. address. / #define R_PARISC_DIR14WR 83 / 14 bits of eff. address. / #define R_PARISC_DIR14DR 84 / 14 bits of eff. address. / #define R_PARISC_DIR16F 85 / 16 bits of eff. address. / #define R_PARISC_DIR16WF 86 / 16 bits of eff. address. / #define R_PARISC_DIR16DF 87 / 16 bits of eff. address. / #define R_PARISC_GPREL64 88 / 64 bits of GP-rel. address. / #define R_PARISC_GPREL14WR 91 / GP-rel. address, right 14 bits. / #define R_PARISC_GPREL14DR 92 / GP-rel. address, right 14 bits. / #define R_PARISC_GPREL16F 93 / 16 bits GP-rel. address. / #define R_PARISC_GPREL16WF 94 / 16 bits GP-rel. address. / #define R_PARISC_GPREL16DF 95 / 16 bits GP-rel. address. / #define R_PARISC_LTOFF64 96 / 64 bits LT-rel. address. / #define R_PARISC_LTOFF14WR 99 / LT-rel. address, right 14 bits. / #define R_PARISC_LTOFF14DR 100 / LT-rel. address, right 14 bits. / #define R_PARISC_LTOFF16F 101 / 16 bits LT-rel. address. / #define R_PARISC_LTOFF16WF 102 / 16 bits LT-rel. address. / #define R_PARISC_LTOFF16DF 103 / 16 bits LT-rel. address. / #define R_PARISC_SECREL64 104 / 64 bits section rel. address. / #define R_PARISC_SEGREL64 112 / 64 bits segment rel. address. / #define R_PARISC_PLTOFF14WR 115 / PLT-rel. address, right 14 bits. / #define R_PARISC_PLTOFF14DR 116 / PLT-rel. address, right 14 bits. / #define R_PARISC_PLTOFF16F 117 / 16 bits LT-rel. address. / #define R_PARISC_PLTOFF16WF 118 / 16 bits PLT-rel. address. / #define R_PARISC_PLTOFF16DF 119 / 16 bits PLT-rel. address. / #define R_PARISC_LTOFF_FPTR64 120 / 64 bits LT-rel. function ptr. / #define R_PARISC_LTOFF_FPTR14WR 123 / LT-rel. fct. ptr., right 14 bits. / #define R_PARISC_LTOFF_FPTR14DR 124 / LT-rel. fct. ptr., right 14 bits. / #define R_PARISC_LTOFF_FPTR16F 125 / 16 bits LT-rel. function ptr. / #define R_PARISC_LTOFF_FPTR16WF 126 / 16 bits LT-rel. function ptr. / #define R_PARISC_LTOFF_FPTR16DF 127 / 16 bits LT-rel. function ptr. / #define R_PARISC_LORESERVE 128 #define R_PARISC_COPY 128 / Copy relocation. / #define R_PARISC_IPLT 129 / Dynamic reloc, imported PLT / #define R_PARISC_EPLT 130 / Dynamic reloc, exported PLT / #define R_PARISC_TPREL32 153 / 32 bits TP-rel. address. / #define R_PARISC_TPREL21L 154 / TP-rel. address, left 21 bits. / #define R_PARISC_TPREL14R 158 / TP-rel. address, right 14 bits. / #define R_PARISC_LTOFF_TP21L 162 / LT-TP-rel. address, left 21 bits. / #define R_PARISC_LTOFF_TP14R 166 / LT-TP-rel. address, right 14 bits./ #define R_PARISC_LTOFF_TP14F 167 / 14 bits LT-TP-rel. address. / #define R_PARISC_TPREL64 216 / 64 bits TP-rel. address. / #define R_PARISC_TPREL14WR 219 / TP-rel. address, right 14 bits. / #define R_PARISC_TPREL14DR 220 / TP-rel. address, right 14 bits. / #define R_PARISC_TPREL16F 221 / 16 bits TP-rel. address. / #define R_PARISC_TPREL16WF 222 / 16 bits TP-rel. address. / #define R_PARISC_TPREL16DF 223 / 16 bits TP-rel. address. / #define R_PARISC_LTOFF_TP64 224 / 64 bits LT-TP-rel. address. / #define R_PARISC_LTOFF_TP14WR 227 / LT-TP-rel. address, right 14 bits./ #define R_PARISC_LTOFF_TP14DR 228 / LT-TP-rel. address, right 14 bits./ #define R_PARISC_LTOFF_TP16F 229 / 16 bits LT-TP-rel. address. / #define R_PARISC_LTOFF_TP16WF 230 / 16 bits LT-TP-rel. address. / #define R_PARISC_LTOFF_TP16DF 231 / 16 bits LT-TP-rel. address. / #define R_PARISC_GNU_VTENTRY 232 #define R_PARISC_GNU_VTINHERIT 233 #define R_PARISC_TLS_GD21L 234 / GD 21-bit left. / #define R_PARISC_TLS_GD14R 235 / GD 14-bit right. / #define R_PARISC_TLS_GDCALL 236 / GD call to __t_g_a. / #define R_PARISC_TLS_LDM21L 237 / LD module 21-bit left. / #define R_PARISC_TLS_LDM14R 238 / LD module 14-bit right. / #define R_PARISC_TLS_LDMCALL 239 / LD module call to __t_g_a. / #define R_PARISC_TLS_LDO21L 240 / LD offset 21-bit left. / #define R_PARISC_TLS_LDO14R 241 / LD offset 14-bit right. / #define R_PARISC_TLS_DTPMOD32 242 / DTP module 32-bit. / #define R_PARISC_TLS_DTPMOD64 243 / DTP module 64-bit. / #define R_PARISC_TLS_DTPOFF32 244 / DTP offset 32-bit. / #define R_PARISC_TLS_DTPOFF64 245 / DTP offset 32-bit. / #define R_PARISC_TLS_LE21L R_PARISC_TPREL21L #define R_PARISC_TLS_LE14R R_PARISC_TPREL14R #define R_PARISC_TLS_IE21L R_PARISC_LTOFF_TP21L #define R_PARISC_TLS_IE14R R_PARISC_LTOFF_TP14R #define R_PARISC_TLS_TPREL32 R_PARISC_TPREL32 #define R_PARISC_TLS_TPREL64 R_PARISC_TPREL64 #define R_PARISC_HIRESERVE 255 / Legal values for p_type field of Elf32_Phdr/Elf64_Phdr. / #define PT_HP_TLS (PT_LOOS + 0x0) #define PT_HP_CORE_NONE (PT_LOOS + 0x1) #define PT_HP_CORE_VERSION (PT_LOOS + 0x2) #define PT_HP_CORE_KERNEL (PT_LOOS + 0x3) #define PT_HP_CORE_COMM (PT_LOOS + 0x4) #define PT_HP_CORE_PROC (PT_LOOS + 0x5) #define PT_HP_CORE_LOADABLE (PT_LOOS + 0x6) #define PT_HP_CORE_STACK (PT_LOOS + 0x7) #define PT_HP_CORE_SHM (PT_LOOS + 0x8) #define PT_HP_CORE_MMF (PT_LOOS + 0x9) #define PT_HP_PARALLEL (PT_LOOS + 0x10) #define PT_HP_FASTBIND (PT_LOOS + 0x11) #define PT_HP_OPT_ANNOT (PT_LOOS + 0x12) #define PT_HP_HSL_ANNOT (PT_LOOS + 0x13) #define PT_HP_STACK (PT_LOOS + 0x14) #define PT_PARISC_ARCHEXT 0x70000000 #define PT_PARISC_UNWIND 0x70000001 / Legal values for p_flags field of Elf32_Phdr/Elf64_Phdr. / #define PF_PARISC_SBP 0x08000000 #define PF_HP_PAGE_SIZE 0x00100000 #define PF_HP_FAR_SHARED 0x00200000 #define PF_HP_NEAR_SHARED 0x00400000 #define PF_HP_CODE 0x01000000 #define PF_HP_MODIFY 0x02000000 #define PF_HP_LAZYSWAP 0x04000000 #define PF_HP_SBP 0x08000000 / Alpha specific definitions. / / Legal values for e_flags field of Elf64_Ehdr. / #define EF_ALPHA_32BIT 1 / All addresses must be < 2GB. / #define EF_ALPHA_CANRELAX 2 / Relocations for relaxing exist. / / Legal values for sh_type field of Elf64_Shdr. / / These two are primerily concerned with ECOFF debugging info. / #define SHT_ALPHA_DEBUG 0x70000001 #define SHT_ALPHA_REGINFO 0x70000002 / Legal values for sh_flags field of Elf64_Shdr. / #define SHF_ALPHA_GPREL 0x10000000 / Legal values for st_other field of Elf64_Sym. / #define STO_ALPHA_NOPV 0x80 / No PV required. / #define STO_ALPHA_STD_GPLOAD 0x88 / PV only used for initial ldgp. / / Alpha relocs. / #define R_ALPHA_NONE 0 / No reloc / #define R_ALPHA_REFLONG 1 / Direct 32 bit / #define R_ALPHA_REFQUAD 2 / Direct 64 bit / #define R_ALPHA_GPREL32 3 / GP relative 32 bit / #define R_ALPHA_LITERAL 4 / GP relative 16 bit w/optimization / #define R_ALPHA_LITUSE 5 / Optimization hint for LITERAL / #define R_ALPHA_GPDISP 6 / Add displacement to GP / #define R_ALPHA_BRADDR 7 / PC+4 relative 23 bit shifted / #define R_ALPHA_HINT 8 / PC+4 relative 16 bit shifted / #define R_ALPHA_SREL16 9 / PC relative 16 bit / #define R_ALPHA_SREL32 10 / PC relative 32 bit / #define R_ALPHA_SREL64 11 / PC relative 64 bit / #define R_ALPHA_GPRELHIGH 17 / GP relative 32 bit, high 16 bits / #define R_ALPHA_GPRELLOW 18 / GP relative 32 bit, low 16 bits / #define R_ALPHA_GPREL16 19 / GP relative 16 bit / #define R_ALPHA_COPY 24 / Copy symbol at runtime / #define R_ALPHA_GLOB_DAT 25 / Create GOT entry / #define R_ALPHA_JMP_SLOT 26 / Create PLT entry / #define R_ALPHA_RELATIVE 27 / Adjust by program base / #define R_ALPHA_TLS_GD_HI 28 #define R_ALPHA_TLSGD 29 #define R_ALPHA_TLS_LDM 30 #define R_ALPHA_DTPMOD64 31 #define R_ALPHA_GOTDTPREL 32 #define R_ALPHA_DTPREL64 33 #define R_ALPHA_DTPRELHI 34 #define R_ALPHA_DTPRELLO 35 #define R_ALPHA_DTPREL16 36 #define R_ALPHA_GOTTPREL 37 #define R_ALPHA_TPREL64 38 #define R_ALPHA_TPRELHI 39 #define R_ALPHA_TPRELLO 40 #define R_ALPHA_TPREL16 41 / Keep this the last entry. / #define R_ALPHA_NUM 46 / Magic values of the LITUSE relocation addend. / #define LITUSE_ALPHA_ADDR 0 #define LITUSE_ALPHA_BASE 1 #define LITUSE_ALPHA_BYTOFF 2 #define LITUSE_ALPHA_JSR 3 #define LITUSE_ALPHA_TLS_GD 4 #define LITUSE_ALPHA_TLS_LDM 5 / Legal values for d_tag of Elf64_Dyn. / #define DT_ALPHA_PLTRO (DT_LOPROC + 0) #define DT_ALPHA_NUM 1 / PowerPC specific declarations / / Values for Elf32/64_Ehdr.e_flags. / #define EF_PPC_EMB 0x80000000 / PowerPC embedded flag / / Cygnus local bits below / #define EF_PPC_RELOCATABLE 0x00010000 / PowerPC -mrelocatable flag/ #define EF_PPC_RELOCATABLE_LIB 0x00008000 / PowerPC -mrelocatable-lib flag / / PowerPC relocations defined by the ABIs / #define R_PPC_NONE 0 #define R_PPC_ADDR32 1 / 32bit absolute address / #define R_PPC_ADDR24 2 / 26bit address, 2 bits ignored. / #define R_PPC_ADDR16 3 / 16bit absolute address / #define R_PPC_ADDR16_LO 4 / lower 16bit of absolute address / #define R_PPC_ADDR16_HI 5 / high 16bit of absolute address / #define R_PPC_ADDR16_HA 6 / adjusted high 16bit / #define R_PPC_ADDR14 7 / 16bit address, 2 bits ignored / #define R_PPC_ADDR14_BRTAKEN 8 #define R_PPC_ADDR14_BRNTAKEN 9 #define R_PPC_REL24 10 / PC relative 26 bit / #define R_PPC_REL14 11 / PC relative 16 bit / #define R_PPC_REL14_BRTAKEN 12 #define R_PPC_REL14_BRNTAKEN 13 #define R_PPC_GOT16 14 #define R_PPC_GOT16_LO 15 #define R_PPC_GOT16_HI 16 #define R_PPC_GOT16_HA 17 #define R_PPC_PLTREL24 18 #define R_PPC_COPY 19 #define R_PPC_GLOB_DAT 20 #define R_PPC_JMP_SLOT 21 #define R_PPC_RELATIVE 22 #define R_PPC_LOCAL24PC 23 #define R_PPC_UADDR32 24 #define R_PPC_UADDR16 25 #define R_PPC_REL32 26 #define R_PPC_PLT32 27 #define R_PPC_PLTREL32 28 #define R_PPC_PLT16_LO 29 #define R_PPC_PLT16_HI 30 #define R_PPC_PLT16_HA 31 #define R_PPC_SDAREL16 32 #define R_PPC_SECTOFF 33 #define R_PPC_SECTOFF_LO 34 #define R_PPC_SECTOFF_HI 35 #define R_PPC_SECTOFF_HA 36 / PowerPC relocations defined for the TLS access ABI. / #define R_PPC_TLS 67 / none (sym+add)@tls / #define R_PPC_DTPMOD32 68 / word32 (sym+add)@dtpmod / #define R_PPC_TPREL16 69 / half16* (sym+add)@tprel / #define R_PPC_TPREL16_LO 70 / half16 (sym+add)@tprel@l / #define R_PPC_TPREL16_HI 71 / half16 (sym+add)@tprel@h / #define R_PPC_TPREL16_HA 72 / half16 (sym+add)@tprel@ha / #define R_PPC_TPREL32 73 / word32 (sym+add)@tprel / #define R_PPC_DTPREL16 74 / half16* (sym+add)@dtprel / #define R_PPC_DTPREL16_LO 75 / half16 (sym+add)@dtprel@l / #define R_PPC_DTPREL16_HI 76 / half16 (sym+add)@dtprel@h / #define R_PPC_DTPREL16_HA 77 / half16 (sym+add)@dtprel@ha / #define R_PPC_DTPREL32 78 / word32 (sym+add)@dtprel / #define R_PPC_GOT_TLSGD16 79 / half16* (sym+add)@got@tlsgd / #define R_PPC_GOT_TLSGD16_LO 80 / half16 (sym+add)@got@tlsgd@l / #define R_PPC_GOT_TLSGD16_HI 81 / half16 (sym+add)@got@tlsgd@h / #define R_PPC_GOT_TLSGD16_HA 82 / half16 (sym+add)@got@tlsgd@ha / #define R_PPC_GOT_TLSLD16 83 / half16* (sym+add)@got@tlsld / #define R_PPC_GOT_TLSLD16_LO 84 / half16 (sym+add)@got@tlsld@l / #define R_PPC_GOT_TLSLD16_HI 85 / half16 (sym+add)@got@tlsld@h / #define R_PPC_GOT_TLSLD16_HA 86 / half16 (sym+add)@got@tlsld@ha / #define R_PPC_GOT_TPREL16 87 / half16* (sym+add)@got@tprel / #define R_PPC_GOT_TPREL16_LO 88 / half16 (sym+add)@got@tprel@l / #define R_PPC_GOT_TPREL16_HI 89 / half16 (sym+add)@got@tprel@h / #define R_PPC_GOT_TPREL16_HA 90 / half16 (sym+add)@got@tprel@ha / #define R_PPC_GOT_DTPREL16 91 / half16* (sym+add)@got@dtprel / #define R_PPC_GOT_DTPREL16_LO 92 / half16* (sym+add)@got@dtprel@l / #define R_PPC_GOT_DTPREL16_HI 93 / half16* (sym+add)@got@dtprel@h / #define R_PPC_GOT_DTPREL16_HA 94 / half16* (sym+add)@got@dtprel@ha / #define R_PPC_TLSGD 95 / none (sym+add)@tlsgd / #define R_PPC_TLSLD 96 / none (sym+add)@tlsld / / The remaining relocs are from the Embedded ELF ABI, and are not in the SVR4 ELF ABI. / #define R_PPC_EMB_NADDR32 101 #define R_PPC_EMB_NADDR16 102 #define R_PPC_EMB_NADDR16_LO 103 #define R_PPC_EMB_NADDR16_HI 104 #define R_PPC_EMB_NADDR16_HA 105 #define R_PPC_EMB_SDAI16 106 #define R_PPC_EMB_SDA2I16 107 #define R_PPC_EMB_SDA2REL 108 #define R_PPC_EMB_SDA21 109 / 16 bit offset in SDA / #define R_PPC_EMB_MRKREF 110 #define R_PPC_EMB_RELSEC16 111 #define R_PPC_EMB_RELST_LO 112 #define R_PPC_EMB_RELST_HI 113 #define R_PPC_EMB_RELST_HA 114 #define R_PPC_EMB_BIT_FLD 115 #define R_PPC_EMB_RELSDA 116 / 16 bit relative offset in SDA / / Diab tool relocations. / #define R_PPC_DIAB_SDA21_LO 180 / like EMB_SDA21, but lower 16 bit / #define R_PPC_DIAB_SDA21_HI 181 / like EMB_SDA21, but high 16 bit / #define R_PPC_DIAB_SDA21_HA 182 / like EMB_SDA21, adjusted high 16 / #define R_PPC_DIAB_RELSDA_LO 183 / like EMB_RELSDA, but lower 16 bit / #define R_PPC_DIAB_RELSDA_HI 184 / like EMB_RELSDA, but high 16 bit / #define R_PPC_DIAB_RELSDA_HA 185 / like EMB_RELSDA, adjusted high 16 / / GNU extension to support local ifunc. / #define R_PPC_IRELATIVE 248 / GNU relocs used in PIC code sequences. / #define R_PPC_REL16 249 / half16 (sym+add-.) / #define R_PPC_REL16_LO 250 / half16 (sym+add-.)@l / #define R_PPC_REL16_HI 251 / half16 (sym+add-.)@h / #define R_PPC_REL16_HA 252 / half16 (sym+add-.)@ha / / This is a phony reloc to handle any old fashioned TOC16 references that may still be in object files. / #define R_PPC_TOC16 255 / PowerPC specific values for the Dyn d_tag field. / #define DT_PPC_GOT (DT_LOPROC + 0) #define DT_PPC_OPT (DT_LOPROC + 1) #define DT_PPC_NUM 2 / PowerPC specific values for the DT_PPC_OPT Dyn entry. / #define PPC_OPT_TLS 1 / PowerPC64 relocations defined by the ABIs / #define R_PPC64_NONE R_PPC_NONE #define R_PPC64_ADDR32 R_PPC_ADDR32 / 32bit absolute address / #define R_PPC64_ADDR24 R_PPC_ADDR24 / 26bit address, word aligned / #define R_PPC64_ADDR16 R_PPC_ADDR16 / 16bit absolute address / #define R_PPC64_ADDR16_LO R_PPC_ADDR16_LO / lower 16bits of address / #define R_PPC64_ADDR16_HI R_PPC_ADDR16_HI / high 16bits of address. / #define R_PPC64_ADDR16_HA R_PPC_ADDR16_HA / adjusted high 16bits. / #define R_PPC64_ADDR14 R_PPC_ADDR14 / 16bit address, word aligned / #define R_PPC64_ADDR14_BRTAKEN R_PPC_ADDR14_BRTAKEN #define R_PPC64_ADDR14_BRNTAKEN R_PPC_ADDR14_BRNTAKEN #define R_PPC64_REL24 R_PPC_REL24 / PC-rel. 26 bit, word aligned / #define R_PPC64_REL14 R_PPC_REL14 / PC relative 16 bit / #define R_PPC64_REL14_BRTAKEN R_PPC_REL14_BRTAKEN #define R_PPC64_REL14_BRNTAKEN R_PPC_REL14_BRNTAKEN #define R_PPC64_GOT16 R_PPC_GOT16 #define R_PPC64_GOT16_LO R_PPC_GOT16_LO #define R_PPC64_GOT16_HI R_PPC_GOT16_HI #define R_PPC64_GOT16_HA R_PPC_GOT16_HA #define R_PPC64_COPY R_PPC_COPY #define R_PPC64_GLOB_DAT R_PPC_GLOB_DAT #define R_PPC64_JMP_SLOT R_PPC_JMP_SLOT #define R_PPC64_RELATIVE R_PPC_RELATIVE #define R_PPC64_UADDR32 R_PPC_UADDR32 #define R_PPC64_UADDR16 R_PPC_UADDR16 #define R_PPC64_REL32 R_PPC_REL32 #define R_PPC64_PLT32 R_PPC_PLT32 #define R_PPC64_PLTREL32 R_PPC_PLTREL32 #define R_PPC64_PLT16_LO R_PPC_PLT16_LO #define R_PPC64_PLT16_HI R_PPC_PLT16_HI #define R_PPC64_PLT16_HA R_PPC_PLT16_HA #define R_PPC64_SECTOFF R_PPC_SECTOFF #define R_PPC64_SECTOFF_LO R_PPC_SECTOFF_LO #define R_PPC64_SECTOFF_HI R_PPC_SECTOFF_HI #define R_PPC64_SECTOFF_HA R_PPC_SECTOFF_HA #define R_PPC64_ADDR30 37 / word30 (S + A - P) >> 2 / #define R_PPC64_ADDR64 38 / doubleword64 S + A / #define R_PPC64_ADDR16_HIGHER 39 / half16 #higher(S + A) / #define R_PPC64_ADDR16_HIGHERA 40 / half16 #highera(S + A) / #define R_PPC64_ADDR16_HIGHEST 41 / half16 #highest(S + A) / #define R_PPC64_ADDR16_HIGHESTA 42 / half16 #highesta(S + A) / #define R_PPC64_UADDR64 43 / doubleword64 S + A / #define R_PPC64_REL64 44 / doubleword64 S + A - P / #define R_PPC64_PLT64 45 / doubleword64 L + A / #define R_PPC64_PLTREL64 46 / doubleword64 L + A - P / #define R_PPC64_TOC16 47 / half16* S + A - .TOC / #define R_PPC64_TOC16_LO 48 / half16 #lo(S + A - .TOC.) / #define R_PPC64_TOC16_HI 49 / half16 #hi(S + A - .TOC.) / #define R_PPC64_TOC16_HA 50 / half16 #ha(S + A - .TOC.) / #define R_PPC64_TOC 51 / doubleword64 .TOC / #define R_PPC64_PLTGOT16 52 / half16* M + A / #define R_PPC64_PLTGOT16_LO 53 / half16 #lo(M + A) / #define R_PPC64_PLTGOT16_HI 54 / half16 #hi(M + A) / #define R_PPC64_PLTGOT16_HA 55 / half16 #ha(M + A) / #define R_PPC64_ADDR16_DS 56 / half16ds* (S + A) >> 2 / #define R_PPC64_ADDR16_LO_DS 57 / half16ds #lo(S + A) >> 2 / #define R_PPC64_GOT16_DS 58 / half16ds* (G + A) >> 2 / #define R_PPC64_GOT16_LO_DS 59 / half16ds #lo(G + A) >> 2 / #define R_PPC64_PLT16_LO_DS 60 / half16ds #lo(L + A) >> 2 / #define R_PPC64_SECTOFF_DS 61 / half16ds* (R + A) >> 2 / #define R_PPC64_SECTOFF_LO_DS 62 / half16ds #lo(R + A) >> 2 / #define R_PPC64_TOC16_DS 63 / half16ds* (S + A - .TOC.) >> 2 / #define R_PPC64_TOC16_LO_DS 64 / half16ds #lo(S + A - .TOC.) >> 2 / #define R_PPC64_PLTGOT16_DS 65 / half16ds* (M + A) >> 2 / #define R_PPC64_PLTGOT16_LO_DS 66 / half16ds #lo(M + A) >> 2 / / PowerPC64 relocations defined for the TLS access ABI. / #define R_PPC64_TLS 67 / none (sym+add)@tls / #define R_PPC64_DTPMOD64 68 / doubleword64 (sym+add)@dtpmod / #define R_PPC64_TPREL16 69 / half16* (sym+add)@tprel / #define R_PPC64_TPREL16_LO 70 / half16 (sym+add)@tprel@l / #define R_PPC64_TPREL16_HI 71 / half16 (sym+add)@tprel@h / #define R_PPC64_TPREL16_HA 72 / half16 (sym+add)@tprel@ha / #define R_PPC64_TPREL64 73 / doubleword64 (sym+add)@tprel / #define R_PPC64_DTPREL16 74 / half16* (sym+add)@dtprel / #define R_PPC64_DTPREL16_LO 75 / half16 (sym+add)@dtprel@l / #define R_PPC64_DTPREL16_HI 76 / half16 (sym+add)@dtprel@h / #define R_PPC64_DTPREL16_HA 77 / half16 (sym+add)@dtprel@ha / #define R_PPC64_DTPREL64 78 / doubleword64 (sym+add)@dtprel / #define R_PPC64_GOT_TLSGD16 79 / half16* (sym+add)@got@tlsgd / #define R_PPC64_GOT_TLSGD16_LO 80 / half16 (sym+add)@got@tlsgd@l / #define R_PPC64_GOT_TLSGD16_HI 81 / half16 (sym+add)@got@tlsgd@h / #define R_PPC64_GOT_TLSGD16_HA 82 / half16 (sym+add)@got@tlsgd@ha / #define R_PPC64_GOT_TLSLD16 83 / half16* (sym+add)@got@tlsld / #define R_PPC64_GOT_TLSLD16_LO 84 / half16 (sym+add)@got@tlsld@l / #define R_PPC64_GOT_TLSLD16_HI 85 / half16 (sym+add)@got@tlsld@h / #define R_PPC64_GOT_TLSLD16_HA 86 / half16 (sym+add)@got@tlsld@ha / #define R_PPC64_GOT_TPREL16_DS 87 / half16ds* (sym+add)@got@tprel / #define R_PPC64_GOT_TPREL16_LO_DS 88 / half16ds (sym+add)@got@tprel@l / #define R_PPC64_GOT_TPREL16_HI 89 / half16 (sym+add)@got@tprel@h / #define R_PPC64_GOT_TPREL16_HA 90 / half16 (sym+add)@got@tprel@ha / #define R_PPC64_GOT_DTPREL16_DS 91 / half16ds* (sym+add)@got@dtprel / #define R_PPC64_GOT_DTPREL16_LO_DS 92 / half16ds (sym+add)@got@dtprel@l / #define R_PPC64_GOT_DTPREL16_HI 93 / half16 (sym+add)@got@dtprel@h / #define R_PPC64_GOT_DTPREL16_HA 94 / half16 (sym+add)@got@dtprel@ha / #define R_PPC64_TPREL16_DS 95 / half16ds* (sym+add)@tprel / #define R_PPC64_TPREL16_LO_DS 96 / half16ds (sym+add)@tprel@l / #define R_PPC64_TPREL16_HIGHER 97 / half16 (sym+add)@tprel@higher / #define R_PPC64_TPREL16_HIGHERA 98 / half16 (sym+add)@tprel@highera / #define R_PPC64_TPREL16_HIGHEST 99 / half16 (sym+add)@tprel@highest / #define R_PPC64_TPREL16_HIGHESTA 100 / half16 (sym+add)@tprel@highesta / #define R_PPC64_DTPREL16_DS 101 / half16ds* (sym+add)@dtprel / #define R_PPC64_DTPREL16_LO_DS 102 / half16ds (sym+add)@dtprel@l / #define R_PPC64_DTPREL16_HIGHER 103 / half16 (sym+add)@dtprel@higher / #define R_PPC64_DTPREL16_HIGHERA 104 / half16 (sym+add)@dtprel@highera / #define R_PPC64_DTPREL16_HIGHEST 105 / half16 (sym+add)@dtprel@highest / #define R_PPC64_DTPREL16_HIGHESTA 106 / half16 (sym+add)@dtprel@highesta / #define R_PPC64_TLSGD 107 / none (sym+add)@tlsgd / #define R_PPC64_TLSLD 108 / none (sym+add)@tlsld / #define R_PPC64_TOCSAVE 109 / none / / Added when HA and HI relocs were changed to report overflows. / #define R_PPC64_ADDR16_HIGH 110 #define R_PPC64_ADDR16_HIGHA 111 #define R_PPC64_TPREL16_HIGH 112 #define R_PPC64_TPREL16_HIGHA 113 #define R_PPC64_DTPREL16_HIGH 114 #define R_PPC64_DTPREL16_HIGHA 115 / GNU extension to support local ifunc. / #define R_PPC64_JMP_IREL 247 #define R_PPC64_IRELATIVE 248 #define R_PPC64_REL16 249 / half16 (sym+add-.) / #define R_PPC64_REL16_LO 250 / half16 (sym+add-.)@l / #define R_PPC64_REL16_HI 251 / half16 (sym+add-.)@h / #define R_PPC64_REL16_HA 252 / half16 (sym+add-.)@ha / / e_flags bits specifying ABI. 1 for original function descriptor using ABI, 2 for revised ABI without function descriptors, 0 for unspecified or not using any features affected by the differences. / #define EF_PPC64_ABI 3 / PowerPC64 specific values for the Dyn d_tag field. / #define DT_PPC64_GLINK (DT_LOPROC + 0) #define DT_PPC64_OPD (DT_LOPROC + 1) #define DT_PPC64_OPDSZ (DT_LOPROC + 2) #define DT_PPC64_OPT (DT_LOPROC + 3) #define DT_PPC64_NUM 4 / PowerPC64 specific bits in the DT_PPC64_OPT Dyn entry. / #define PPC64_OPT_TLS 1 #define PPC64_OPT_MULTI_TOC 2 #define PPC64_OPT_LOCALENTRY 4 / PowerPC64 specific values for the Elf64_Sym st_other field. / #define STO_PPC64_LOCAL_BIT 5 #define STO_PPC64_LOCAL_MASK (7 << STO_PPC64_LOCAL_BIT) #define PPC64_LOCAL_ENTRY_OFFSET(other) \ (((1 << (((other) & STO_PPC64_LOCAL_MASK) >> STO_PPC64_LOCAL_BIT)) >> 2) << 2) / ARM specific declarations / / Processor specific flags for the ELF header e_flags field. / #define EF_ARM_RELEXEC 0x01 #define EF_ARM_HASENTRY 0x02 #define EF_ARM_INTERWORK 0x04 #define EF_ARM_APCS_26 0x08 #define EF_ARM_APCS_FLOAT 0x10 #define EF_ARM_PIC 0x20 #define EF_ARM_ALIGN8 0x40 / 8-bit structure alignment is in use / #define EF_ARM_NEW_ABI 0x80 #define EF_ARM_OLD_ABI 0x100 #define EF_ARM_SOFT_FLOAT 0x200 #define EF_ARM_VFP_FLOAT 0x400 #define EF_ARM_MAVERICK_FLOAT 0x800 #define EF_ARM_ABI_FLOAT_SOFT 0x200 / NB conflicts with EF_ARM_SOFT_FLOAT / #define EF_ARM_ABI_FLOAT_HARD 0x400 / NB conflicts with EF_ARM_VFP_FLOAT / / Other constants defined in the ARM ELF spec. version B-01. / / NB. These conflict with values defined above. / #define EF_ARM_SYMSARESORTED 0x04 #define EF_ARM_DYNSYMSUSESEGIDX 0x08 #define EF_ARM_MAPSYMSFIRST 0x10 #define EF_ARM_EABIMASK 0XFF000000 / Constants defined in AAELF. / #define EF_ARM_BE8 0x00800000 #define EF_ARM_LE8 0x00400000 #define EF_ARM_EABI_VERSION(flags) ((flags) & EF_ARM_EABIMASK) #define EF_ARM_EABI_UNKNOWN 0x00000000 #define EF_ARM_EABI_VER1 0x01000000 #define EF_ARM_EABI_VER2 0x02000000 #define EF_ARM_EABI_VER3 0x03000000 #define EF_ARM_EABI_VER4 0x04000000 #define EF_ARM_EABI_VER5 0x05000000 / Additional symbol types for Thumb. / #define STT_ARM_TFUNC STT_LOPROC / A Thumb function. / #define STT_ARM_16BIT STT_HIPROC / A Thumb label. / / ARM-specific values for sh_flags / #define SHF_ARM_ENTRYSECT 0x10000000 / Section contains an entry point / #define SHF_ARM_COMDEF 0x80000000 / Section may be multiply defined in the input to a link step. / / ARM-specific program header flags / #define PF_ARM_SB 0x10000000 / Segment contains the location addressed by the static base. / #define PF_ARM_PI 0x20000000 / Position-independent segment. / #define PF_ARM_ABS 0x40000000 / Absolute segment. / / Processor specific values for the Phdr p_type field. / #define PT_ARM_EXIDX (PT_LOPROC + 1) / ARM unwind segment. / / Processor specific values for the Shdr sh_type field. / #define SHT_ARM_EXIDX (SHT_LOPROC + 1) / ARM unwind section. / #define SHT_ARM_PREEMPTMAP (SHT_LOPROC + 2) / Preemption details. / #define SHT_ARM_ATTRIBUTES (SHT_LOPROC + 3) / ARM attributes section. / / AArch64 relocs. / #define R_AARCH64_NONE 0 / No relocation. / / ILP32 AArch64 relocs. / #define R_AARCH64_P32_ABS32 1 / Direct 32 bit. / #define R_AARCH64_P32_COPY 180 / Copy symbol at runtime. / #define R_AARCH64_P32_GLOB_DAT 181 / Create GOT entry. / #define R_AARCH64_P32_JUMP_SLOT 182 / Create PLT entry. / #define R_AARCH64_P32_RELATIVE 183 / Adjust by program base. / #define R_AARCH64_P32_TLS_DTPMOD 184 / Module number, 32 bit. / #define R_AARCH64_P32_TLS_DTPREL 185 / Module-relative offset, 32 bit. / #define R_AARCH64_P32_TLS_TPREL 186 / TP-relative offset, 32 bit. / #define R_AARCH64_P32_TLSDESC 187 / TLS Descriptor. / #define R_AARCH64_P32_IRELATIVE 188 / STT_GNU_IFUNC relocation. / / LP64 AArch64 relocs. / #define R_AARCH64_ABS64 257 / Direct 64 bit. / #define R_AARCH64_ABS32 258 / Direct 32 bit. / #define R_AARCH64_ABS16 259 / Direct 16-bit. / #define R_AARCH64_PREL64 260 / PC-relative 64-bit. / #define R_AARCH64_PREL32 261 / PC-relative 32-bit. / #define R_AARCH64_PREL16 262 / PC-relative 16-bit. / #define R_AARCH64_MOVW_UABS_G0 263 / Dir. MOVZ imm. from bits 15:0. / #define R_AARCH64_MOVW_UABS_G0_NC 264 / Likewise for MOVK; no check. / #define R_AARCH64_MOVW_UABS_G1 265 / Dir. MOVZ imm. from bits 31:16. / #define R_AARCH64_MOVW_UABS_G1_NC 266 / Likewise for MOVK; no check. / #define R_AARCH64_MOVW_UABS_G2 267 / Dir. MOVZ imm. from bits 47:32. / #define R_AARCH64_MOVW_UABS_G2_NC 268 / Likewise for MOVK; no check. / #define R_AARCH64_MOVW_UABS_G3 269 / Dir. MOV{K,Z} imm. from 63:48. / #define R_AARCH64_MOVW_SABS_G0 270 / Dir. MOV{N,Z} imm. from 15:0. / #define R_AARCH64_MOVW_SABS_G1 271 / Dir. MOV{N,Z} imm. from 31:16. / #define R_AARCH64_MOVW_SABS_G2 272 / Dir. MOV{N,Z} imm. from 47:32. / #define R_AARCH64_LD_PREL_LO19 273 / PC-rel. LD imm. from bits 20:2. / #define R_AARCH64_ADR_PREL_LO21 274 / PC-rel. ADR imm. from bits 20:0. / #define R_AARCH64_ADR_PREL_PG_HI21 275 / Page-rel. ADRP imm. from 32:12. / #define R_AARCH64_ADR_PREL_PG_HI21_NC 276 / Likewise; no overflow check. / #define R_AARCH64_ADD_ABS_LO12_NC 277 / Dir. ADD imm. from bits 11:0. / #define R_AARCH64_LDST8_ABS_LO12_NC 278 / Likewise for LD/ST; no check. / #define R_AARCH64_TSTBR14 279 / PC-rel. TBZ/TBNZ imm. from 15:2. / #define R_AARCH64_CONDBR19 280 / PC-rel. cond. br. imm. from 20:2. / #define R_AARCH64_JUMP26 282 / PC-rel. B imm. from bits 27:2. / #define R_AARCH64_CALL26 283 / Likewise for CALL. / #define R_AARCH64_LDST16_ABS_LO12_NC 284 / Dir. ADD imm. from bits 11:1. / #define R_AARCH64_LDST32_ABS_LO12_NC 285 / Likewise for bits 11:2. / #define R_AARCH64_LDST64_ABS_LO12_NC 286 / Likewise for bits 11:3. / #define R_AARCH64_MOVW_PREL_G0 287 / PC-rel. MOV{N,Z} imm. from 15:0. / #define R_AARCH64_MOVW_PREL_G0_NC 288 / Likewise for MOVK; no check. / #define R_AARCH64_MOVW_PREL_G1 289 / PC-rel. MOV{N,Z} imm. from 31:16. / #define R_AARCH64_MOVW_PREL_G1_NC 290 / Likewise for MOVK; no check. / #define R_AARCH64_MOVW_PREL_G2 291 / PC-rel. MOV{N,Z} imm. from 47:32. / #define R_AARCH64_MOVW_PREL_G2_NC 292 / Likewise for MOVK; no check. / #define R_AARCH64_MOVW_PREL_G3 293 / PC-rel. MOV{N,Z} imm. from 63:48. / #define R_AARCH64_LDST128_ABS_LO12_NC 299 / Dir. ADD imm. from bits 11:4. / #define R_AARCH64_MOVW_GOTOFF_G0 300 / GOT-rel. off. MOV{N,Z} imm. 15:0. / #define R_AARCH64_MOVW_GOTOFF_G0_NC 301 / Likewise for MOVK; no check. / #define R_AARCH64_MOVW_GOTOFF_G1 302 / GOT-rel. o. MOV{N,Z} imm. 31:16. / #define R_AARCH64_MOVW_GOTOFF_G1_NC 303 / Likewise for MOVK; no check. / #define R_AARCH64_MOVW_GOTOFF_G2 304 / GOT-rel. o. MOV{N,Z} imm. 47:32. / #define R_AARCH64_MOVW_GOTOFF_G2_NC 305 / Likewise for MOVK; no check. / #define R_AARCH64_MOVW_GOTOFF_G3 306 / GOT-rel. o. MOV{N,Z} imm. 63:48. / #define R_AARCH64_GOTREL64 307 / GOT-relative 64-bit. / #define R_AARCH64_GOTREL32 308 / GOT-relative 32-bit. / #define R_AARCH64_GOT_LD_PREL19 309 / PC-rel. GOT off. load imm. 20:2. / #define R_AARCH64_LD64_GOTOFF_LO15 310 / GOT-rel. off. LD/ST imm. 14:3. / #define R_AARCH64_ADR_GOT_PAGE 311 / P-page-rel. GOT off. ADRP 32:12. / #define R_AARCH64_LD64_GOT_LO12_NC 312 / Dir. GOT off. LD/ST imm. 11:3. / #define R_AARCH64_LD64_GOTPAGE_LO15 313 / GOT-page-rel. GOT off. LD/ST 14:3 / #define R_AARCH64_TLSGD_ADR_PREL21 512 / PC-relative ADR imm. 20:0. / #define R_AARCH64_TLSGD_ADR_PAGE21 513 / page-rel. ADRP imm. 32:12. / #define R_AARCH64_TLSGD_ADD_LO12_NC 514 / direct ADD imm. from 11:0. / #define R_AARCH64_TLSGD_MOVW_G1 515 / GOT-rel. MOV{N,Z} 31:16. / #define R_AARCH64_TLSGD_MOVW_G0_NC 516 / GOT-rel. MOVK imm. 15:0. / #define R_AARCH64_TLSLD_ADR_PREL21 517 / Like 512; local dynamic model. / #define R_AARCH64_TLSLD_ADR_PAGE21 518 / Like 513; local dynamic model. / #define R_AARCH64_TLSLD_ADD_LO12_NC 519 / Like 514; local dynamic model. / #define R_AARCH64_TLSLD_MOVW_G1 520 / Like 515; local dynamic model. / #define R_AARCH64_TLSLD_MOVW_G0_NC 521 / Like 516; local dynamic model. / #define R_AARCH64_TLSLD_LD_PREL19 522 / TLS PC-rel. load imm. 20:2. / #define R_AARCH64_TLSLD_MOVW_DTPREL_G2 523 / TLS DTP-rel. MOV{N,Z} 47:32. / #define R_AARCH64_TLSLD_MOVW_DTPREL_G1 524 / TLS DTP-rel. MOV{N,Z} 31:16. / #define R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC 525 / Likewise; MOVK; no check. / #define R_AARCH64_TLSLD_MOVW_DTPREL_G0 526 / TLS DTP-rel. MOV{N,Z} 15:0. / #define R_AARCH64_TLSLD_MOVW_DTPREL_G0_NC 527 / Likewise; MOVK; no check. / #define R_AARCH64_TLSLD_ADD_DTPREL_HI12 528 / DTP-rel. ADD imm. from 23:12. / #define R_AARCH64_TLSLD_ADD_DTPREL_LO12 529 / DTP-rel. ADD imm. from 11:0. / #define R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC 530 / Likewise; no ovfl. check. / #define R_AARCH64_TLSLD_LDST8_DTPREL_LO12 531 / DTP-rel. LD/ST imm. 11:0. / #define R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC 532 / Likewise; no check. / #define R_AARCH64_TLSLD_LDST16_DTPREL_LO12 533 / DTP-rel. LD/ST imm. 11:1. / #define R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC 534 / Likewise; no check. / #define R_AARCH64_TLSLD_LDST32_DTPREL_LO12 535 / DTP-rel. LD/ST imm. 11:2. / #define R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC 536 / Likewise; no check. / #define R_AARCH64_TLSLD_LDST64_DTPREL_LO12 537 / DTP-rel. LD/ST imm. 11:3. / #define R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC 538 / Likewise; no check. / #define R_AARCH64_TLSIE_MOVW_GOTTPREL_G1 539 / GOT-rel. MOV{N,Z} 31:16. / #define R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC 540 / GOT-rel. MOVK 15:0. / #define R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 541 / Page-rel. ADRP 32:12. / #define R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC 542 / Direct LD off. 11:3. / #define R_AARCH64_TLSIE_LD_GOTTPREL_PREL19 543 / PC-rel. load imm. 20:2. / #define R_AARCH64_TLSLE_MOVW_TPREL_G2 544 / TLS TP-rel. MOV{N,Z} 47:32. / #define R_AARCH64_TLSLE_MOVW_TPREL_G1 545 / TLS TP-rel. MOV{N,Z} 31:16. / #define R_AARCH64_TLSLE_MOVW_TPREL_G1_NC 546 / Likewise; MOVK; no check. / #define R_AARCH64_TLSLE_MOVW_TPREL_G0 547 / TLS TP-rel. MOV{N,Z} 15:0. / #define R_AARCH64_TLSLE_MOVW_TPREL_G0_NC 548 / Likewise; MOVK; no check. / #define R_AARCH64_TLSLE_ADD_TPREL_HI12 549 / TP-rel. ADD imm. 23:12. / #define R_AARCH64_TLSLE_ADD_TPREL_LO12 550 / TP-rel. ADD imm. 11:0. / #define R_AARCH64_TLSLE_ADD_TPREL_LO12_NC 551 / Likewise; no ovfl. check. / #define R_AARCH64_TLSLE_LDST8_TPREL_LO12 552 / TP-rel. LD/ST off. 11:0. / #define R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC 553 / Likewise; no ovfl. check. / #define R_AARCH64_TLSLE_LDST16_TPREL_LO12 554 / TP-rel. LD/ST off. 11:1. / #define R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC 555 / Likewise; no check. / #define R_AARCH64_TLSLE_LDST32_TPREL_LO12 556 / TP-rel. LD/ST off. 11:2. / #define R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC 557 / Likewise; no check. / #define R_AARCH64_TLSLE_LDST64_TPREL_LO12 558 / TP-rel. LD/ST off. 11:3. / #define R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC 559 / Likewise; no check. / #define R_AARCH64_TLSDESC_LD_PREL19 560 / PC-rel. load immediate 20:2. / #define R_AARCH64_TLSDESC_ADR_PREL21 561 / PC-rel. ADR immediate 20:0. / #define R_AARCH64_TLSDESC_ADR_PAGE21 562 / Page-rel. ADRP imm. 32:12. / #define R_AARCH64_TLSDESC_LD64_LO12 563 / Direct LD off. from 11:3. / #define R_AARCH64_TLSDESC_ADD_LO12 564 / Direct ADD imm. from 11:0. / #define R_AARCH64_TLSDESC_OFF_G1 565 / GOT-rel. MOV{N,Z} imm. 31:16. / #define R_AARCH64_TLSDESC_OFF_G0_NC 566 / GOT-rel. MOVK imm. 15:0; no ck. / #define R_AARCH64_TLSDESC_LDR 567 / Relax LDR. / #define R_AARCH64_TLSDESC_ADD 568 / Relax ADD. / #define R_AARCH64_TLSDESC_CALL 569 / Relax BLR. / #define R_AARCH64_TLSLE_LDST128_TPREL_LO12 570 / TP-rel. LD/ST off. 11:4. / #define R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC 571 / Likewise; no check. / #define R_AARCH64_TLSLD_LDST128_DTPREL_LO12 572 / DTP-rel. LD/ST imm. 11:4. / #define R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC 573 / Likewise; no check. / #define R_AARCH64_COPY 1024 / Copy symbol at runtime. / #define R_AARCH64_GLOB_DAT 1025 / Create GOT entry. / #define R_AARCH64_JUMP_SLOT 1026 / Create PLT entry. / #define R_AARCH64_RELATIVE 1027 / Adjust by program base. / #define R_AARCH64_TLS_DTPMOD 1028 / Module number, 64 bit. / #define R_AARCH64_TLS_DTPREL 1029 / Module-relative offset, 64 bit. / #define R_AARCH64_TLS_TPREL 1030 / TP-relative offset, 64 bit. / #define R_AARCH64_TLSDESC 1031 / TLS Descriptor. / #define R_AARCH64_IRELATIVE 1032 / STT_GNU_IFUNC relocation. / / AArch64 specific values for the Dyn d_tag field. / #define DT_AARCH64_BTI_PLT (DT_LOPROC + 1) #define DT_AARCH64_PAC_PLT (DT_LOPROC + 3) #define DT_AARCH64_VARIANT_PCS (DT_LOPROC + 5) #define DT_AARCH64_NUM 6 / AArch64 specific values for the st_other field. / #define STO_AARCH64_VARIANT_PCS 0x80 / ARM relocs. / #define R_ARM_NONE 0 / No reloc / #define R_ARM_PC24 1 / Deprecated PC relative 26 bit branch. / #define R_ARM_ABS32 2 / Direct 32 bit / #define R_ARM_REL32 3 / PC relative 32 bit / #define R_ARM_PC13 4 #define R_ARM_ABS16 5 / Direct 16 bit / #define R_ARM_ABS12 6 / Direct 12 bit / #define R_ARM_THM_ABS5 7 / Direct & 0x7C (LDR, STR). / #define R_ARM_ABS8 8 / Direct 8 bit / #define R_ARM_SBREL32 9 #define R_ARM_THM_PC22 10 / PC relative 24 bit (Thumb32 BL). / #define R_ARM_THM_PC8 11 / PC relative & 0x3FC (Thumb16 LDR, ADD, ADR). / #define R_ARM_AMP_VCALL9 12 #define R_ARM_SWI24 13 / Obsolete static relocation. / #define R_ARM_TLS_DESC 13 / Dynamic relocation. / #define R_ARM_THM_SWI8 14 / Reserved. / #define R_ARM_XPC25 15 / Reserved. / #define R_ARM_THM_XPC22 16 / Reserved. / #define R_ARM_TLS_DTPMOD32 17 / ID of module containing symbol / #define R_ARM_TLS_DTPOFF32 18 / Offset in TLS block / #define R_ARM_TLS_TPOFF32 19 / Offset in static TLS block / #define R_ARM_COPY 20 / Copy symbol at runtime / #define R_ARM_GLOB_DAT 21 / Create GOT entry / #define R_ARM_JUMP_SLOT 22 / Create PLT entry / #define R_ARM_RELATIVE 23 / Adjust by program base / #define R_ARM_GOTOFF 24 / 32 bit offset to GOT / #define R_ARM_GOTPC 25 / 32 bit PC relative offset to GOT / #define R_ARM_GOT32 26 / 32 bit GOT entry / #define R_ARM_PLT32 27 / Deprecated, 32 bit PLT address. / #define R_ARM_CALL 28 / PC relative 24 bit (BL, BLX). / #define R_ARM_JUMP24 29 / PC relative 24 bit (B, BL<cond>). / #define R_ARM_THM_JUMP24 30 / PC relative 24 bit (Thumb32 B.W). / #define R_ARM_BASE_ABS 31 / Adjust by program base. / #define R_ARM_ALU_PCREL_7_0 32 / Obsolete. / #define R_ARM_ALU_PCREL_15_8 33 / Obsolete. / #define R_ARM_ALU_PCREL_23_15 34 / Obsolete. / #define R_ARM_LDR_SBREL_11_0 35 / Deprecated, prog. base relative. / #define R_ARM_ALU_SBREL_19_12 36 / Deprecated, prog. base relative. / #define R_ARM_ALU_SBREL_27_20 37 / Deprecated, prog. base relative. / #define R_ARM_TARGET1 38 #define R_ARM_SBREL31 39 / Program base relative. / #define R_ARM_V4BX 40 #define R_ARM_TARGET2 41 #define R_ARM_PREL31 42 / 32 bit PC relative. / #define R_ARM_MOVW_ABS_NC 43 / Direct 16-bit (MOVW). / #define R_ARM_MOVT_ABS 44 / Direct high 16-bit (MOVT). / #define R_ARM_MOVW_PREL_NC 45 / PC relative 16-bit (MOVW). / #define R_ARM_MOVT_PREL 46 / PC relative (MOVT). / #define R_ARM_THM_MOVW_ABS_NC 47 / Direct 16 bit (Thumb32 MOVW). / #define R_ARM_THM_MOVT_ABS 48 / Direct high 16 bit (Thumb32 MOVT). / #define R_ARM_THM_MOVW_PREL_NC 49 / PC relative 16 bit (Thumb32 MOVW). / #define R_ARM_THM_MOVT_PREL 50 / PC relative high 16 bit (Thumb32 MOVT). / #define R_ARM_THM_JUMP19 51 / PC relative 20 bit (Thumb32 B<cond>.W). / #define R_ARM_THM_JUMP6 52 / PC relative X & 0x7E (Thumb16 CBZ, CBNZ). / #define R_ARM_THM_ALU_PREL_11_0 53 / PC relative 12 bit (Thumb32 ADR.W). / #define R_ARM_THM_PC12 54 / PC relative 12 bit (Thumb32 LDR{D,SB,H,SH}). / #define R_ARM_ABS32_NOI 55 / Direct 32-bit. / #define R_ARM_REL32_NOI 56 / PC relative 32-bit. / #define R_ARM_ALU_PC_G0_NC 57 / PC relative (ADD, SUB). / #define R_ARM_ALU_PC_G0 58 / PC relative (ADD, SUB). / #define R_ARM_ALU_PC_G1_NC 59 / PC relative (ADD, SUB). / #define R_ARM_ALU_PC_G1 60 / PC relative (ADD, SUB). / #define R_ARM_ALU_PC_G2 61 / PC relative (ADD, SUB). / #define R_ARM_LDR_PC_G1 62 / PC relative (LDR,STR,LDRB,STRB). / #define R_ARM_LDR_PC_G2 63 / PC relative (LDR,STR,LDRB,STRB). / #define R_ARM_LDRS_PC_G0 64 / PC relative (STR{D,H}, LDR{D,SB,H,SH}). / #define R_ARM_LDRS_PC_G1 65 / PC relative (STR{D,H}, LDR{D,SB,H,SH}). / #define R_ARM_LDRS_PC_G2 66 / PC relative (STR{D,H}, LDR{D,SB,H,SH}). / #define R_ARM_LDC_PC_G0 67 / PC relative (LDC, STC). / #define R_ARM_LDC_PC_G1 68 / PC relative (LDC, STC). / #define R_ARM_LDC_PC_G2 69 / PC relative (LDC, STC). / #define R_ARM_ALU_SB_G0_NC 70 / Program base relative (ADD,SUB). / #define R_ARM_ALU_SB_G0 71 / Program base relative (ADD,SUB). / #define R_ARM_ALU_SB_G1_NC 72 / Program base relative (ADD,SUB). / #define R_ARM_ALU_SB_G1 73 / Program base relative (ADD,SUB). / #define R_ARM_ALU_SB_G2 74 / Program base relative (ADD,SUB). / #define R_ARM_LDR_SB_G0 75 / Program base relative (LDR, STR, LDRB, STRB). / #define R_ARM_LDR_SB_G1 76 / Program base relative (LDR, STR, LDRB, STRB). / #define R_ARM_LDR_SB_G2 77 / Program base relative (LDR, STR, LDRB, STRB). / #define R_ARM_LDRS_SB_G0 78 / Program base relative (LDR, STR, LDRB, STRB). / #define R_ARM_LDRS_SB_G1 79 / Program base relative (LDR, STR, LDRB, STRB). / #define R_ARM_LDRS_SB_G2 80 / Program base relative (LDR, STR, LDRB, STRB). / #define R_ARM_LDC_SB_G0 81 / Program base relative (LDC,STC). / #define R_ARM_LDC_SB_G1 82 / Program base relative (LDC,STC). / #define R_ARM_LDC_SB_G2 83 / Program base relative (LDC,STC). / #define R_ARM_MOVW_BREL_NC 84 / Program base relative 16 bit (MOVW). / #define R_ARM_MOVT_BREL 85 / Program base relative high 16 bit (MOVT). / #define R_ARM_MOVW_BREL 86 / Program base relative 16 bit (MOVW). / #define R_ARM_THM_MOVW_BREL_NC 87 / Program base relative 16 bit (Thumb32 MOVW). / #define R_ARM_THM_MOVT_BREL 88 / Program base relative high 16 bit (Thumb32 MOVT). / #define R_ARM_THM_MOVW_BREL 89 / Program base relative 16 bit (Thumb32 MOVW). / #define R_ARM_TLS_GOTDESC 90 #define R_ARM_TLS_CALL 91 #define R_ARM_TLS_DESCSEQ 92 / TLS relaxation. / #define R_ARM_THM_TLS_CALL 93 #define R_ARM_PLT32_ABS 94 #define R_ARM_GOT_ABS 95 / GOT entry. / #define R_ARM_GOT_PREL 96 / PC relative GOT entry. / #define R_ARM_GOT_BREL12 97 / GOT entry relative to GOT origin (LDR). / #define R_ARM_GOTOFF12 98 / 12 bit, GOT entry relative to GOT origin (LDR, STR). / #define R_ARM_GOTRELAX 99 #define R_ARM_GNU_VTENTRY 100 #define R_ARM_GNU_VTINHERIT 101 #define R_ARM_THM_PC11 102 / PC relative & 0xFFE (Thumb16 B). / #define R_ARM_THM_PC9 103 / PC relative & 0x1FE (Thumb16 B/B<cond>). / #define R_ARM_TLS_GD32 104 / PC-rel 32 bit for global dynamic thread local data / #define R_ARM_TLS_LDM32 105 / PC-rel 32 bit for local dynamic thread local data / #define R_ARM_TLS_LDO32 106 / 32 bit offset relative to TLS block / #define R_ARM_TLS_IE32 107 / PC-rel 32 bit for GOT entry of static TLS block offset / #define R_ARM_TLS_LE32 108 / 32 bit offset relative to static TLS block / #define R_ARM_TLS_LDO12 109 / 12 bit relative to TLS block (LDR, STR). / #define R_ARM_TLS_LE12 110 / 12 bit relative to static TLS block (LDR, STR). / #define R_ARM_TLS_IE12GP 111 / 12 bit GOT entry relative to GOT origin (LDR). / #define R_ARM_ME_TOO 128 / Obsolete. / #define R_ARM_THM_TLS_DESCSEQ 129 #define R_ARM_THM_TLS_DESCSEQ16 129 #define R_ARM_THM_TLS_DESCSEQ32 130 #define R_ARM_THM_GOT_BREL12 131 / GOT entry relative to GOT origin, 12 bit (Thumb32 LDR). / #define R_ARM_IRELATIVE 160 #define R_ARM_RXPC25 249 #define R_ARM_RSBREL32 250 #define R_ARM_THM_RPC22 251 #define R_ARM_RREL32 252 #define R_ARM_RABS22 253 #define R_ARM_RPC24 254 #define R_ARM_RBASE 255 / Keep this the last entry. / #define R_ARM_NUM 256 / C-SKY / #define R_CKCORE_NONE 0 / no reloc / #define R_CKCORE_ADDR32 1 / direct 32 bit (S + A) / #define R_CKCORE_PCRELIMM8BY4 2 / disp ((S + A - P) >> 2) & 0xff / #define R_CKCORE_PCRELIMM11BY2 3 / disp ((S + A - P) >> 1) & 0x7ff / #define R_CKCORE_PCREL32 5 / 32-bit rel (S + A - P) / #define R_CKCORE_PCRELJSR_IMM11BY2 6 / disp ((S + A - P) >>1) & 0x7ff / #define R_CKCORE_RELATIVE 9 / 32 bit adjust program base(B + A)/ #define R_CKCORE_COPY 10 / 32 bit adjust by program base / #define R_CKCORE_GLOB_DAT 11 / off between got and sym (S) / #define R_CKCORE_JUMP_SLOT 12 / PLT entry (S) / #define R_CKCORE_GOTOFF 13 / offset to GOT (S + A - GOT) / #define R_CKCORE_GOTPC 14 / PC offset to GOT (GOT + A - P) / #define R_CKCORE_GOT32 15 / 32 bit GOT entry (G) / #define R_CKCORE_PLT32 16 / 32 bit PLT entry (G) / #define R_CKCORE_ADDRGOT 17 / GOT entry in GLOB_DAT (GOT + G) / #define R_CKCORE_ADDRPLT 18 / PLT entry in GLOB_DAT (GOT + G) / #define R_CKCORE_PCREL_IMM26BY2 19 / ((S + A - P) >> 1) & 0x3ffffff / #define R_CKCORE_PCREL_IMM16BY2 20 / disp ((S + A - P) >> 1) & 0xffff / #define R_CKCORE_PCREL_IMM16BY4 21 / disp ((S + A - P) >> 2) & 0xffff / #define R_CKCORE_PCREL_IMM10BY2 22 / disp ((S + A - P) >> 1) & 0x3ff / #define R_CKCORE_PCREL_IMM10BY4 23 / disp ((S + A - P) >> 2) & 0x3ff / #define R_CKCORE_ADDR_HI16 24 / high & low 16 bit ADDR / / ((S + A) >> 16) & 0xffff / #define R_CKCORE_ADDR_LO16 25 / (S + A) & 0xffff / #define R_CKCORE_GOTPC_HI16 26 / high & low 16 bit GOTPC / / ((GOT + A - P) >> 16) & 0xffff / #define R_CKCORE_GOTPC_LO16 27 / (GOT + A - P) & 0xffff / #define R_CKCORE_GOTOFF_HI16 28 / high & low 16 bit GOTOFF / / ((S + A - GOT) >> 16) & 0xffff / #define R_CKCORE_GOTOFF_LO16 29 / (S + A - GOT) & 0xffff / #define R_CKCORE_GOT12 30 / 12 bit disp GOT entry (G) / #define R_CKCORE_GOT_HI16 31 / high & low 16 bit GOT / / (G >> 16) & 0xffff / #define R_CKCORE_GOT_LO16 32 / (G & 0xffff) / #define R_CKCORE_PLT12 33 / 12 bit disp PLT entry (G) / #define R_CKCORE_PLT_HI16 34 / high & low 16 bit PLT / / (G >> 16) & 0xffff / #define R_CKCORE_PLT_LO16 35 / G & 0xffff / #define R_CKCORE_ADDRGOT_HI16 36 / high & low 16 bit ADDRGOT / / (GOT + G * 4) & 0xffff / #define R_CKCORE_ADDRGOT_LO16 37 / (GOT + G * 4) & 0xffff / #define R_CKCORE_ADDRPLT_HI16 38 / high & low 16 bit ADDRPLT / / ((GOT + G * 4) >> 16) & 0xFFFF / #define R_CKCORE_ADDRPLT_LO16 39 / (GOT+G4) & 0xffff / #define R_CKCORE_PCREL_JSR_IMM26BY2 40 /* disp ((S+A-P) >>1) & x3ffffff / #define R_CKCORE_TOFFSET_LO16 41 / (S+A-BTEXT) & 0xffff / #define R_CKCORE_DOFFSET_LO16 42 / (S+A-BTEXT) & 0xffff / #define R_CKCORE_PCREL_IMM18BY2 43 / disp ((S+A-P) >>1) & 0x3ffff / #define R_CKCORE_DOFFSET_IMM18 44 / disp (S+A-BDATA) & 0x3ffff / #define R_CKCORE_DOFFSET_IMM18BY2 45 / disp ((S+A-BDATA)>>1) & 0x3ffff / #define R_CKCORE_DOFFSET_IMM18BY4 46 / disp ((S+A-BDATA)>>2) & 0x3ffff / #define R_CKCORE_GOT_IMM18BY4 48 / disp (G >> 2) / #define R_CKCORE_PLT_IMM18BY4 49 / disp (G >> 2) / #define R_CKCORE_PCREL_IMM7BY4 50 / disp ((S+A-P) >>2) & 0x7f / #define R_CKCORE_TLS_LE32 51 / 32 bit offset to TLS block / #define R_CKCORE_TLS_IE32 52 #define R_CKCORE_TLS_GD32 53 #define R_CKCORE_TLS_LDM32 54 #define R_CKCORE_TLS_LDO32 55 #define R_CKCORE_TLS_DTPMOD32 56 #define R_CKCORE_TLS_DTPOFF32 57 #define R_CKCORE_TLS_TPOFF32 58 / C-SKY elf header definition. / #define EF_CSKY_ABIMASK 0XF0000000 #define EF_CSKY_OTHER 0X0FFF0000 #define EF_CSKY_PROCESSOR 0X0000FFFF #define EF_CSKY_ABIV1 0X10000000 #define EF_CSKY_ABIV2 0X20000000 / C-SKY attributes section. / #define SHT_CSKY_ATTRIBUTES (SHT_LOPROC + 1) / IA-64 specific declarations. / / Processor specific flags for the Ehdr e_flags field. / #define EF_IA_64_MASKOS 0x0000000f / os-specific flags / #define EF_IA_64_ABI64 0x00000010 / 64-bit ABI / #define EF_IA_64_ARCH 0xff000000 / arch. version mask / / Processor specific values for the Phdr p_type field. / #define PT_IA_64_ARCHEXT (PT_LOPROC + 0) / arch extension bits / #define PT_IA_64_UNWIND (PT_LOPROC + 1) / ia64 unwind bits / #define PT_IA_64_HP_OPT_ANOT (PT_LOOS + 0x12) #define PT_IA_64_HP_HSL_ANOT (PT_LOOS + 0x13) #define PT_IA_64_HP_STACK (PT_LOOS + 0x14) / Processor specific flags for the Phdr p_flags field. / #define PF_IA_64_NORECOV 0x80000000 / spec insns w/o recovery / / Processor specific values for the Shdr sh_type field. / #define SHT_IA_64_EXT (SHT_LOPROC + 0) / extension bits / #define SHT_IA_64_UNWIND (SHT_LOPROC + 1) / unwind bits / / Processor specific flags for the Shdr sh_flags field. / #define SHF_IA_64_SHORT 0x10000000 / section near gp / #define SHF_IA_64_NORECOV 0x20000000 / spec insns w/o recovery / / Processor specific values for the Dyn d_tag field. / #define DT_IA_64_PLT_RESERVE (DT_LOPROC + 0) #define DT_IA_64_NUM 1 / IA-64 relocations. / #define R_IA64_NONE 0x00 / none / #define R_IA64_IMM14 0x21 / symbol + addend, add imm14 / #define R_IA64_IMM22 0x22 / symbol + addend, add imm22 / #define R_IA64_IMM64 0x23 / symbol + addend, mov imm64 / #define R_IA64_DIR32MSB 0x24 / symbol + addend, data4 MSB / #define R_IA64_DIR32LSB 0x25 / symbol + addend, data4 LSB / #define R_IA64_DIR64MSB 0x26 / symbol + addend, data8 MSB / #define R_IA64_DIR64LSB 0x27 / symbol + addend, data8 LSB / #define R_IA64_GPREL22 0x2a / @gprel(sym + add), add imm22 / #define R_IA64_GPREL64I 0x2b / @gprel(sym + add), mov imm64 / #define R_IA64_GPREL32MSB 0x2c / @gprel(sym + add), data4 MSB / #define R_IA64_GPREL32LSB 0x2d / @gprel(sym + add), data4 LSB / #define R_IA64_GPREL64MSB 0x2e / @gprel(sym + add), data8 MSB / #define R_IA64_GPREL64LSB 0x2f / @gprel(sym + add), data8 LSB / #define R_IA64_LTOFF22 0x32 / @ltoff(sym + add), add imm22 / #define R_IA64_LTOFF64I 0x33 / @ltoff(sym + add), mov imm64 / #define R_IA64_PLTOFF22 0x3a / @pltoff(sym + add), add imm22 / #define R_IA64_PLTOFF64I 0x3b / @pltoff(sym + add), mov imm64 / #define R_IA64_PLTOFF64MSB 0x3e / @pltoff(sym + add), data8 MSB / #define R_IA64_PLTOFF64LSB 0x3f / @pltoff(sym + add), data8 LSB / #define R_IA64_FPTR64I 0x43 / @fptr(sym + add), mov imm64 / #define R_IA64_FPTR32MSB 0x44 / @fptr(sym + add), data4 MSB / #define R_IA64_FPTR32LSB 0x45 / @fptr(sym + add), data4 LSB / #define R_IA64_FPTR64MSB 0x46 / @fptr(sym + add), data8 MSB / #define R_IA64_FPTR64LSB 0x47 / @fptr(sym + add), data8 LSB / #define R_IA64_PCREL60B 0x48 / @pcrel(sym + add), brl / #define R_IA64_PCREL21B 0x49 / @pcrel(sym + add), ptb, call / #define R_IA64_PCREL21M 0x4a / @pcrel(sym + add), chk.s / #define R_IA64_PCREL21F 0x4b / @pcrel(sym + add), fchkf / #define R_IA64_PCREL32MSB 0x4c / @pcrel(sym + add), data4 MSB / #define R_IA64_PCREL32LSB 0x4d / @pcrel(sym + add), data4 LSB / #define R_IA64_PCREL64MSB 0x4e / @pcrel(sym + add), data8 MSB / #define R_IA64_PCREL64LSB 0x4f / @pcrel(sym + add), data8 LSB / #define R_IA64_LTOFF_FPTR22 0x52 / @ltoff(@fptr(s+a)), imm22 / #define R_IA64_LTOFF_FPTR64I 0x53 / @ltoff(@fptr(s+a)), imm64 / #define R_IA64_LTOFF_FPTR32MSB 0x54 / @ltoff(@fptr(s+a)), data4 MSB / #define R_IA64_LTOFF_FPTR32LSB 0x55 / @ltoff(@fptr(s+a)), data4 LSB / #define R_IA64_LTOFF_FPTR64MSB 0x56 / @ltoff(@fptr(s+a)), data8 MSB / #define R_IA64_LTOFF_FPTR64LSB 0x57 / @ltoff(@fptr(s+a)), data8 LSB / #define R_IA64_SEGREL32MSB 0x5c / @segrel(sym + add), data4 MSB / #define R_IA64_SEGREL32LSB 0x5d / @segrel(sym + add), data4 LSB / #define R_IA64_SEGREL64MSB 0x5e / @segrel(sym + add), data8 MSB / #define R_IA64_SEGREL64LSB 0x5f / @segrel(sym + add), data8 LSB / #define R_IA64_SECREL32MSB 0x64 / @secrel(sym + add), data4 MSB / #define R_IA64_SECREL32LSB 0x65 / @secrel(sym + add), data4 LSB / #define R_IA64_SECREL64MSB 0x66 / @secrel(sym + add), data8 MSB / #define R_IA64_SECREL64LSB 0x67 / @secrel(sym + add), data8 LSB / #define R_IA64_REL32MSB 0x6c / data 4 + REL / #define R_IA64_REL32LSB 0x6d / data 4 + REL / #define R_IA64_REL64MSB 0x6e / data 8 + REL / #define R_IA64_REL64LSB 0x6f / data 8 + REL / #define R_IA64_LTV32MSB 0x74 / symbol + addend, data4 MSB / #define R_IA64_LTV32LSB 0x75 / symbol + addend, data4 LSB / #define R_IA64_LTV64MSB 0x76 / symbol + addend, data8 MSB / #define R_IA64_LTV64LSB 0x77 / symbol + addend, data8 LSB / #define R_IA64_PCREL21BI 0x79 / @pcrel(sym + add), 21bit inst / #define R_IA64_PCREL22 0x7a / @pcrel(sym + add), 22bit inst / #define R_IA64_PCREL64I 0x7b / @pcrel(sym + add), 64bit inst / #define R_IA64_IPLTMSB 0x80 / dynamic reloc, imported PLT, MSB / #define R_IA64_IPLTLSB 0x81 / dynamic reloc, imported PLT, LSB / #define R_IA64_COPY 0x84 / copy relocation / #define R_IA64_SUB 0x85 / Addend and symbol difference / #define R_IA64_LTOFF22X 0x86 / LTOFF22, relaxable. / #define R_IA64_LDXMOV 0x87 / Use of LTOFF22X. / #define R_IA64_TPREL14 0x91 / @tprel(sym + add), imm14 / #define R_IA64_TPREL22 0x92 / @tprel(sym + add), imm22 / #define R_IA64_TPREL64I 0x93 / @tprel(sym + add), imm64 / #define R_IA64_TPREL64MSB 0x96 / @tprel(sym + add), data8 MSB / #define R_IA64_TPREL64LSB 0x97 / @tprel(sym + add), data8 LSB / #define R_IA64_LTOFF_TPREL22 0x9a / @ltoff(@tprel(s+a)), imm2 / #define R_IA64_DTPMOD64MSB 0xa6 / @dtpmod(sym + add), data8 MSB / #define R_IA64_DTPMOD64LSB 0xa7 / @dtpmod(sym + add), data8 LSB / #define R_IA64_LTOFF_DTPMOD22 0xaa / @ltoff(@dtpmod(sym + add)), imm22 / #define R_IA64_DTPREL14 0xb1 / @dtprel(sym + add), imm14 / #define R_IA64_DTPREL22 0xb2 / @dtprel(sym + add), imm22 / #define R_IA64_DTPREL64I 0xb3 / @dtprel(sym + add), imm64 / #define R_IA64_DTPREL32MSB 0xb4 / @dtprel(sym + add), data4 MSB / #define R_IA64_DTPREL32LSB 0xb5 / @dtprel(sym + add), data4 LSB / #define R_IA64_DTPREL64MSB 0xb6 / @dtprel(sym + add), data8 MSB / #define R_IA64_DTPREL64LSB 0xb7 / @dtprel(sym + add), data8 LSB / #define R_IA64_LTOFF_DTPREL22 0xba / @ltoff(@dtprel(s+a)), imm22 / / SH specific declarations / / Processor specific flags for the ELF header e_flags field. / #define EF_SH_MACH_MASK 0x1f #define EF_SH_UNKNOWN 0x0 #define EF_SH1 0x1 #define EF_SH2 0x2 #define EF_SH3 0x3 #define EF_SH_DSP 0x4 #define EF_SH3_DSP 0x5 #define EF_SH4AL_DSP 0x6 #define EF_SH3E 0x8 #define EF_SH4 0x9 #define EF_SH2E 0xb #define EF_SH4A 0xc #define EF_SH2A 0xd #define EF_SH4_NOFPU 0x10 #define EF_SH4A_NOFPU 0x11 #define EF_SH4_NOMMU_NOFPU 0x12 #define EF_SH2A_NOFPU 0x13 #define EF_SH3_NOMMU 0x14 #define EF_SH2A_SH4_NOFPU 0x15 #define EF_SH2A_SH3_NOFPU 0x16 #define EF_SH2A_SH4 0x17 #define EF_SH2A_SH3E 0x18 / SH relocs. / #define R_SH_NONE 0 #define R_SH_DIR32 1 #define R_SH_REL32 2 #define R_SH_DIR8WPN 3 #define R_SH_IND12W 4 #define R_SH_DIR8WPL 5 #define R_SH_DIR8WPZ 6 #define R_SH_DIR8BP 7 #define R_SH_DIR8W 8 #define R_SH_DIR8L 9 #define R_SH_SWITCH16 25 #define R_SH_SWITCH32 26 #define R_SH_USES 27 #define R_SH_COUNT 28 #define R_SH_ALIGN 29 #define R_SH_CODE 30 #define R_SH_DATA 31 #define R_SH_LABEL 32 #define R_SH_SWITCH8 33 #define R_SH_GNU_VTINHERIT 34 #define R_SH_GNU_VTENTRY 35 #define R_SH_TLS_GD_32 144 #define R_SH_TLS_LD_32 145 #define R_SH_TLS_LDO_32 146 #define R_SH_TLS_IE_32 147 #define R_SH_TLS_LE_32 148 #define R_SH_TLS_DTPMOD32 149 #define R_SH_TLS_DTPOFF32 150 #define R_SH_TLS_TPOFF32 151 #define R_SH_GOT32 160 #define R_SH_PLT32 161 #define R_SH_COPY 162 #define R_SH_GLOB_DAT 163 #define R_SH_JMP_SLOT 164 #define R_SH_RELATIVE 165 #define R_SH_GOTOFF 166 #define R_SH_GOTPC 167 / Keep this the last entry. / #define R_SH_NUM 256 / S/390 specific definitions. / / Valid values for the e_flags field. / #define EF_S390_HIGH_GPRS 0x00000001 / High GPRs kernel facility needed. / / Additional s390 relocs / #define R_390_NONE 0 / No reloc. / #define R_390_8 1 / Direct 8 bit. / #define R_390_12 2 / Direct 12 bit. / #define R_390_16 3 / Direct 16 bit. / #define R_390_32 4 / Direct 32 bit. / #define R_390_PC32 5 / PC relative 32 bit. / #define R_390_GOT12 6 / 12 bit GOT offset. / #define R_390_GOT32 7 / 32 bit GOT offset. / #define R_390_PLT32 8 / 32 bit PC relative PLT address. / #define R_390_COPY 9 / Copy symbol at runtime. / #define R_390_GLOB_DAT 10 / Create GOT entry. / #define R_390_JMP_SLOT 11 / Create PLT entry. / #define R_390_RELATIVE 12 / Adjust by program base. / #define R_390_GOTOFF32 13 / 32 bit offset to GOT. / #define R_390_GOTPC 14 / 32 bit PC relative offset to GOT. / #define R_390_GOT16 15 / 16 bit GOT offset. / #define R_390_PC16 16 / PC relative 16 bit. / #define R_390_PC16DBL 17 / PC relative 16 bit shifted by 1. / #define R_390_PLT16DBL 18 / 16 bit PC rel. PLT shifted by 1. / #define R_390_PC32DBL 19 / PC relative 32 bit shifted by 1. / #define R_390_PLT32DBL 20 / 32 bit PC rel. PLT shifted by 1. / #define R_390_GOTPCDBL 21 / 32 bit PC rel. GOT shifted by 1. / #define R_390_64 22 / Direct 64 bit. / #define R_390_PC64 23 / PC relative 64 bit. / #define R_390_GOT64 24 / 64 bit GOT offset. / #define R_390_PLT64 25 / 64 bit PC relative PLT address. / #define R_390_GOTENT 26 / 32 bit PC rel. to GOT entry >> 1. / #define R_390_GOTOFF16 27 / 16 bit offset to GOT. / #define R_390_GOTOFF64 28 / 64 bit offset to GOT. / #define R_390_GOTPLT12 29 / 12 bit offset to jump slot. / #define R_390_GOTPLT16 30 / 16 bit offset to jump slot. / #define R_390_GOTPLT32 31 / 32 bit offset to jump slot. / #define R_390_GOTPLT64 32 / 64 bit offset to jump slot. / #define R_390_GOTPLTENT 33 / 32 bit rel. offset to jump slot. / #define R_390_PLTOFF16 34 / 16 bit offset from GOT to PLT. / #define R_390_PLTOFF32 35 / 32 bit offset from GOT to PLT. / #define R_390_PLTOFF64 36 / 16 bit offset from GOT to PLT. / #define R_390_TLS_LOAD 37 / Tag for load insn in TLS code. / #define R_390_TLS_GDCALL 38 / Tag for function call in general dynamic TLS code. / #define R_390_TLS_LDCALL 39 / Tag for function call in local dynamic TLS code. / #define R_390_TLS_GD32 40 / Direct 32 bit for general dynamic thread local data. / #define R_390_TLS_GD64 41 / Direct 64 bit for general dynamic thread local data. / #define R_390_TLS_GOTIE12 42 / 12 bit GOT offset for static TLS block offset. / #define R_390_TLS_GOTIE32 43 / 32 bit GOT offset for static TLS block offset. / #define R_390_TLS_GOTIE64 44 / 64 bit GOT offset for static TLS block offset. / #define R_390_TLS_LDM32 45 / Direct 32 bit for local dynamic thread local data in LE code. / #define R_390_TLS_LDM64 46 / Direct 64 bit for local dynamic thread local data in LE code. / #define R_390_TLS_IE32 47 / 32 bit address of GOT entry for negated static TLS block offset. / #define R_390_TLS_IE64 48 / 64 bit address of GOT entry for negated static TLS block offset. / #define R_390_TLS_IEENT 49 / 32 bit rel. offset to GOT entry for negated static TLS block offset. / #define R_390_TLS_LE32 50 / 32 bit negated offset relative to static TLS block. / #define R_390_TLS_LE64 51 / 64 bit negated offset relative to static TLS block. / #define R_390_TLS_LDO32 52 / 32 bit offset relative to TLS block. / #define R_390_TLS_LDO64 53 / 64 bit offset relative to TLS block. / #define R_390_TLS_DTPMOD 54 / ID of module containing symbol. / #define R_390_TLS_DTPOFF 55 / Offset in TLS block. / #define R_390_TLS_TPOFF 56 / Negated offset in static TLS block. / #define R_390_20 57 / Direct 20 bit. / #define R_390_GOT20 58 / 20 bit GOT offset. / #define R_390_GOTPLT20 59 / 20 bit offset to jump slot. / #define R_390_TLS_GOTIE20 60 / 20 bit GOT offset for static TLS block offset. / #define R_390_IRELATIVE 61 / STT_GNU_IFUNC relocation. / / Keep this the last entry. / #define R_390_NUM 62 / CRIS relocations. / #define R_CRIS_NONE 0 #define R_CRIS_8 1 #define R_CRIS_16 2 #define R_CRIS_32 3 #define R_CRIS_8_PCREL 4 #define R_CRIS_16_PCREL 5 #define R_CRIS_32_PCREL 6 #define R_CRIS_GNU_VTINHERIT 7 #define R_CRIS_GNU_VTENTRY 8 #define R_CRIS_COPY 9 #define R_CRIS_GLOB_DAT 10 #define R_CRIS_JUMP_SLOT 11 #define R_CRIS_RELATIVE 12 #define R_CRIS_16_GOT 13 #define R_CRIS_32_GOT 14 #define R_CRIS_16_GOTPLT 15 #define R_CRIS_32_GOTPLT 16 #define R_CRIS_32_GOTREL 17 #define R_CRIS_32_PLT_GOTREL 18 #define R_CRIS_32_PLT_PCREL 19 #define R_CRIS_NUM 20 / AMD x86-64 relocations. / #define R_X86_64_NONE 0 / No reloc / #define R_X86_64_64 1 / Direct 64 bit / #define R_X86_64_PC32 2 / PC relative 32 bit signed / #define R_X86_64_GOT32 3 / 32 bit GOT entry / #define R_X86_64_PLT32 4 / 32 bit PLT address / #define R_X86_64_COPY 5 / Copy symbol at runtime / #define R_X86_64_GLOB_DAT 6 / Create GOT entry / #define R_X86_64_JUMP_SLOT 7 / Create PLT entry / #define R_X86_64_RELATIVE 8 / Adjust by program base / #define R_X86_64_GOTPCREL 9 / 32 bit signed PC relative offset to GOT / #define R_X86_64_32 10 / Direct 32 bit zero extended / #define R_X86_64_32S 11 / Direct 32 bit sign extended / #define R_X86_64_16 12 / Direct 16 bit zero extended / #define R_X86_64_PC16 13 / 16 bit sign extended pc relative / #define R_X86_64_8 14 / Direct 8 bit sign extended / #define R_X86_64_PC8 15 / 8 bit sign extended pc relative / #define R_X86_64_DTPMOD64 16 / ID of module containing symbol / #define R_X86_64_DTPOFF64 17 / Offset in module's TLS block / #define R_X86_64_TPOFF64 18 / Offset in initial TLS block / #define R_X86_64_TLSGD 19 / 32 bit signed PC relative offset to two GOT entries for GD symbol / #define R_X86_64_TLSLD 20 / 32 bit signed PC relative offset to two GOT entries for LD symbol / #define R_X86_64_DTPOFF32 21 / Offset in TLS block / #define R_X86_64_GOTTPOFF 22 / 32 bit signed PC relative offset to GOT entry for IE symbol / #define R_X86_64_TPOFF32 23 / Offset in initial TLS block / #define R_X86_64_PC64 24 / PC relative 64 bit / #define R_X86_64_GOTOFF64 25 / 64 bit offset to GOT / #define R_X86_64_GOTPC32 26 / 32 bit signed pc relative offset to GOT / #define R_X86_64_GOT64 27 / 64-bit GOT entry offset / #define R_X86_64_GOTPCREL64 28 / 64-bit PC relative offset to GOT entry / #define R_X86_64_GOTPC64 29 / 64-bit PC relative offset to GOT / #define R_X86_64_GOTPLT64 30 / like GOT64, says PLT entry needed / #define R_X86_64_PLTOFF64 31 / 64-bit GOT relative offset to PLT entry / #define R_X86_64_SIZE32 32 / Size of symbol plus 32-bit addend / #define R_X86_64_SIZE64 33 / Size of symbol plus 64-bit addend / #define R_X86_64_GOTPC32_TLSDESC 34 / GOT offset for TLS descriptor. / #define R_X86_64_TLSDESC_CALL 35 / Marker for call through TLS descriptor. / #define R_X86_64_TLSDESC 36 / TLS descriptor. / #define R_X86_64_IRELATIVE 37 / Adjust indirectly by program base / #define R_X86_64_RELATIVE64 38 / 64-bit adjust by program base / / 39 Reserved was R_X86_64_PC32_BND / / 40 Reserved was R_X86_64_PLT32_BND / #define R_X86_64_GOTPCRELX 41 / Load from 32 bit signed pc relative offset to GOT entry without REX prefix, relaxable. / #define R_X86_64_REX_GOTPCRELX 42 / Load from 32 bit signed pc relative offset to GOT entry with REX prefix, relaxable. / #define R_X86_64_NUM 43 / x86-64 sh_type values. / #define SHT_X86_64_UNWIND 0x70000001 / Unwind information. / / AM33 relocations. / #define R_MN10300_NONE 0 / No reloc. / #define R_MN10300_32 1 / Direct 32 bit. / #define R_MN10300_16 2 / Direct 16 bit. / #define R_MN10300_8 3 / Direct 8 bit. / #define R_MN10300_PCREL32 4 / PC-relative 32-bit. / #define R_MN10300_PCREL16 5 / PC-relative 16-bit signed. / #define R_MN10300_PCREL8 6 / PC-relative 8-bit signed. / #define R_MN10300_GNU_VTINHERIT 7 / Ancient C++ vtable garbage... / #define R_MN10300_GNU_VTENTRY 8 / ... collection annotation. / #define R_MN10300_24 9 / Direct 24 bit. / #define R_MN10300_GOTPC32 10 / 32-bit PCrel offset to GOT. / #define R_MN10300_GOTPC16 11 / 16-bit PCrel offset to GOT. / #define R_MN10300_GOTOFF32 12 / 32-bit offset from GOT. / #define R_MN10300_GOTOFF24 13 / 24-bit offset from GOT. / #define R_MN10300_GOTOFF16 14 / 16-bit offset from GOT. / #define R_MN10300_PLT32 15 / 32-bit PCrel to PLT entry. / #define R_MN10300_PLT16 16 / 16-bit PCrel to PLT entry. / #define R_MN10300_GOT32 17 / 32-bit offset to GOT entry. / #define R_MN10300_GOT24 18 / 24-bit offset to GOT entry. / #define R_MN10300_GOT16 19 / 16-bit offset to GOT entry. / #define R_MN10300_COPY 20 / Copy symbol at runtime. / #define R_MN10300_GLOB_DAT 21 / Create GOT entry. / #define R_MN10300_JMP_SLOT 22 / Create PLT entry. / #define R_MN10300_RELATIVE 23 / Adjust by program base. / #define R_MN10300_TLS_GD 24 / 32-bit offset for global dynamic. / #define R_MN10300_TLS_LD 25 / 32-bit offset for local dynamic. / #define R_MN10300_TLS_LDO 26 / Module-relative offset. / #define R_MN10300_TLS_GOTIE 27 / GOT offset for static TLS block offset. / #define R_MN10300_TLS_IE 28 / GOT address for static TLS block offset. / #define R_MN10300_TLS_LE 29 / Offset relative to static TLS block. / #define R_MN10300_TLS_DTPMOD 30 / ID of module containing symbol. / #define R_MN10300_TLS_DTPOFF 31 / Offset in module TLS block. / #define R_MN10300_TLS_TPOFF 32 / Offset in static TLS block. / #define R_MN10300_SYM_DIFF 33 / Adjustment for next reloc as needed by linker relaxation. / #define R_MN10300_ALIGN 34 / Alignment requirement for linker relaxation. / #define R_MN10300_NUM 35 / M32R relocs. / #define R_M32R_NONE 0 / No reloc. / #define R_M32R_16 1 / Direct 16 bit. / #define R_M32R_32 2 / Direct 32 bit. / #define R_M32R_24 3 / Direct 24 bit. / #define R_M32R_10_PCREL 4 / PC relative 10 bit shifted. / #define R_M32R_18_PCREL 5 / PC relative 18 bit shifted. / #define R_M32R_26_PCREL 6 / PC relative 26 bit shifted. / #define R_M32R_HI16_ULO 7 / High 16 bit with unsigned low. / #define R_M32R_HI16_SLO 8 / High 16 bit with signed low. / #define R_M32R_LO16 9 / Low 16 bit. / #define R_M32R_SDA16 10 / 16 bit offset in SDA. / #define R_M32R_GNU_VTINHERIT 11 #define R_M32R_GNU_VTENTRY 12 / M32R relocs use SHT_RELA. / #define R_M32R_16_RELA 33 / Direct 16 bit. / #define R_M32R_32_RELA 34 / Direct 32 bit. / #define R_M32R_24_RELA 35 / Direct 24 bit. / #define R_M32R_10_PCREL_RELA 36 / PC relative 10 bit shifted. / #define R_M32R_18_PCREL_RELA 37 / PC relative 18 bit shifted. / #define R_M32R_26_PCREL_RELA 38 / PC relative 26 bit shifted. / #define R_M32R_HI16_ULO_RELA 39 / High 16 bit with unsigned low / #define R_M32R_HI16_SLO_RELA 40 / High 16 bit with signed low / #define R_M32R_LO16_RELA 41 / Low 16 bit / #define R_M32R_SDA16_RELA 42 / 16 bit offset in SDA / #define R_M32R_RELA_GNU_VTINHERIT 43 #define R_M32R_RELA_GNU_VTENTRY 44 #define R_M32R_REL32 45 / PC relative 32 bit. / #define R_M32R_GOT24 48 / 24 bit GOT entry / #define R_M32R_26_PLTREL 49 / 26 bit PC relative to PLT shifted / #define R_M32R_COPY 50 / Copy symbol at runtime / #define R_M32R_GLOB_DAT 51 / Create GOT entry / #define R_M32R_JMP_SLOT 52 / Create PLT entry / #define R_M32R_RELATIVE 53 / Adjust by program base / #define R_M32R_GOTOFF 54 / 24 bit offset to GOT / #define R_M32R_GOTPC24 55 / 24 bit PC relative offset to GOT / #define R_M32R_GOT16_HI_ULO 56 / High 16 bit GOT entry with unsigned low / #define R_M32R_GOT16_HI_SLO 57 / High 16 bit GOT entry with signed low / #define R_M32R_GOT16_LO 58 / Low 16 bit GOT entry / #define R_M32R_GOTPC_HI_ULO 59 / High 16 bit PC relative offset to GOT with unsigned low / #define R_M32R_GOTPC_HI_SLO 60 / High 16 bit PC relative offset to GOT with signed low / #define R_M32R_GOTPC_LO 61 / Low 16 bit PC relative offset to GOT / #define R_M32R_GOTOFF_HI_ULO 62 / High 16 bit offset to GOT with unsigned low / #define R_M32R_GOTOFF_HI_SLO 63 / High 16 bit offset to GOT with signed low / #define R_M32R_GOTOFF_LO 64 / Low 16 bit offset to GOT / #define R_M32R_NUM 256 / Keep this the last entry. / / MicroBlaze relocations / #define R_MICROBLAZE_NONE 0 / No reloc. / #define R_MICROBLAZE_32 1 / Direct 32 bit. / #define R_MICROBLAZE_32_PCREL 2 / PC relative 32 bit. / #define R_MICROBLAZE_64_PCREL 3 / PC relative 64 bit. / #define R_MICROBLAZE_32_PCREL_LO 4 / Low 16 bits of PCREL32. / #define R_MICROBLAZE_64 5 / Direct 64 bit. / #define R_MICROBLAZE_32_LO 6 / Low 16 bit. / #define R_MICROBLAZE_SRO32 7 / Read-only small data area. / #define R_MICROBLAZE_SRW32 8 / Read-write small data area. / #define R_MICROBLAZE_64_NONE 9 / No reloc. / #define R_MICROBLAZE_32_SYM_OP_SYM 10 / Symbol Op Symbol relocation. / #define R_MICROBLAZE_GNU_VTINHERIT 11 / GNU C++ vtable hierarchy. / #define R_MICROBLAZE_GNU_VTENTRY 12 / GNU C++ vtable member usage. / #define R_MICROBLAZE_GOTPC_64 13 / PC-relative GOT offset. / #define R_MICROBLAZE_GOT_64 14 / GOT entry offset. / #define R_MICROBLAZE_PLT_64 15 / PLT offset (PC-relative). / #define R_MICROBLAZE_REL 16 / Adjust by program base. / #define R_MICROBLAZE_JUMP_SLOT 17 / Create PLT entry. / #define R_MICROBLAZE_GLOB_DAT 18 / Create GOT entry. / #define R_MICROBLAZE_GOTOFF_64 19 / 64 bit offset to GOT. / #define R_MICROBLAZE_GOTOFF_32 20 / 32 bit offset to GOT. / #define R_MICROBLAZE_COPY 21 / Runtime copy. / #define R_MICROBLAZE_TLS 22 / TLS Reloc. / #define R_MICROBLAZE_TLSGD 23 / TLS General Dynamic. / #define R_MICROBLAZE_TLSLD 24 / TLS Local Dynamic. / #define R_MICROBLAZE_TLSDTPMOD32 25 / TLS Module ID. / #define R_MICROBLAZE_TLSDTPREL32 26 / TLS Offset Within TLS Block. / #define R_MICROBLAZE_TLSDTPREL64 27 / TLS Offset Within TLS Block. / #define R_MICROBLAZE_TLSGOTTPREL32 28 / TLS Offset From Thread Pointer. / #define R_MICROBLAZE_TLSTPREL32 29 / TLS Offset From Thread Pointer. / / Legal values for d_tag (dynamic entry type). / #define DT_NIOS2_GP 0x70000002 / Address of _gp. / / Nios II relocations. / #define R_NIOS2_NONE 0 / No reloc. / #define R_NIOS2_S16 1 / Direct signed 16 bit. / #define R_NIOS2_U16 2 / Direct unsigned 16 bit. / #define R_NIOS2_PCREL16 3 / PC relative 16 bit. / #define R_NIOS2_CALL26 4 / Direct call. / #define R_NIOS2_IMM5 5 / 5 bit constant expression. / #define R_NIOS2_CACHE_OPX 6 / 5 bit expression, shift 22. / #define R_NIOS2_IMM6 7 / 6 bit constant expression. / #define R_NIOS2_IMM8 8 / 8 bit constant expression. / #define R_NIOS2_HI16 9 / High 16 bit. / #define R_NIOS2_LO16 10 / Low 16 bit. / #define R_NIOS2_HIADJ16 11 / High 16 bit, adjusted. / #define R_NIOS2_BFD_RELOC_32 12 / 32 bit symbol value + addend. / #define R_NIOS2_BFD_RELOC_16 13 / 16 bit symbol value + addend. / #define R_NIOS2_BFD_RELOC_8 14 / 8 bit symbol value + addend. / #define R_NIOS2_GPREL 15 / 16 bit GP pointer offset. / #define R_NIOS2_GNU_VTINHERIT 16 / GNU C++ vtable hierarchy. / #define R_NIOS2_GNU_VTENTRY 17 / GNU C++ vtable member usage. / #define R_NIOS2_UJMP 18 / Unconditional branch. / #define R_NIOS2_CJMP 19 / Conditional branch. / #define R_NIOS2_CALLR 20 / Indirect call through register. / #define R_NIOS2_ALIGN 21 / Alignment requirement for linker relaxation. / #define R_NIOS2_GOT16 22 / 16 bit GOT entry. / #define R_NIOS2_CALL16 23 / 16 bit GOT entry for function. / #define R_NIOS2_GOTOFF_LO 24 / %lo of offset to GOT pointer. / #define R_NIOS2_GOTOFF_HA 25 / %hiadj of offset to GOT pointer. / #define R_NIOS2_PCREL_LO 26 / %lo of PC relative offset. / #define R_NIOS2_PCREL_HA 27 / %hiadj of PC relative offset. / #define R_NIOS2_TLS_GD16 28 / 16 bit GOT offset for TLS GD. / #define R_NIOS2_TLS_LDM16 29 / 16 bit GOT offset for TLS LDM. / #define R_NIOS2_TLS_LDO16 30 / 16 bit module relative offset. / #define R_NIOS2_TLS_IE16 31 / 16 bit GOT offset for TLS IE. / #define R_NIOS2_TLS_LE16 32 / 16 bit LE TP-relative offset. / #define R_NIOS2_TLS_DTPMOD 33 / Module number. / #define R_NIOS2_TLS_DTPREL 34 / Module-relative offset. / #define R_NIOS2_TLS_TPREL 35 / TP-relative offset. / #define R_NIOS2_COPY 36 / Copy symbol at runtime. / #define R_NIOS2_GLOB_DAT 37 / Create GOT entry. / #define R_NIOS2_JUMP_SLOT 38 / Create PLT entry. / #define R_NIOS2_RELATIVE 39 / Adjust by program base. / #define R_NIOS2_GOTOFF 40 / 16 bit offset to GOT pointer. / #define R_NIOS2_CALL26_NOAT 41 / Direct call in .noat section. / #define R_NIOS2_GOT_LO 42 / %lo() of GOT entry. / #define R_NIOS2_GOT_HA 43 / %hiadj() of GOT entry. / #define R_NIOS2_CALL_LO 44 / %lo() of function GOT entry. / #define R_NIOS2_CALL_HA 45 / %hiadj() of function GOT entry. / / TILEPro relocations. / #define R_TILEPRO_NONE 0 / No reloc / #define R_TILEPRO_32 1 / Direct 32 bit / #define R_TILEPRO_16 2 / Direct 16 bit / #define R_TILEPRO_8 3 / Direct 8 bit / #define R_TILEPRO_32_PCREL 4 / PC relative 32 bit / #define R_TILEPRO_16_PCREL 5 / PC relative 16 bit / #define R_TILEPRO_8_PCREL 6 / PC relative 8 bit / #define R_TILEPRO_LO16 7 / Low 16 bit / #define R_TILEPRO_HI16 8 / High 16 bit / #define R_TILEPRO_HA16 9 / High 16 bit, adjusted / #define R_TILEPRO_COPY 10 / Copy relocation / #define R_TILEPRO_GLOB_DAT 11 / Create GOT entry / #define R_TILEPRO_JMP_SLOT 12 / Create PLT entry / #define R_TILEPRO_RELATIVE 13 / Adjust by program base / #define R_TILEPRO_BROFF_X1 14 / X1 pipe branch offset / #define R_TILEPRO_JOFFLONG_X1 15 / X1 pipe jump offset / #define R_TILEPRO_JOFFLONG_X1_PLT 16 / X1 pipe jump offset to PLT / #define R_TILEPRO_IMM8_X0 17 / X0 pipe 8-bit / #define R_TILEPRO_IMM8_Y0 18 / Y0 pipe 8-bit / #define R_TILEPRO_IMM8_X1 19 / X1 pipe 8-bit / #define R_TILEPRO_IMM8_Y1 20 / Y1 pipe 8-bit / #define R_TILEPRO_MT_IMM15_X1 21 / X1 pipe mtspr / #define R_TILEPRO_MF_IMM15_X1 22 / X1 pipe mfspr / #define R_TILEPRO_IMM16_X0 23 / X0 pipe 16-bit / #define R_TILEPRO_IMM16_X1 24 / X1 pipe 16-bit / #define R_TILEPRO_IMM16_X0_LO 25 / X0 pipe low 16-bit / #define R_TILEPRO_IMM16_X1_LO 26 / X1 pipe low 16-bit / #define R_TILEPRO_IMM16_X0_HI 27 / X0 pipe high 16-bit / #define R_TILEPRO_IMM16_X1_HI 28 / X1 pipe high 16-bit / #define R_TILEPRO_IMM16_X0_HA 29 / X0 pipe high 16-bit, adjusted / #define R_TILEPRO_IMM16_X1_HA 30 / X1 pipe high 16-bit, adjusted / #define R_TILEPRO_IMM16_X0_PCREL 31 / X0 pipe PC relative 16 bit / #define R_TILEPRO_IMM16_X1_PCREL 32 / X1 pipe PC relative 16 bit / #define R_TILEPRO_IMM16_X0_LO_PCREL 33 / X0 pipe PC relative low 16 bit / #define R_TILEPRO_IMM16_X1_LO_PCREL 34 / X1 pipe PC relative low 16 bit / #define R_TILEPRO_IMM16_X0_HI_PCREL 35 / X0 pipe PC relative high 16 bit / #define R_TILEPRO_IMM16_X1_HI_PCREL 36 / X1 pipe PC relative high 16 bit / #define R_TILEPRO_IMM16_X0_HA_PCREL 37 / X0 pipe PC relative ha() 16 bit / #define R_TILEPRO_IMM16_X1_HA_PCREL 38 / X1 pipe PC relative ha() 16 bit / #define R_TILEPRO_IMM16_X0_GOT 39 / X0 pipe 16-bit GOT offset / #define R_TILEPRO_IMM16_X1_GOT 40 / X1 pipe 16-bit GOT offset / #define R_TILEPRO_IMM16_X0_GOT_LO 41 / X0 pipe low 16-bit GOT offset / #define R_TILEPRO_IMM16_X1_GOT_LO 42 / X1 pipe low 16-bit GOT offset / #define R_TILEPRO_IMM16_X0_GOT_HI 43 / X0 pipe high 16-bit GOT offset / #define R_TILEPRO_IMM16_X1_GOT_HI 44 / X1 pipe high 16-bit GOT offset / #define R_TILEPRO_IMM16_X0_GOT_HA 45 / X0 pipe ha() 16-bit GOT offset / #define R_TILEPRO_IMM16_X1_GOT_HA 46 / X1 pipe ha() 16-bit GOT offset / #define R_TILEPRO_MMSTART_X0 47 / X0 pipe mm "start" / #define R_TILEPRO_MMEND_X0 48 / X0 pipe mm "end" / #define R_TILEPRO_MMSTART_X1 49 / X1 pipe mm "start" / #define R_TILEPRO_MMEND_X1 50 / X1 pipe mm "end" / #define R_TILEPRO_SHAMT_X0 51 / X0 pipe shift amount / #define R_TILEPRO_SHAMT_X1 52 / X1 pipe shift amount / #define R_TILEPRO_SHAMT_Y0 53 / Y0 pipe shift amount / #define R_TILEPRO_SHAMT_Y1 54 / Y1 pipe shift amount / #define R_TILEPRO_DEST_IMM8_X1 55 / X1 pipe destination 8-bit / / Relocs 56-59 are currently not defined. / #define R_TILEPRO_TLS_GD_CALL 60 / "jal" for TLS GD / #define R_TILEPRO_IMM8_X0_TLS_GD_ADD 61 / X0 pipe "addi" for TLS GD / #define R_TILEPRO_IMM8_X1_TLS_GD_ADD 62 / X1 pipe "addi" for TLS GD / #define R_TILEPRO_IMM8_Y0_TLS_GD_ADD 63 / Y0 pipe "addi" for TLS GD / #define R_TILEPRO_IMM8_Y1_TLS_GD_ADD 64 / Y1 pipe "addi" for TLS GD / #define R_TILEPRO_TLS_IE_LOAD 65 / "lw_tls" for TLS IE / #define R_TILEPRO_IMM16_X0_TLS_GD 66 / X0 pipe 16-bit TLS GD offset / #define R_TILEPRO_IMM16_X1_TLS_GD 67 / X1 pipe 16-bit TLS GD offset / #define R_TILEPRO_IMM16_X0_TLS_GD_LO 68 / X0 pipe low 16-bit TLS GD offset / #define R_TILEPRO_IMM16_X1_TLS_GD_LO 69 / X1 pipe low 16-bit TLS GD offset / #define R_TILEPRO_IMM16_X0_TLS_GD_HI 70 / X0 pipe high 16-bit TLS GD offset / #define R_TILEPRO_IMM16_X1_TLS_GD_HI 71 / X1 pipe high 16-bit TLS GD offset / #define R_TILEPRO_IMM16_X0_TLS_GD_HA 72 / X0 pipe ha() 16-bit TLS GD offset / #define R_TILEPRO_IMM16_X1_TLS_GD_HA 73 / X1 pipe ha() 16-bit TLS GD offset / #define R_TILEPRO_IMM16_X0_TLS_IE 74 / X0 pipe 16-bit TLS IE offset / #define R_TILEPRO_IMM16_X1_TLS_IE 75 / X1 pipe 16-bit TLS IE offset / #define R_TILEPRO_IMM16_X0_TLS_IE_LO 76 / X0 pipe low 16-bit TLS IE offset / #define R_TILEPRO_IMM16_X1_TLS_IE_LO 77 / X1 pipe low 16-bit TLS IE offset / #define R_TILEPRO_IMM16_X0_TLS_IE_HI 78 / X0 pipe high 16-bit TLS IE offset / #define R_TILEPRO_IMM16_X1_TLS_IE_HI 79 / X1 pipe high 16-bit TLS IE offset / #define R_TILEPRO_IMM16_X0_TLS_IE_HA 80 / X0 pipe ha() 16-bit TLS IE offset / #define R_TILEPRO_IMM16_X1_TLS_IE_HA 81 / X1 pipe ha() 16-bit TLS IE offset / #define R_TILEPRO_TLS_DTPMOD32 82 / ID of module containing symbol / #define R_TILEPRO_TLS_DTPOFF32 83 / Offset in TLS block / #define R_TILEPRO_TLS_TPOFF32 84 / Offset in static TLS block / #define R_TILEPRO_IMM16_X0_TLS_LE 85 / X0 pipe 16-bit TLS LE offset / #define R_TILEPRO_IMM16_X1_TLS_LE 86 / X1 pipe 16-bit TLS LE offset / #define R_TILEPRO_IMM16_X0_TLS_LE_LO 87 / X0 pipe low 16-bit TLS LE offset / #define R_TILEPRO_IMM16_X1_TLS_LE_LO 88 / X1 pipe low 16-bit TLS LE offset / #define R_TILEPRO_IMM16_X0_TLS_LE_HI 89 / X0 pipe high 16-bit TLS LE offset / #define R_TILEPRO_IMM16_X1_TLS_LE_HI 90 / X1 pipe high 16-bit TLS LE offset / #define R_TILEPRO_IMM16_X0_TLS_LE_HA 91 / X0 pipe ha() 16-bit TLS LE offset / #define R_TILEPRO_IMM16_X1_TLS_LE_HA 92 / X1 pipe ha() 16-bit TLS LE offset / #define R_TILEPRO_GNU_VTINHERIT 128 / GNU C++ vtable hierarchy / #define R_TILEPRO_GNU_VTENTRY 129 / GNU C++ vtable member usage / #define R_TILEPRO_NUM 130 / TILE-Gx relocations. / #define R_TILEGX_NONE 0 / No reloc / #define R_TILEGX_64 1 / Direct 64 bit / #define R_TILEGX_32 2 / Direct 32 bit / #define R_TILEGX_16 3 / Direct 16 bit / #define R_TILEGX_8 4 / Direct 8 bit / #define R_TILEGX_64_PCREL 5 / PC relative 64 bit / #define R_TILEGX_32_PCREL 6 / PC relative 32 bit / #define R_TILEGX_16_PCREL 7 / PC relative 16 bit / #define R_TILEGX_8_PCREL 8 / PC relative 8 bit / #define R_TILEGX_HW0 9 / hword 0 16-bit / #define R_TILEGX_HW1 10 / hword 1 16-bit / #define R_TILEGX_HW2 11 / hword 2 16-bit / #define R_TILEGX_HW3 12 / hword 3 16-bit / #define R_TILEGX_HW0_LAST 13 / last hword 0 16-bit / #define R_TILEGX_HW1_LAST 14 / last hword 1 16-bit / #define R_TILEGX_HW2_LAST 15 / last hword 2 16-bit / #define R_TILEGX_COPY 16 / Copy relocation / #define R_TILEGX_GLOB_DAT 17 / Create GOT entry / #define R_TILEGX_JMP_SLOT 18 / Create PLT entry / #define R_TILEGX_RELATIVE 19 / Adjust by program base / #define R_TILEGX_BROFF_X1 20 / X1 pipe branch offset / #define R_TILEGX_JUMPOFF_X1 21 / X1 pipe jump offset / #define R_TILEGX_JUMPOFF_X1_PLT 22 / X1 pipe jump offset to PLT / #define R_TILEGX_IMM8_X0 23 / X0 pipe 8-bit / #define R_TILEGX_IMM8_Y0 24 / Y0 pipe 8-bit / #define R_TILEGX_IMM8_X1 25 / X1 pipe 8-bit / #define R_TILEGX_IMM8_Y1 26 / Y1 pipe 8-bit / #define R_TILEGX_DEST_IMM8_X1 27 / X1 pipe destination 8-bit / #define R_TILEGX_MT_IMM14_X1 28 / X1 pipe mtspr / #define R_TILEGX_MF_IMM14_X1 29 / X1 pipe mfspr / #define R_TILEGX_MMSTART_X0 30 / X0 pipe mm "start" / #define R_TILEGX_MMEND_X0 31 / X0 pipe mm "end" / #define R_TILEGX_SHAMT_X0 32 / X0 pipe shift amount / #define R_TILEGX_SHAMT_X1 33 / X1 pipe shift amount / #define R_TILEGX_SHAMT_Y0 34 / Y0 pipe shift amount / #define R_TILEGX_SHAMT_Y1 35 / Y1 pipe shift amount / #define R_TILEGX_IMM16_X0_HW0 36 / X0 pipe hword 0 / #define R_TILEGX_IMM16_X1_HW0 37 / X1 pipe hword 0 / #define R_TILEGX_IMM16_X0_HW1 38 / X0 pipe hword 1 / #define R_TILEGX_IMM16_X1_HW1 39 / X1 pipe hword 1 / #define R_TILEGX_IMM16_X0_HW2 40 / X0 pipe hword 2 / #define R_TILEGX_IMM16_X1_HW2 41 / X1 pipe hword 2 / #define R_TILEGX_IMM16_X0_HW3 42 / X0 pipe hword 3 / #define R_TILEGX_IMM16_X1_HW3 43 / X1 pipe hword 3 / #define R_TILEGX_IMM16_X0_HW0_LAST 44 / X0 pipe last hword 0 / #define R_TILEGX_IMM16_X1_HW0_LAST 45 / X1 pipe last hword 0 / #define R_TILEGX_IMM16_X0_HW1_LAST 46 / X0 pipe last hword 1 / #define R_TILEGX_IMM16_X1_HW1_LAST 47 / X1 pipe last hword 1 / #define R_TILEGX_IMM16_X0_HW2_LAST 48 / X0 pipe last hword 2 / #define R_TILEGX_IMM16_X1_HW2_LAST 49 / X1 pipe last hword 2 / #define R_TILEGX_IMM16_X0_HW0_PCREL 50 / X0 pipe PC relative hword 0 / #define R_TILEGX_IMM16_X1_HW0_PCREL 51 / X1 pipe PC relative hword 0 / #define R_TILEGX_IMM16_X0_HW1_PCREL 52 / X0 pipe PC relative hword 1 / #define R_TILEGX_IMM16_X1_HW1_PCREL 53 / X1 pipe PC relative hword 1 / #define R_TILEGX_IMM16_X0_HW2_PCREL 54 / X0 pipe PC relative hword 2 / #define R_TILEGX_IMM16_X1_HW2_PCREL 55 / X1 pipe PC relative hword 2 / #define R_TILEGX_IMM16_X0_HW3_PCREL 56 / X0 pipe PC relative hword 3 / #define R_TILEGX_IMM16_X1_HW3_PCREL 57 / X1 pipe PC relative hword 3 / #define R_TILEGX_IMM16_X0_HW0_LAST_PCREL 58 / X0 pipe PC-rel last hword 0 / #define R_TILEGX_IMM16_X1_HW0_LAST_PCREL 59 / X1 pipe PC-rel last hword 0 / #define R_TILEGX_IMM16_X0_HW1_LAST_PCREL 60 / X0 pipe PC-rel last hword 1 / #define R_TILEGX_IMM16_X1_HW1_LAST_PCREL 61 / X1 pipe PC-rel last hword 1 / #define R_TILEGX_IMM16_X0_HW2_LAST_PCREL 62 / X0 pipe PC-rel last hword 2 / #define R_TILEGX_IMM16_X1_HW2_LAST_PCREL 63 / X1 pipe PC-rel last hword 2 / #define R_TILEGX_IMM16_X0_HW0_GOT 64 / X0 pipe hword 0 GOT offset / #define R_TILEGX_IMM16_X1_HW0_GOT 65 / X1 pipe hword 0 GOT offset / #define R_TILEGX_IMM16_X0_HW0_PLT_PCREL 66 / X0 pipe PC-rel PLT hword 0 / #define R_TILEGX_IMM16_X1_HW0_PLT_PCREL 67 / X1 pipe PC-rel PLT hword 0 / #define R_TILEGX_IMM16_X0_HW1_PLT_PCREL 68 / X0 pipe PC-rel PLT hword 1 / #define R_TILEGX_IMM16_X1_HW1_PLT_PCREL 69 / X1 pipe PC-rel PLT hword 1 / #define R_TILEGX_IMM16_X0_HW2_PLT_PCREL 70 / X0 pipe PC-rel PLT hword 2 / #define R_TILEGX_IMM16_X1_HW2_PLT_PCREL 71 / X1 pipe PC-rel PLT hword 2 / #define R_TILEGX_IMM16_X0_HW0_LAST_GOT 72 / X0 pipe last hword 0 GOT offset / #define R_TILEGX_IMM16_X1_HW0_LAST_GOT 73 / X1 pipe last hword 0 GOT offset / #define R_TILEGX_IMM16_X0_HW1_LAST_GOT 74 / X0 pipe last hword 1 GOT offset / #define R_TILEGX_IMM16_X1_HW1_LAST_GOT 75 / X1 pipe last hword 1 GOT offset / #define R_TILEGX_IMM16_X0_HW3_PLT_PCREL 76 / X0 pipe PC-rel PLT hword 3 / #define R_TILEGX_IMM16_X1_HW3_PLT_PCREL 77 / X1 pipe PC-rel PLT hword 3 / #define R_TILEGX_IMM16_X0_HW0_TLS_GD 78 / X0 pipe hword 0 TLS GD offset / #define R_TILEGX_IMM16_X1_HW0_TLS_GD 79 / X1 pipe hword 0 TLS GD offset / #define R_TILEGX_IMM16_X0_HW0_TLS_LE 80 / X0 pipe hword 0 TLS LE offset / #define R_TILEGX_IMM16_X1_HW0_TLS_LE 81 / X1 pipe hword 0 TLS LE offset / #define R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE 82 / X0 pipe last hword 0 LE off / #define R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE 83 / X1 pipe last hword 0 LE off / #define R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE 84 / X0 pipe last hword 1 LE off / #define R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE 85 / X1 pipe last hword 1 LE off / #define R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD 86 / X0 pipe last hword 0 GD off / #define R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD 87 / X1 pipe last hword 0 GD off / #define R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD 88 / X0 pipe last hword 1 GD off / #define R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD 89 / X1 pipe last hword 1 GD off / / Relocs 90-91 are currently not defined. / #define R_TILEGX_IMM16_X0_HW0_TLS_IE 92 / X0 pipe hword 0 TLS IE offset / #define R_TILEGX_IMM16_X1_HW0_TLS_IE 93 / X1 pipe hword 0 TLS IE offset / #define R_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL 94 / X0 pipe PC-rel PLT last hword 0 / #define R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL 95 / X1 pipe PC-rel PLT last hword 0 / #define R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL 96 / X0 pipe PC-rel PLT last hword 1 / #define R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL 97 / X1 pipe PC-rel PLT last hword 1 / #define R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL 98 / X0 pipe PC-rel PLT last hword 2 / #define R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL 99 / X1 pipe PC-rel PLT last hword 2 / #define R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE 100 / X0 pipe last hword 0 IE off / #define R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE 101 / X1 pipe last hword 0 IE off / #define R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE 102 / X0 pipe last hword 1 IE off / #define R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE 103 / X1 pipe last hword 1 IE off / / Relocs 104-105 are currently not defined. / #define R_TILEGX_TLS_DTPMOD64 106 / 64-bit ID of symbol's module / #define R_TILEGX_TLS_DTPOFF64 107 / 64-bit offset in TLS block / #define R_TILEGX_TLS_TPOFF64 108 / 64-bit offset in static TLS block / #define R_TILEGX_TLS_DTPMOD32 109 / 32-bit ID of symbol's module / #define R_TILEGX_TLS_DTPOFF32 110 / 32-bit offset in TLS block / #define R_TILEGX_TLS_TPOFF32 111 / 32-bit offset in static TLS block / #define R_TILEGX_TLS_GD_CALL 112 / "jal" for TLS GD / #define R_TILEGX_IMM8_X0_TLS_GD_ADD 113 / X0 pipe "addi" for TLS GD / #define R_TILEGX_IMM8_X1_TLS_GD_ADD 114 / X1 pipe "addi" for TLS GD / #define R_TILEGX_IMM8_Y0_TLS_GD_ADD 115 / Y0 pipe "addi" for TLS GD / #define R_TILEGX_IMM8_Y1_TLS_GD_ADD 116 / Y1 pipe "addi" for TLS GD / #define R_TILEGX_TLS_IE_LOAD 117 / "ld_tls" for TLS IE / #define R_TILEGX_IMM8_X0_TLS_ADD 118 / X0 pipe "addi" for TLS GD/IE / #define R_TILEGX_IMM8_X1_TLS_ADD 119 / X1 pipe "addi" for TLS GD/IE / #define R_TILEGX_IMM8_Y0_TLS_ADD 120 / Y0 pipe "addi" for TLS GD/IE / #define R_TILEGX_IMM8_Y1_TLS_ADD 121 / Y1 pipe "addi" for TLS GD/IE / #define R_TILEGX_GNU_VTINHERIT 128 / GNU C++ vtable hierarchy / #define R_TILEGX_GNU_VTENTRY 129 / GNU C++ vtable member usage / #define R_TILEGX_NUM 130 / RISC-V ELF Flags / #define EF_RISCV_RVC 0x0001 #define EF_RISCV_FLOAT_ABI 0x0006 #define EF_RISCV_FLOAT_ABI_SOFT 0x0000 #define EF_RISCV_FLOAT_ABI_SINGLE 0x0002 #define EF_RISCV_FLOAT_ABI_DOUBLE 0x0004 #define EF_RISCV_FLOAT_ABI_QUAD 0x0006 / RISC-V relocations. / #define R_RISCV_NONE 0 #define R_RISCV_32 1 #define R_RISCV_64 2 #define R_RISCV_RELATIVE 3 #define R_RISCV_COPY 4 #define R_RISCV_JUMP_SLOT 5 #define R_RISCV_TLS_DTPMOD32 6 #define R_RISCV_TLS_DTPMOD64 7 #define R_RISCV_TLS_DTPREL32 8 #define R_RISCV_TLS_DTPREL64 9 #define R_RISCV_TLS_TPREL32 10 #define R_RISCV_TLS_TPREL64 11 #define R_RISCV_BRANCH 16 #define R_RISCV_JAL 17 #define R_RISCV_CALL 18 #define R_RISCV_CALL_PLT 19 #define R_RISCV_GOT_HI20 20 #define R_RISCV_TLS_GOT_HI20 21 #define R_RISCV_TLS_GD_HI20 22 #define R_RISCV_PCREL_HI20 23 #define R_RISCV_PCREL_LO12_I 24 #define R_RISCV_PCREL_LO12_S 25 #define R_RISCV_HI20 26 #define R_RISCV_LO12_I 27 #define R_RISCV_LO12_S 28 #define R_RISCV_TPREL_HI20 29 #define R_RISCV_TPREL_LO12_I 30 #define R_RISCV_TPREL_LO12_S 31 #define R_RISCV_TPREL_ADD 32 #define R_RISCV_ADD8 33 #define R_RISCV_ADD16 34 #define R_RISCV_ADD32 35 #define R_RISCV_ADD64 36 #define R_RISCV_SUB8 37 #define R_RISCV_SUB16 38 #define R_RISCV_SUB32 39 #define R_RISCV_SUB64 40 #define R_RISCV_GNU_VTINHERIT 41 #define R_RISCV_GNU_VTENTRY 42 #define R_RISCV_ALIGN 43 #define R_RISCV_RVC_BRANCH 44 #define R_RISCV_RVC_JUMP 45 #define R_RISCV_RVC_LUI 46 #define R_RISCV_GPREL_I 47 #define R_RISCV_GPREL_S 48 #define R_RISCV_TPREL_I 49 #define R_RISCV_TPREL_S 50 #define R_RISCV_RELAX 51 #define R_RISCV_SUB6 52 #define R_RISCV_SET6 53 #define R_RISCV_SET8 54 #define R_RISCV_SET16 55 #define R_RISCV_SET32 56 #define R_RISCV_32_PCREL 57 #define R_RISCV_IRELATIVE 58 #define R_RISCV_NUM 59 / BPF specific declarations. / #define R_BPF_NONE 0 / No reloc / #define R_BPF_64_64 1 #define R_BPF_64_32 10 / Imagination Meta specific relocations. / #define R_METAG_HIADDR16 0 #define R_METAG_LOADDR16 1 #define R_METAG_ADDR32 2 / 32bit absolute address / #define R_METAG_NONE 3 / No reloc / #define R_METAG_RELBRANCH 4 #define R_METAG_GETSETOFF 5 / Backward compatibility / #define R_METAG_REG32OP1 6 #define R_METAG_REG32OP2 7 #define R_METAG_REG32OP3 8 #define R_METAG_REG16OP1 9 #define R_METAG_REG16OP2 10 #define R_METAG_REG16OP3 11 #define R_METAG_REG32OP4 12 #define R_METAG_HIOG 13 #define R_METAG_LOOG 14 #define R_METAG_REL8 15 #define R_METAG_REL16 16 / GNU / #define R_METAG_GNU_VTINHERIT 30 #define R_METAG_GNU_VTENTRY 31 / PIC relocations / #define R_METAG_HI16_GOTOFF 32 #define R_METAG_LO16_GOTOFF 33 #define R_METAG_GETSET_GOTOFF 34 #define R_METAG_GETSET_GOT 35 #define R_METAG_HI16_GOTPC 36 #define R_METAG_LO16_GOTPC 37 #define R_METAG_HI16_PLT 38 #define R_METAG_LO16_PLT 39 #define R_METAG_RELBRANCH_PLT 40 #define R_METAG_GOTOFF 41 #define R_METAG_PLT 42 #define R_METAG_COPY 43 #define R_METAG_JMP_SLOT 44 #define R_METAG_RELATIVE 45 #define R_METAG_GLOB_DAT 46 / TLS relocations / #define R_METAG_TLS_GD 47 #define R_METAG_TLS_LDM 48 #define R_METAG_TLS_LDO_HI16 49 #define R_METAG_TLS_LDO_LO16 50 #define R_METAG_TLS_LDO 51 #define R_METAG_TLS_IE 52 #define R_METAG_TLS_IENONPIC 53 #define R_METAG_TLS_IENONPIC_HI16 54 #define R_METAG_TLS_IENONPIC_LO16 55 #define R_METAG_TLS_TPOFF 56 #define R_METAG_TLS_DTPMOD 57 #define R_METAG_TLS_DTPOFF 58 #define R_METAG_TLS_LE 59 #define R_METAG_TLS_LE_HI16 60 #define R_METAG_TLS_LE_LO16 61 / NDS32 relocations. / #define R_NDS32_NONE 0 #define R_NDS32_32_RELA 20 #define R_NDS32_COPY 39 #define R_NDS32_GLOB_DAT 40 #define R_NDS32_JMP_SLOT 41 #define R_NDS32_RELATIVE 42 #define R_NDS32_TLS_TPOFF 102 #define R_NDS32_TLS_DESC 119 / ARCompact/ARCv2 specific relocs. / #define R_ARC_NONE 0x0 #define R_ARC_8 0x1 #define R_ARC_16 0x2 #define R_ARC_24 0x3 #define R_ARC_32 0x4 #define R_ARC_B26 0x5 #define R_ARC_B22_PCREL 0x6 #define R_ARC_H30 0x7 #define R_ARC_N8 0x8 #define R_ARC_N16 0x9 #define R_ARC_N24 0xA #define R_ARC_N32 0xB #define R_ARC_SDA 0xC #define R_ARC_SECTOFF 0xD #define R_ARC_S21H_PCREL 0xE #define R_ARC_S21W_PCREL 0xF #define R_ARC_S25H_PCREL 0x10 #define R_ARC_S25W_PCREL 0x11 #define R_ARC_SDA32 0x12 #define R_ARC_SDA_LDST 0x13 #define R_ARC_SDA_LDST1 0x14 #define R_ARC_SDA_LDST2 0x15 #define R_ARC_SDA16_LD 0x16 #define R_ARC_SDA16_LD1 0x17 #define R_ARC_SDA16_LD2 0x18 #define R_ARC_S13_PCREL 0x19 #define R_ARC_W 0x1A #define R_ARC_32_ME 0x1B #define R_ARC_N32_ME 0x1C #define R_ARC_SECTOFF_ME 0x1D #define R_ARC_SDA32_ME 0x1E #define R_ARC_W_ME 0x1F #define R_ARC_H30_ME 0x20 #define R_ARC_SECTOFF_U8 0x21 #define R_ARC_SECTOFF_S9 0x22 #define R_AC_SECTOFF_U8 0x23 #define R_AC_SECTOFF_U8_1 0x24 #define R_AC_SECTOFF_U8_2 0x25 #define R_AC_SECTOFF_S9 0x26 #define R_AC_SECTOFF_S9_1 0x27 #define R_AC_SECTOFF_S9_2 0x28 #define R_ARC_SECTOFF_ME_1 0x29 #define R_ARC_SECTOFF_ME_2 0x2A #define R_ARC_SECTOFF_1 0x2B #define R_ARC_SECTOFF_2 0x2C #define R_ARC_PC32 0x32 #define R_ARC_GOTPC32 0x33 #define R_ARC_PLT32 0x34 #define R_ARC_COPY 0x35 #define R_ARC_GLOB_DAT 0x36 #define R_ARC_JUMP_SLOT 0x37 #define R_ARC_RELATIVE 0x38 #define R_ARC_GOTOFF 0x39 #define R_ARC_GOTPC 0x3A #define R_ARC_GOT32 0x3B #define R_ARC_TLS_DTPMOD 0x42 #define R_ARC_TLS_DTPOFF 0x43 #define R_ARC_TLS_TPOFF 0x44 #define R_ARC_TLS_GD_GOT 0x45 #define R_ARC_TLS_GD_LD 0x46 #define R_ARC_TLS_GD_CALL 0x47 #define R_ARC_TLS_IE_GOT 0x48 #define R_ARC_TLS_DTPOFF_S9 0x4a #define R_ARC_TLS_LE_S9 0x4a #define R_ARC_TLS_LE_32 0x4b #endif / elf.h */	178.26 KB	2026-02-17 11:02
📄 endian.h /* Copyright (C) 1992-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _ENDIAN_H #define _ENDIAN_H 1 #include <features.h> / Get the definitions of ___ENDIAN, __BYTE_ORDER, and __FLOAT_WORD_ORDER. / #include <bits/endian.h> #ifdef __USE_MISC # define LITTLE_ENDIAN __LITTLE_ENDIAN # define BIG_ENDIAN __BIG_ENDIAN # define PDP_ENDIAN __PDP_ENDIAN # define BYTE_ORDER __BYTE_ORDER #endif #if defined __USE_MISC && !defined __ASSEMBLER__ /* Conversion interfaces. / # include <bits/byteswap.h> # include <bits/uintn-identity.h> # if __BYTE_ORDER == __LITTLE_ENDIAN # define htobe16(x) __bswap_16 (x) # define htole16(x) __uint16_identity (x) # define be16toh(x) __bswap_16 (x) # define le16toh(x) __uint16_identity (x) # define htobe32(x) __bswap_32 (x) # define htole32(x) __uint32_identity (x) # define be32toh(x) __bswap_32 (x) # define le32toh(x) __uint32_identity (x) # define htobe64(x) __bswap_64 (x) # define htole64(x) __uint64_identity (x) # define be64toh(x) __bswap_64 (x) # define le64toh(x) __uint64_identity (x) # else # define htobe16(x) __uint16_identity (x) # define htole16(x) __bswap_16 (x) # define be16toh(x) __uint16_identity (x) # define le16toh(x) __bswap_16 (x) # define htobe32(x) __uint32_identity (x) # define htole32(x) __bswap_32 (x) # define be32toh(x) __uint32_identity (x) # define le32toh(x) __bswap_32 (x) # define htobe64(x) __uint64_identity (x) # define htole64(x) __bswap_64 (x) # define be64toh(x) __uint64_identity (x) # define le64toh(x) __bswap_64 (x) # endif #endif #endif / endian.h */	2.25 KB	2026-02-17 11:01
📄 envz.h /* Routines for dealing with '\0' separated environment vectors Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _ENVZ_H #define _ENVZ_H 1 #include <features.h> #include <errno.h> / Envz's are argz's too, and should be created etc., using the same routines. / #include <argz.h> __BEGIN_DECLS / Returns a pointer to the entry in ENVZ for NAME, or 0 if there is none. / extern char envz_entry (const char __restrict __envz, size_t __envz_len, const char __restrict __name) __THROW __attribute_pure__; /* Returns a pointer to the value portion of the entry in ENVZ for NAME, or 0 if there is none. / extern char envz_get (const char __restrict __envz, size_t __envz_len, const char __restrict __name) __THROW __attribute_pure__; /* Adds an entry for NAME with value VALUE to ENVZ & ENVZ_LEN. If an entry with the same name already exists in ENVZ, it is removed. If VALUE is NULL, then the new entry will a special null one, for which envz_get will return NULL, although envz_entry will still return an entry; this is handy because when merging with another envz, the null entry can override an entry in the other one. Null entries can be removed with envz_strip (). / extern error_t envz_add (char __restrict __envz, size_t __restrict __envz_len, const char __restrict __name, const char __restrict __value) __THROW; /* Adds each entry in ENVZ2 to ENVZ & ENVZ_LEN, as if with envz_add(). If OVERRIDE is true, then values in ENVZ2 will supersede those with the same name in ENV, otherwise not. / extern error_t envz_merge (char __restrict __envz, size_t __restrict __envz_len, const char __restrict __envz2, size_t __envz2_len, int __override) __THROW; / Remove the entry for NAME from ENVZ & ENVZ_LEN, if any. / extern void envz_remove (char __restrict __envz, size_t __restrict __envz_len, const char __restrict __name) __THROW; / Remove null entries. / extern void envz_strip (char __restrict __envz, size_t __restrict __envz_len) __THROW; __END_DECLS #endif /* envz.h */	2.8 KB	2026-02-17 11:01
📄 err.h /* 4.4BSD utility functions for error messages. Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _ERR_H #define _ERR_H 1 #include <features.h> #define __need___va_list #include <stdarg.h> #ifndef __GNUC_VA_LIST # define __gnuc_va_list void #endif __BEGIN_DECLS /* Print "program: ", FORMAT, ": ", the standard error string for errno, and a newline, on stderr. / extern void warn (const char __format, ...) __attribute__ ((__format__ (__printf__, 1, 2))); extern void vwarn (const char __format, __gnuc_va_list) __attribute__ ((__format__ (__printf__, 1, 0))); / Likewise, but without ": " and the standard error string. / extern void warnx (const char __format, ...) __attribute__ ((__format__ (__printf__, 1, 2))); extern void vwarnx (const char __format, __gnuc_va_list) __attribute__ ((__format__ (__printf__, 1, 0))); / Likewise, and then exit with STATUS. / extern void err (int __status, const char __format, ...) __attribute__ ((__noreturn__, __format__ (__printf__, 2, 3))); extern void verr (int __status, const char __format, __gnuc_va_list) __attribute__ ((__noreturn__, __format__ (__printf__, 2, 0))); extern void errx (int __status, const char __format, ...) __attribute__ ((__noreturn__, __format__ (__printf__, 2, 3))); extern void verrx (int __status, const char , __gnuc_va_list) __attribute__ ((__noreturn__, __format__ (__printf__, 2, 0))); #include <bits/floatn.h> #if defined __LDBL_COMPAT \|\| __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 # include <bits/err-ldbl.h> #endif __END_DECLS #endif / err.h */	2.29 KB	2026-02-17 11:01
📄 errno.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99 Standard: 7.5 Errors <errno.h> / #ifndef _ERRNO_H #define _ERRNO_H 1 #include <features.h> / The system-specific definitions of the E* constants, as macros. / #include <bits/errno.h> / When included from assembly language, this header only provides the E* constants. / #ifndef __ASSEMBLER__ __BEGIN_DECLS / The error code set by various library functions. / extern int __errno_location (void) __THROW __attribute_const__; # define errno (__errno_location ()) # ifdef __USE_GNU / The full and simple forms of the name with which the program was invoked. These variables are set up automatically at startup based on the value of argv[0]. / extern char program_invocation_name; extern char program_invocation_short_name; #include <bits/types/error_t.h> # endif / __USE_GNU / __END_DECLS #endif / !__ASSEMBLER__ / #endif / errno.h */	1.64 KB	2026-02-17 11:01
📄 error.h /* Declaration for error-reporting function Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _ERROR_H #define _ERROR_H 1 #include <features.h> __BEGIN_DECLS / Print a message with `fprintf (stderr, FORMAT, ...)'; if ERRNUM is nonzero, follow it with ": " and strerror (ERRNUM). If STATUS is nonzero, terminate the program with `exit (STATUS)'. / extern void error (int __status, int __errnum, const char __format, ...) __attribute__ ((__format__ (__printf__, 3, 4))); extern void error_at_line (int __status, int __errnum, const char __fname, unsigned int __lineno, const char __format, ...) __attribute__ ((__format__ (__printf__, 5, 6))); /* If NULL, error will flush stdout, then print on stderr the program name, a colon and a space. Otherwise, error will call this function without parameters instead. / extern void (error_print_progname) (void); /* This variable is incremented each time `error' is called. / extern unsigned int error_message_count; / Sometimes we want to have at most one error per line. This variable controls whether this mode is selected or not. / extern int error_one_per_line; #include <bits/floatn.h> #if defined __LDBL_COMPAT \|\| __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 # include <bits/error-ldbl.h> #else / Do not inline error and error_at_line when long double has the same size of double, nor when long double reuses the float128 implementation, because that would invalidate the redirections to the compatibility functions. / # if defined __extern_always_inline && defined __va_arg_pack # include <bits/error.h> # endif #endif __END_DECLS #endif / error.h */	2.36 KB	2026-02-17 11:01
📁 et	-	2026-03-21 15:44
📄 execinfo.h /* Copyright (C) 1998-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _EXECINFO_H #define _EXECINFO_H 1 #include <features.h> __BEGIN_DECLS / Store up to SIZE return address of the current program state in ARRAY and return the exact number of values stored. / extern int backtrace (void __array, int __size) __nonnull ((1)); / Return names of functions from the backtrace list in ARRAY in a newly malloc()ed memory block. / extern char backtrace_symbols (void const __array, int __size) __THROW __nonnull ((1)); / This function is similar to backtrace_symbols() but it writes the result immediately to a file. / extern void backtrace_symbols_fd (void const __array, int __size, int __fd) __THROW __nonnull ((1)); __END_DECLS #endif / execinfo.h */	1.49 KB	2026-02-17 11:02
📄 fcntl.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * POSIX Standard: 6.5 File Control Operations <fcntl.h> / #ifndef _FCNTL_H #define _FCNTL_H 1 #include <features.h> / This must be early so <bits/fcntl.h> can define types winningly. / __BEGIN_DECLS / Get __mode_t, __dev_t and __off_t ./ #include <bits/types.h> / Get the definitions of O_, F_, FD_: all the numbers and flag bits for `open', `fcntl', et al. / #include <bits/fcntl.h> /* Detect if open needs mode as a third argument (or for openat as a fourth argument). / #ifdef __O_TMPFILE # define __OPEN_NEEDS_MODE(oflag) \ (((oflag) & O_CREAT) != 0 \|\| ((oflag) & __O_TMPFILE) == __O_TMPFILE) #else # define __OPEN_NEEDS_MODE(oflag) (((oflag) & O_CREAT) != 0) #endif / POSIX.1-2001 specifies that these types are defined by <fcntl.h>. Earlier POSIX standards permitted any type ending in `_t' to be defined by any POSIX header, so we don't conditionalize the definitions here. / #ifndef __mode_t_defined typedef __mode_t mode_t; # define __mode_t_defined #endif #ifndef __off_t_defined # ifndef __USE_FILE_OFFSET64 typedef __off_t off_t; # else typedef __off64_t off_t; # endif # define __off_t_defined #endif #if defined __USE_LARGEFILE64 && !defined __off64_t_defined typedef __off64_t off64_t; # define __off64_t_defined #endif #ifndef __pid_t_defined typedef __pid_t pid_t; # define __pid_t_defined #endif / For XPG all symbols from <sys/stat.h> should also be available. / #ifdef __USE_XOPEN2K8 # include <bits/types/struct_timespec.h> #endif #if defined __USE_XOPEN \|\| defined __USE_XOPEN2K8 # include <bits/stat.h> # define S_IFMT __S_IFMT # define S_IFDIR __S_IFDIR # define S_IFCHR __S_IFCHR # define S_IFBLK __S_IFBLK # define S_IFREG __S_IFREG # ifdef __S_IFIFO # define S_IFIFO __S_IFIFO # endif # ifdef __S_IFLNK # define S_IFLNK __S_IFLNK # endif # if (defined __USE_UNIX98 \|\| defined __USE_XOPEN2K8) && defined __S_IFSOCK # define S_IFSOCK __S_IFSOCK # endif / Protection bits. / # define S_ISUID __S_ISUID / Set user ID on execution. / # define S_ISGID __S_ISGID / Set group ID on execution. / # if defined __USE_MISC \|\| defined __USE_XOPEN / Save swapped text after use (sticky bit). This is pretty well obsolete. / # define S_ISVTX __S_ISVTX # endif # define S_IRUSR __S_IREAD / Read by owner. / # define S_IWUSR __S_IWRITE / Write by owner. / # define S_IXUSR __S_IEXEC / Execute by owner. / / Read, write, and execute by owner. / # define S_IRWXU (__S_IREAD\|__S_IWRITE\|__S_IEXEC) # define S_IRGRP (S_IRUSR >> 3) / Read by group. / # define S_IWGRP (S_IWUSR >> 3) / Write by group. / # define S_IXGRP (S_IXUSR >> 3) / Execute by group. / / Read, write, and execute by group. / # define S_IRWXG (S_IRWXU >> 3) # define S_IROTH (S_IRGRP >> 3) / Read by others. / # define S_IWOTH (S_IWGRP >> 3) / Write by others. / # define S_IXOTH (S_IXGRP >> 3) / Execute by others. / / Read, write, and execute by others. / # define S_IRWXO (S_IRWXG >> 3) #endif #ifdef __USE_MISC # ifndef R_OK / Verbatim from <unistd.h>. Ugh. / / Values for the second argument to access. These may be OR'd together. / # define R_OK 4 / Test for read permission. / # define W_OK 2 / Test for write permission. / # define X_OK 1 / Test for execute permission. / # define F_OK 0 / Test for existence. / # endif #endif / Use misc. / / XPG wants the following symbols. <stdio.h> has the same definitions. / #if defined __USE_XOPEN \|\| defined __USE_XOPEN2K8 # define SEEK_SET 0 / Seek from beginning of file. / # define SEEK_CUR 1 / Seek from current position. / # define SEEK_END 2 / Seek from end of file. / #endif / XPG / / The constants AT_REMOVEDIR and AT_EACCESS have the same value. AT_EACCESS is meaningful only to faccessat, while AT_REMOVEDIR is meaningful only to unlinkat. The two functions do completely different things and therefore, the flags can be allowed to overlap. For example, passing AT_REMOVEDIR to faccessat would be undefined behavior and thus treating it equivalent to AT_EACCESS is valid undefined behavior. / #ifdef __USE_ATFILE # define AT_FDCWD -100 / Special value used to indicate the at functions should use the current working directory. / # define AT_SYMLINK_NOFOLLOW 0x100 /* Do not follow symbolic links. / # define AT_REMOVEDIR 0x200 / Remove directory instead of unlinking file. / # define AT_SYMLINK_FOLLOW 0x400 / Follow symbolic links. / # ifdef __USE_GNU # define AT_NO_AUTOMOUNT 0x800 / Suppress terminal automount traversal. / # define AT_EMPTY_PATH 0x1000 / Allow empty relative pathname. / # define AT_STATX_SYNC_TYPE 0x6000 # define AT_STATX_SYNC_AS_STAT 0x0000 # define AT_STATX_FORCE_SYNC 0x2000 # define AT_STATX_DONT_SYNC 0x4000 # define AT_RECURSIVE 0x8000 / Apply to the entire subtree. / # endif # define AT_EACCESS 0x200 / Test access permitted for effective IDs, not real IDs. / #endif / Do the file control operation described by CMD on FD. The remaining arguments are interpreted depending on CMD. This function is a cancellation point and therefore not marked with __THROW. / #ifndef __USE_TIME_BITS64 # ifndef __USE_FILE_OFFSET64 extern int fcntl (int __fd, int __cmd, ...); # else # ifdef __REDIRECT extern int __REDIRECT (fcntl, (int __fd, int __cmd, ...), fcntl64); # else # define fcntl fcntl64 # endif # endif # ifdef __USE_LARGEFILE64 extern int fcntl64 (int __fd, int __cmd, ...); # endif #else / __USE_TIME_BITS64 / # ifdef __REDIRECT extern int __REDIRECT_NTH (fcntl, (int __fd, int __request, ...), __fcntl_time64); extern int __REDIRECT_NTH (fcntl64, (int __fd, int __request, ...), __fcntl_time64); # else extern int __fcntl_time64 (int __fd, int __request, ...) __THROW; # define fcntl64 __fcntl_time64 # define fcntl __fcntl_time64 # endif #endif / Open FILE and return a new file descriptor for it, or -1 on error. OFLAG determines the type of access used. If O_CREAT or O_TMPFILE is set in OFLAG, the third argument is taken as a `mode_t', the mode of the created file. This function is a cancellation point and therefore not marked with __THROW. / #ifndef __USE_FILE_OFFSET64 extern int open (const char __file, int __oflag, ...) __nonnull ((1)); #else # ifdef __REDIRECT extern int __REDIRECT (open, (const char __file, int __oflag, ...), open64) __nonnull ((1)); # else # define open open64 # endif #endif #ifdef __USE_LARGEFILE64 extern int open64 (const char __file, int __oflag, ...) __nonnull ((1)); #endif #ifdef __USE_ATFILE /* Similar to `open' but a relative path name is interpreted relative to the directory for which FD is a descriptor. NOTE: some other `openat' implementation support additional functionality through this interface, especially using the O_XATTR flag. This is not yet supported here. This function is a cancellation point and therefore not marked with __THROW. / # ifndef __USE_FILE_OFFSET64 extern int openat (int __fd, const char __file, int __oflag, ...) __nonnull ((2)); # else # ifdef __REDIRECT extern int __REDIRECT (openat, (int __fd, const char __file, int __oflag, ...), openat64) __nonnull ((2)); # else # define openat openat64 # endif # endif # ifdef __USE_LARGEFILE64 extern int openat64 (int __fd, const char __file, int __oflag, ...) __nonnull ((2)); # endif #endif /* Create and open FILE, with mode MODE. This takes an `int' MODE argument because that is what `mode_t' will be widened to. This function is a cancellation point and therefore not marked with __THROW. / #ifndef __USE_FILE_OFFSET64 extern int creat (const char __file, mode_t __mode) __nonnull ((1)); #else # ifdef __REDIRECT extern int __REDIRECT (creat, (const char __file, mode_t __mode), creat64) __nonnull ((1)); # else # define creat creat64 # endif #endif #ifdef __USE_LARGEFILE64 extern int creat64 (const char __file, mode_t __mode) __nonnull ((1)); #endif #if !defined F_LOCK && (defined __USE_MISC \|\| (defined __USE_XOPEN_EXTENDED \ && !defined __USE_POSIX)) /* NOTE: These declarations also appear in <unistd.h>; be sure to keep both files consistent. Some systems have them there and some here, and some software depends on the macros being defined without including both. / / `lockf' is a simpler interface to the locking facilities of `fcntl'. LEN is always relative to the current file position. The CMD argument is one of the following. / # define F_ULOCK 0 / Unlock a previously locked region. / # define F_LOCK 1 / Lock a region for exclusive use. / # define F_TLOCK 2 / Test and lock a region for exclusive use. / # define F_TEST 3 / Test a region for other processes locks. / # ifndef __USE_FILE_OFFSET64 extern int lockf (int __fd, int __cmd, off_t __len); # else # ifdef __REDIRECT extern int __REDIRECT (lockf, (int __fd, int __cmd, __off64_t __len), lockf64); # else # define lockf lockf64 # endif # endif # ifdef __USE_LARGEFILE64 extern int lockf64 (int __fd, int __cmd, off64_t __len); # endif #endif #ifdef __USE_XOPEN2K / Advice the system about the expected behaviour of the application with respect to the file associated with FD. / # ifndef __USE_FILE_OFFSET64 extern int posix_fadvise (int __fd, off_t __offset, off_t __len, int __advise) __THROW; # else # ifdef __REDIRECT_NTH extern int __REDIRECT_NTH (posix_fadvise, (int __fd, __off64_t __offset, __off64_t __len, int __advise), posix_fadvise64); # else # define posix_fadvise posix_fadvise64 # endif # endif # ifdef __USE_LARGEFILE64 extern int posix_fadvise64 (int __fd, off64_t __offset, off64_t __len, int __advise) __THROW; # endif / Reserve storage for the data of the file associated with FD. This function is a possible cancellation point and therefore not marked with __THROW. / # ifndef __USE_FILE_OFFSET64 extern int posix_fallocate (int __fd, off_t __offset, off_t __len); # else # ifdef __REDIRECT extern int __REDIRECT (posix_fallocate, (int __fd, __off64_t __offset, __off64_t __len), posix_fallocate64); # else # define posix_fallocate posix_fallocate64 # endif # endif # ifdef __USE_LARGEFILE64 extern int posix_fallocate64 (int __fd, off64_t __offset, off64_t __len); # endif #endif / Define some inlines helping to catch common problems. / #if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function \ && defined __va_arg_pack_len # include <bits/fcntl2.h> #endif __END_DECLS #endif / fcntl.h */	11.17 KB	2026-02-17 11:01
📄 features-time64.h /* Features part to handle 64-bit time_t support. Copyright (C) 2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / We need to know the word size in order to check the time size. */ #include <bits/wordsize.h> #include <bits/timesize.h> #if defined _TIME_BITS # if _TIME_BITS == 64 # if ! defined (_FILE_OFFSET_BITS) \|\| _FILE_OFFSET_BITS != 64 # error "_TIME_BITS=64 is allowed only with _FILE_OFFSET_BITS=64" # elif __TIMESIZE == 32 # define __USE_TIME_BITS64 1 # endif # elif _TIME_BITS == 32 # if __TIMESIZE > 32 # error "_TIME_BITS=32 is not compatible with __TIMESIZE > 32" # endif # else # error Invalid _TIME_BITS value (can only be 32 or 64-bit) # endif #endif	1.37 KB	2026-02-17 11:01
📄 features.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _FEATURES_H #define _FEATURES_H 1 / These are defined by the user (or the compiler) to specify the desired environment: __STRICT_ANSI__ ISO Standard C. _ISOC99_SOURCE Extensions to ISO C89 from ISO C99. _ISOC11_SOURCE Extensions to ISO C99 from ISO C11. _ISOC2X_SOURCE Extensions to ISO C99 from ISO C2X. __STDC_WANT_LIB_EXT2__ Extensions to ISO C99 from TR 27431-2:2010. __STDC_WANT_IEC_60559_BFP_EXT__ Extensions to ISO C11 from TS 18661-1:2014. __STDC_WANT_IEC_60559_FUNCS_EXT__ Extensions to ISO C11 from TS 18661-4:2015. __STDC_WANT_IEC_60559_TYPES_EXT__ Extensions to ISO C11 from TS 18661-3:2015. __STDC_WANT_IEC_60559_EXT__ ISO C2X interfaces defined only in Annex F. _POSIX_SOURCE IEEE Std 1003.1. _POSIX_C_SOURCE If ==1, like _POSIX_SOURCE; if >=2 add IEEE Std 1003.2; if >=199309L, add IEEE Std 1003.1b-1993; if >=199506L, add IEEE Std 1003.1c-1995; if >=200112L, all of IEEE 1003.1-2004 if >=200809L, all of IEEE 1003.1-2008 _XOPEN_SOURCE Includes POSIX and XPG things. Set to 500 if Single Unix conformance is wanted, to 600 for the sixth revision, to 700 for the seventh revision. _XOPEN_SOURCE_EXTENDED XPG things and X/Open Unix extensions. _LARGEFILE_SOURCE Some more functions for correct standard I/O. _LARGEFILE64_SOURCE Additional functionality from LFS for large files. _FILE_OFFSET_BITS=N Select default filesystem interface. _ATFILE_SOURCE Additional at interfaces. _DYNAMIC_STACK_SIZE_SOURCE Select correct (but non compile-time constant) MINSIGSTKSZ, SIGSTKSZ and PTHREAD_STACK_MIN. _GNU_SOURCE All of the above, plus GNU extensions. _DEFAULT_SOURCE The default set of features (taking precedence over __STRICT_ANSI__). _FORTIFY_SOURCE Add security hardening to many library functions. Set to 1 or 2; 2 performs stricter checks than 1. _REENTRANT, _THREAD_SAFE Obsolete; equivalent to _POSIX_C_SOURCE=199506L. The `-ansi' switch to the GNU C compiler, and standards conformance options such as `-std=c99', define __STRICT_ANSI__. If none of these are defined, or if _DEFAULT_SOURCE is defined, the default is to have _POSIX_SOURCE set to one and _POSIX_C_SOURCE set to 200809L, as well as enabling miscellaneous functions from BSD and SVID. If more than one of these are defined, they accumulate. For example __STRICT_ANSI__, _POSIX_SOURCE and _POSIX_C_SOURCE together give you ISO C, 1003.1, and 1003.2, but nothing else. These are defined by this file and are used by the header files to decide what to declare or define: __GLIBC_USE (F) Define things from feature set F. This is defined to 1 or 0; the subsequent macros are either defined or undefined, and those tests should be moved to __GLIBC_USE. __USE_ISOC11 Define ISO C11 things. __USE_ISOC99 Define ISO C99 things. __USE_ISOC95 Define ISO C90 AMD1 (C95) things. __USE_ISOCXX11 Define ISO C++11 things. __USE_POSIX Define IEEE Std 1003.1 things. __USE_POSIX2 Define IEEE Std 1003.2 things. __USE_POSIX199309 Define IEEE Std 1003.1, and .1b things. __USE_POSIX199506 Define IEEE Std 1003.1, .1b, .1c and .1i things. __USE_XOPEN Define XPG things. __USE_XOPEN_EXTENDED Define X/Open Unix things. __USE_UNIX98 Define Single Unix V2 things. __USE_XOPEN2K Define XPG6 things. __USE_XOPEN2KXSI Define XPG6 XSI things. __USE_XOPEN2K8 Define XPG7 things. __USE_XOPEN2K8XSI Define XPG7 XSI things. __USE_LARGEFILE Define correct standard I/O things. __USE_LARGEFILE64 Define LFS things with separate names. __USE_FILE_OFFSET64 Define 64bit interface as default. __USE_MISC Define things from 4.3BSD or System V Unix. __USE_ATFILE Define at interfaces and AT_* constants for them. __USE_DYNAMIC_STACK_SIZE Define correct (but non compile-time constant) MINSIGSTKSZ, SIGSTKSZ and PTHREAD_STACK_MIN. __USE_GNU Define GNU extensions. __USE_FORTIFY_LEVEL Additional security measures used, according to level. The macros `__GNU_LIBRARY__', `__GLIBC__', and `__GLIBC_MINOR__' are defined by this file unconditionally. `__GNU_LIBRARY__' is provided only for compatibility. All new code should use the other symbols to test for features. All macros listed above as possibly being defined by this file are explicitly undefined if they are not explicitly defined. Feature-test macros that are not defined by the user or compiler but are implied by the other feature-test macros defined (or by the lack of any definitions) are defined by the file. ISO C feature test macros depend on the definition of the macro when an affected header is included, not when the first system header is included, and so they are handled in <bits/libc-header-start.h>, which does not have a multiple include guard. Feature test macros that can be handled from the first system header included are handled here. / / Undefine everything, so we get a clean slate. / #undef __USE_ISOC11 #undef __USE_ISOC99 #undef __USE_ISOC95 #undef __USE_ISOCXX11 #undef __USE_POSIX #undef __USE_POSIX2 #undef __USE_POSIX199309 #undef __USE_POSIX199506 #undef __USE_XOPEN #undef __USE_XOPEN_EXTENDED #undef __USE_UNIX98 #undef __USE_XOPEN2K #undef __USE_XOPEN2KXSI #undef __USE_XOPEN2K8 #undef __USE_XOPEN2K8XSI #undef __USE_LARGEFILE #undef __USE_LARGEFILE64 #undef __USE_FILE_OFFSET64 #undef __USE_MISC #undef __USE_ATFILE #undef __USE_DYNAMIC_STACK_SIZE #undef __USE_GNU #undef __USE_FORTIFY_LEVEL #undef __KERNEL_STRICT_NAMES #undef __GLIBC_USE_ISOC2X #undef __GLIBC_USE_DEPRECATED_GETS #undef __GLIBC_USE_DEPRECATED_SCANF / Suppress kernel-name space pollution unless user expressedly asks for it. / #ifndef _LOOSE_KERNEL_NAMES # define __KERNEL_STRICT_NAMES #endif / Convenience macro to test the version of gcc. Use like this: #if __GNUC_PREREQ (2,8) ... code requiring gcc 2.8 or later ... #endif Note: only works for GCC 2.0 and later, because __GNUC_MINOR__ was added in 2.0. / #if defined __GNUC__ && defined __GNUC_MINOR__ # define __GNUC_PREREQ(maj, min) \ ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) #else # define __GNUC_PREREQ(maj, min) 0 #endif / Similarly for clang. Features added to GCC after version 4.2 may or may not also be available in clang, and clang's definitions of __GNUC(_MINOR)__ are fixed at 4 and 2 respectively. Not all such features can be queried via __has_extension/__has_feature. / #if defined __clang_major__ && defined __clang_minor__ # define __glibc_clang_prereq(maj, min) \ ((__clang_major__ << 16) + __clang_minor__ >= ((maj) << 16) + (min)) #else # define __glibc_clang_prereq(maj, min) 0 #endif / Whether to use feature set F. / #define __GLIBC_USE(F) __GLIBC_USE_ ## F / _BSD_SOURCE and _SVID_SOURCE are deprecated aliases for _DEFAULT_SOURCE. If _DEFAULT_SOURCE is present we do not issue a warning; the expectation is that the source is being transitioned to use the new macro. / #if (defined _BSD_SOURCE \|\| defined _SVID_SOURCE) \ && !defined _DEFAULT_SOURCE # warning "_BSD_SOURCE and _SVID_SOURCE are deprecated, use _DEFAULT_SOURCE" # undef _DEFAULT_SOURCE # define _DEFAULT_SOURCE 1 #endif / If _GNU_SOURCE was defined by the user, turn on all the other features. / #ifdef _GNU_SOURCE # undef _ISOC95_SOURCE # define _ISOC95_SOURCE 1 # undef _ISOC99_SOURCE # define _ISOC99_SOURCE 1 # undef _ISOC11_SOURCE # define _ISOC11_SOURCE 1 # undef _ISOC2X_SOURCE # define _ISOC2X_SOURCE 1 # undef _POSIX_SOURCE # define _POSIX_SOURCE 1 # undef _POSIX_C_SOURCE # define _POSIX_C_SOURCE 200809L # undef _XOPEN_SOURCE # define _XOPEN_SOURCE 700 # undef _XOPEN_SOURCE_EXTENDED # define _XOPEN_SOURCE_EXTENDED 1 # undef _LARGEFILE64_SOURCE # define _LARGEFILE64_SOURCE 1 # undef _DEFAULT_SOURCE # define _DEFAULT_SOURCE 1 # undef _ATFILE_SOURCE # define _ATFILE_SOURCE 1 # undef _DYNAMIC_STACK_SIZE_SOURCE # define _DYNAMIC_STACK_SIZE_SOURCE 1 #endif / If nothing (other than _GNU_SOURCE and _DEFAULT_SOURCE) is defined, define _DEFAULT_SOURCE. / #if (defined _DEFAULT_SOURCE \ \|\| (!defined __STRICT_ANSI__ \ && !defined _ISOC99_SOURCE && !defined _ISOC11_SOURCE \ && !defined _ISOC2X_SOURCE \ && !defined _POSIX_SOURCE && !defined _POSIX_C_SOURCE \ && !defined _XOPEN_SOURCE)) # undef _DEFAULT_SOURCE # define _DEFAULT_SOURCE 1 #endif / This is to enable the ISO C2X extension. / #if (defined _ISOC2X_SOURCE \ \|\| (defined __STDC_VERSION__ && __STDC_VERSION__ > 201710L)) # define __GLIBC_USE_ISOC2X 1 #else # define __GLIBC_USE_ISOC2X 0 #endif / This is to enable the ISO C11 extension. / #if (defined _ISOC11_SOURCE \|\| defined _ISOC2X_SOURCE \ \|\| (defined __STDC_VERSION__ && __STDC_VERSION__ >= 201112L)) # define __USE_ISOC11 1 #endif / This is to enable the ISO C99 extension. / #if (defined _ISOC99_SOURCE \|\| defined _ISOC11_SOURCE \ \|\| defined _ISOC2X_SOURCE \ \|\| (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L)) # define __USE_ISOC99 1 #endif / This is to enable the ISO C90 Amendment 1:1995 extension. / #if (defined _ISOC99_SOURCE \|\| defined _ISOC11_SOURCE \ \|\| defined _ISOC2X_SOURCE \ \|\| (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199409L)) # define __USE_ISOC95 1 #endif #ifdef __cplusplus / This is to enable compatibility for ISO C++17. / # if __cplusplus >= 201703L # define __USE_ISOC11 1 # endif / This is to enable compatibility for ISO C++11. Check the temporary macro for now, too. / # if __cplusplus >= 201103L \|\| defined __GXX_EXPERIMENTAL_CXX0X__ # define __USE_ISOCXX11 1 # define __USE_ISOC99 1 # endif #endif / If none of the ANSI/POSIX macros are defined, or if _DEFAULT_SOURCE is defined, use POSIX.1-2008 (or another version depending on _XOPEN_SOURCE). / #ifdef _DEFAULT_SOURCE # if !defined _POSIX_SOURCE && !defined _POSIX_C_SOURCE # define __USE_POSIX_IMPLICITLY 1 # endif # undef _POSIX_SOURCE # define _POSIX_SOURCE 1 # undef _POSIX_C_SOURCE # define _POSIX_C_SOURCE 200809L #endif #if ((!defined __STRICT_ANSI__ \ \|\| (defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) >= 500)) \ && !defined _POSIX_SOURCE && !defined _POSIX_C_SOURCE) # define _POSIX_SOURCE 1 # if defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) < 500 # define _POSIX_C_SOURCE 2 # elif defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) < 600 # define _POSIX_C_SOURCE 199506L # elif defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) < 700 # define _POSIX_C_SOURCE 200112L # else # define _POSIX_C_SOURCE 200809L # endif # define __USE_POSIX_IMPLICITLY 1 #endif / Some C libraries once required _REENTRANT and/or _THREAD_SAFE to be defined in all multithreaded code. GNU libc has not required this for many years. We now treat them as compatibility synonyms for _POSIX_C_SOURCE=199506L, which is the earliest level of POSIX with comprehensive support for multithreaded code. Using them never lowers the selected level of POSIX conformance, only raises it. / #if ((!defined _POSIX_C_SOURCE \|\| (_POSIX_C_SOURCE - 0) < 199506L) \ && (defined _REENTRANT \|\| defined _THREAD_SAFE)) # define _POSIX_SOURCE 1 # undef _POSIX_C_SOURCE # define _POSIX_C_SOURCE 199506L #endif #if (defined _POSIX_SOURCE \ \|\| (defined _POSIX_C_SOURCE && _POSIX_C_SOURCE >= 1) \ \|\| defined _XOPEN_SOURCE) # define __USE_POSIX 1 #endif #if defined _POSIX_C_SOURCE && _POSIX_C_SOURCE >= 2 \|\| defined _XOPEN_SOURCE # define __USE_POSIX2 1 #endif #if defined _POSIX_C_SOURCE && (_POSIX_C_SOURCE - 0) >= 199309L # define __USE_POSIX199309 1 #endif #if defined _POSIX_C_SOURCE && (_POSIX_C_SOURCE - 0) >= 199506L # define __USE_POSIX199506 1 #endif #if defined _POSIX_C_SOURCE && (_POSIX_C_SOURCE - 0) >= 200112L # define __USE_XOPEN2K 1 # undef __USE_ISOC95 # define __USE_ISOC95 1 # undef __USE_ISOC99 # define __USE_ISOC99 1 #endif #if defined _POSIX_C_SOURCE && (_POSIX_C_SOURCE - 0) >= 200809L # define __USE_XOPEN2K8 1 # undef _ATFILE_SOURCE # define _ATFILE_SOURCE 1 #endif #ifdef _XOPEN_SOURCE # define __USE_XOPEN 1 # if (_XOPEN_SOURCE - 0) >= 500 # define __USE_XOPEN_EXTENDED 1 # define __USE_UNIX98 1 # undef _LARGEFILE_SOURCE # define _LARGEFILE_SOURCE 1 # if (_XOPEN_SOURCE - 0) >= 600 # if (_XOPEN_SOURCE - 0) >= 700 # define __USE_XOPEN2K8 1 # define __USE_XOPEN2K8XSI 1 # endif # define __USE_XOPEN2K 1 # define __USE_XOPEN2KXSI 1 # undef __USE_ISOC95 # define __USE_ISOC95 1 # undef __USE_ISOC99 # define __USE_ISOC99 1 # endif # else # ifdef _XOPEN_SOURCE_EXTENDED # define __USE_XOPEN_EXTENDED 1 # endif # endif #endif #ifdef _LARGEFILE_SOURCE # define __USE_LARGEFILE 1 #endif #ifdef _LARGEFILE64_SOURCE # define __USE_LARGEFILE64 1 #endif #if defined _FILE_OFFSET_BITS && _FILE_OFFSET_BITS == 64 # define __USE_FILE_OFFSET64 1 #endif #include <features-time64.h> #if defined _DEFAULT_SOURCE # define __USE_MISC 1 #endif #ifdef _ATFILE_SOURCE # define __USE_ATFILE 1 #endif #ifdef _DYNAMIC_STACK_SIZE_SOURCE # define __USE_DYNAMIC_STACK_SIZE 1 #endif #ifdef _GNU_SOURCE # define __USE_GNU 1 #endif #if defined _FORTIFY_SOURCE && _FORTIFY_SOURCE > 0 # if !defined __OPTIMIZE__ \|\| __OPTIMIZE__ <= 0 # warning _FORTIFY_SOURCE requires compiling with optimization (-O) # elif !__GNUC_PREREQ (4, 1) # warning _FORTIFY_SOURCE requires GCC 4.1 or later # elif _FORTIFY_SOURCE > 2 && (__glibc_clang_prereq (9, 0) \ \|\| __GNUC_PREREQ (12, 0)) # if _FORTIFY_SOURCE > 3 # warning _FORTIFY_SOURCE > 3 is treated like 3 on this platform # endif # define __USE_FORTIFY_LEVEL 3 # elif _FORTIFY_SOURCE > 1 # if _FORTIFY_SOURCE > 2 # warning _FORTIFY_SOURCE > 2 is treated like 2 on this platform # endif # define __USE_FORTIFY_LEVEL 2 # else # define __USE_FORTIFY_LEVEL 1 # endif #endif #ifndef __USE_FORTIFY_LEVEL # define __USE_FORTIFY_LEVEL 0 #endif / The function 'gets' existed in C89, but is impossible to use safely. It has been removed from ISO C11 and ISO C++14. Note: for compatibility with various implementations of <cstdio>, this test must consider only the value of __cplusplus when compiling C++. / #if defined __cplusplus ? __cplusplus >= 201402L : defined __USE_ISOC11 # define __GLIBC_USE_DEPRECATED_GETS 0 #else # define __GLIBC_USE_DEPRECATED_GETS 1 #endif / GNU formerly extended the scanf functions with modified format specifiers %as, %aS, and %a[...] that allocate a buffer for the input using malloc. This extension conflicts with ISO C99, which defines %a as a standalone format specifier that reads a floating- point number; moreover, POSIX.1-2008 provides the same feature using the modifier letter 'm' instead (%ms, %mS, %m[...]). We now follow C99 unless GNU extensions are active and the compiler is specifically in C89 or C++98 mode (strict or not). For instance, with GCC, -std=gnu11 will have C99-compliant scanf with or without -D_GNU_SOURCE, but -std=c89 -D_GNU_SOURCE will have the old extension. / #if (defined __USE_GNU \ && (defined __cplusplus \ ? (__cplusplus < 201103L && !defined __GXX_EXPERIMENTAL_CXX0X__) \ : (!defined __STDC_VERSION__ \|\| __STDC_VERSION__ < 199901L))) # define __GLIBC_USE_DEPRECATED_SCANF 1 #else # define __GLIBC_USE_DEPRECATED_SCANF 0 #endif / Get definitions of __STDC_* predefined macros, if the compiler has not preincluded this header automatically. / #include <stdc-predef.h> / This macro indicates that the installed library is the GNU C Library. For historic reasons the value now is 6 and this will stay from now on. The use of this variable is deprecated. Use __GLIBC__ and __GLIBC_MINOR__ now (see below) when you want to test for a specific GNU C library version and use the values in <gnu/lib-names.h> to get the sonames of the shared libraries. / #undef __GNU_LIBRARY__ #define __GNU_LIBRARY__ 6 / Major and minor version number of the GNU C library package. Use these macros to test for features in specific releases. / #define __GLIBC__ 2 #define __GLIBC_MINOR__ 34 #define __GLIBC_PREREQ(maj, min) \ ((__GLIBC__ << 16) + __GLIBC_MINOR__ >= ((maj) << 16) + (min)) / This is here only because every header file already includes this one. / #ifndef __ASSEMBLER__ # ifndef _SYS_CDEFS_H # include <sys/cdefs.h> # endif / If we don't have __REDIRECT, prototypes will be missing if __USE_FILE_OFFSET64 but not __USE_LARGEFILE[64]. / # if defined __USE_FILE_OFFSET64 && !defined __REDIRECT # define __USE_LARGEFILE 1 # define __USE_LARGEFILE64 1 # endif #endif / !ASSEMBLER / / Decide whether we can define 'extern inline' functions in headers. / #if __GNUC_PREREQ (2, 7) && defined __OPTIMIZE__ \ && !defined __OPTIMIZE_SIZE__ && !defined __NO_INLINE__ \ && defined __extern_inline # define __USE_EXTERN_INLINES 1 #endif / This is here only because every header file already includes this one. Get the definitions of all the appropriate `__stub_FUNCTION' symbols. <gnu/stubs.h> contains `#define __stub_FUNCTION' when FUNCTION is a stub that will always return failure (and set errno to ENOSYS). / #include <gnu/stubs.h> #endif / features.h */	17.69 KB	2026-02-17 11:01
📄 fenv.h /* Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99 7.6: Floating-point environment <fenv.h> / #ifndef _FENV_H #define _FENV_H 1 #define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION #include <bits/libc-header-start.h> / Get the architecture dependend definitions. The following definitions are expected to be done: fenv_t type for object representing an entire floating-point environment FE_DFL_ENV macro of type pointer to fenv_t to be used as the argument to functions taking an argument of type fenv_t; in this case the default environment will be used fexcept_t type for object representing the floating-point exception flags including status associated with the flags femode_t type for object representing floating-point control modes FE_DFL_MODE macro of type pointer to const femode_t to be used as the argument to fesetmode; in this case the default control modes will be used The following macros are defined iff the implementation supports this kind of exception. FE_INEXACT inexact result FE_DIVBYZERO division by zero FE_UNDERFLOW result not representable due to underflow FE_OVERFLOW result not representable due to overflow FE_INVALID invalid operation FE_ALL_EXCEPT bitwise OR of all supported exceptions The next macros are defined iff the appropriate rounding mode is supported by the implementation. FE_TONEAREST round to nearest FE_UPWARD round toward +Inf FE_DOWNWARD round toward -Inf FE_TOWARDZERO round toward 0 / #include <bits/fenv.h> __BEGIN_DECLS / Floating-point exception handling. / / Clear the supported exceptions represented by EXCEPTS. / extern int feclearexcept (int __excepts) __THROW; / Store implementation-defined representation of the exception flags indicated by EXCEPTS in the object pointed to by FLAGP. / extern int fegetexceptflag (fexcept_t __flagp, int __excepts) __THROW; /* Raise the supported exceptions represented by EXCEPTS. / extern int feraiseexcept (int __excepts) __THROW; #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) / Set the supported exception flags represented by EXCEPTS, without causing enabled traps to be taken. / extern int fesetexcept (int __excepts) __THROW; #endif / Set complete status for exceptions indicated by EXCEPTS according to the representation in the object pointed to by FLAGP. / extern int fesetexceptflag (const fexcept_t __flagp, int __excepts) __THROW; /* Determine which of subset of the exceptions specified by EXCEPTS are currently set. / extern int fetestexcept (int __excepts) __THROW; #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) / Determine which of subset of the exceptions specified by EXCEPTS are set in FLAGP. / extern int fetestexceptflag (const fexcept_t __flagp, int __excepts) __THROW; #endif / Rounding control. / / Get current rounding direction. / extern int fegetround (void) __THROW __attribute_pure__; / Establish the rounding direction represented by ROUND. / extern int fesetround (int __rounding_direction) __THROW; / Floating-point environment. / / Store the current floating-point environment in the object pointed to by ENVP. / extern int fegetenv (fenv_t __envp) __THROW; /* Save the current environment in the object pointed to by ENVP, clear exception flags and install a non-stop mode (if available) for all exceptions. / extern int feholdexcept (fenv_t __envp) __THROW; /* Establish the floating-point environment represented by the object pointed to by ENVP. / extern int fesetenv (const fenv_t __envp) __THROW; /* Save current exceptions in temporary storage, install environment represented by object pointed to by ENVP and raise exceptions according to saved exceptions. / extern int feupdateenv (const fenv_t __envp) __THROW; /* Control modes. / #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) / Store the current floating-point control modes in the object pointed to by MODEP. / extern int fegetmode (femode_t __modep) __THROW; /* Establish the floating-point control modes represented by the object pointed to by MODEP. / extern int fesetmode (const femode_t __modep) __THROW; #endif /* NaN support. / #if (__GLIBC_USE (IEC_60559_BFP_EXT_C2X) \ && defined FE_INVALID \ && defined __SUPPORT_SNAN__) # define FE_SNANS_ALWAYS_SIGNAL 1 #endif #ifdef __USE_GNU / Enable individual exceptions. Will not enable more exceptions than EXCEPTS specifies. Returns the previous enabled exceptions if all exceptions are successfully set, otherwise returns -1. / extern int feenableexcept (int __excepts) __THROW; / Disable individual exceptions. Will not disable more exceptions than EXCEPTS specifies. Returns the previous enabled exceptions if all exceptions are successfully disabled, otherwise returns -1. / extern int fedisableexcept (int __excepts) __THROW; / Return enabled exceptions. / extern int fegetexcept (void) __THROW; #endif __END_DECLS #endif / fenv.h */	5.65 KB	2026-02-17 11:01
📁 finclude	-	2026-03-21 15:44
📄 fmtmsg.h /* Message display handling. Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef __FMTMSG_H #define __FMTMSG_H 1 #include <features.h> __BEGIN_DECLS / Values to control `fmtmsg' function. / enum { MM_HARD = 0x001, / Source of the condition is hardware. / #define MM_HARD MM_HARD MM_SOFT = 0x002, / Source of the condition is software. / #define MM_SOFT MM_SOFT MM_FIRM = 0x004, / Source of the condition is firmware. / #define MM_FIRM MM_FIRM MM_APPL = 0x008, / Condition detected by application. / #define MM_APPL MM_APPL MM_UTIL = 0x010, / Condition detected by utility. / #define MM_UTIL MM_UTIL MM_OPSYS = 0x020, / Condition detected by operating system. / #define MM_OPSYS MM_OPSYS MM_RECOVER = 0x040, / Recoverable error. / #define MM_RECOVER MM_RECOVER MM_NRECOV = 0x080, / Non-recoverable error. / #define MM_NRECOV MM_NRECOV MM_PRINT = 0x100, / Display message in standard error. / #define MM_PRINT MM_PRINT MM_CONSOLE = 0x200 / Display message on system console. / #define MM_CONSOLE MM_CONSOLE }; / Values to be for SEVERITY parameter of `fmtmsg'. / enum { MM_NOSEV = 0, / No severity level provided for the message. / #define MM_NOSEV MM_NOSEV MM_HALT, / Error causing application to halt. / #define MM_HALT MM_HALT MM_ERROR, / Application has encountered a non-fatal fault. / #define MM_ERROR MM_ERROR MM_WARNING, / Application has detected unusual non-error condition. / #define MM_WARNING MM_WARNING MM_INFO / Informative message. / #define MM_INFO MM_INFO }; / Macros which can be used as null values for the arguments of `fmtmsg'. / #define MM_NULLLBL ((char ) 0) #define MM_NULLSEV 0 #define MM_NULLMC ((long int) 0) #define MM_NULLTXT ((char ) 0) #define MM_NULLACT ((char ) 0) #define MM_NULLTAG ((char ) 0) / Possible return values of `fmtmsg'. / enum { MM_NOTOK = -1, #define MM_NOTOK MM_NOTOK MM_OK = 0, #define MM_OK MM_OK MM_NOMSG = 1, #define MM_NOMSG MM_NOMSG MM_NOCON = 4 #define MM_NOCON MM_NOCON }; / Print message with given CLASSIFICATION, LABEL, SEVERITY, TEXT, ACTION and TAG to console or standard error. / extern int fmtmsg (long int __classification, const char __label, int __severity, const char __text, const char __action, const char __tag); #ifdef __USE_MISC / Add or remove severity level. / extern int addseverity (int __severity, const char __string) __THROW; #endif __END_DECLS #endif /* fmtmsg.h */	3.16 KB	2026-02-17 11:01
📄 fnmatch.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _FNMATCH_H #define _FNMATCH_H 1 #ifdef __cplusplus extern "C" { #endif / We #undef these before defining them because some losing systems (HP-UX A.08.07 for example) define these in <unistd.h>. / #undef FNM_PATHNAME #undef FNM_NOESCAPE #undef FNM_PERIOD / Bits set in the FLAGS argument to `fnmatch'. / #define FNM_PATHNAME (1 << 0) / No wildcard can ever match `/'. / #define FNM_NOESCAPE (1 << 1) / Backslashes don't quote special chars. / #define FNM_PERIOD (1 << 2) / Leading `.' is matched only explicitly. / #if !defined _POSIX_C_SOURCE \|\| _POSIX_C_SOURCE < 2 \|\| defined _GNU_SOURCE # define FNM_FILE_NAME FNM_PATHNAME / Preferred GNU name. / # define FNM_LEADING_DIR (1 << 3) / Ignore `/...' after a match. / # define FNM_CASEFOLD (1 << 4) / Compare without regard to case. / # define FNM_EXTMATCH (1 << 5) / Use ksh-like extended matching. / #endif / Value returned by `fnmatch' if STRING does not match PATTERN. / #define FNM_NOMATCH 1 / This value is returned if the implementation does not support `fnmatch'. Since this is not the case here it will never be returned but the conformance test suites still require the symbol to be defined. / #ifdef _XOPEN_SOURCE # define FNM_NOSYS (-1) #endif / Match NAME against the filename pattern PATTERN, returning zero if it matches, FNM_NOMATCH if not. / extern int fnmatch (const char __pattern, const char __name, int __flags); #ifdef __cplusplus } #endif #endif / fnmatch.h */	2.24 KB	2026-02-17 11:01
📄 fpu_control.h /* FPU control word bits. x86 version. Copyright (C) 1993-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Olaf Flebbe. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _FPU_CONTROL_H #define _FPU_CONTROL_H 1 / Note that this file sets on x86-64 only the x87 FPU, it does not touch the SSE unit. / / Here is the dirty part. Set up your 387 through the control word * (cw) register. * * 15-13 12 11-10 9-8 7-6 5 4 3 2 1 0 * \| reserved \| IC \| RC \| PC \| reserved \| PM \| UM \| OM \| ZM \| DM \| IM * * IM: Invalid operation mask * DM: Denormalized operand mask * ZM: Zero-divide mask * OM: Overflow mask * UM: Underflow mask * PM: Precision (inexact result) mask * * Mask bit is 1 means no interrupt. * * PC: Precision control * 11 - round to extended precision * 10 - round to double precision * 00 - round to single precision * * RC: Rounding control * 00 - rounding to nearest * 01 - rounding down (toward - infinity) * 10 - rounding up (toward + infinity) * 11 - rounding toward zero * * IC: Infinity control * That is for 8087 and 80287 only. * * The hardware default is 0x037f which we use. / #include <features.h> / masking of interrupts / #define _FPU_MASK_IM 0x01 #define _FPU_MASK_DM 0x02 #define _FPU_MASK_ZM 0x04 #define _FPU_MASK_OM 0x08 #define _FPU_MASK_UM 0x10 #define _FPU_MASK_PM 0x20 / precision control / #define _FPU_EXTENDED 0x300 / libm requires double extended precision. / #define _FPU_DOUBLE 0x200 #define _FPU_SINGLE 0x0 / rounding control / #define _FPU_RC_NEAREST 0x0 / RECOMMENDED / #define _FPU_RC_DOWN 0x400 #define _FPU_RC_UP 0x800 #define _FPU_RC_ZERO 0xC00 #define _FPU_RESERVED 0xF0C0 / Reserved bits in cw / / The fdlibm code requires strict IEEE double precision arithmetic, and no interrupts for exceptions, rounding to nearest. / #define _FPU_DEFAULT 0x037f / IEEE: same as above. / #define _FPU_IEEE 0x037f / Type of the control word. / typedef unsigned int fpu_control_t __attribute__ ((__mode__ (__HI__))); / Macros for accessing the hardware control word. "&" is used to work around a bug in older versions of GCC. __volatile__ is used to support combination of writing the control register and reading it back. Without __volatile__, the old value may be used for reading back under compiler optimization. Note that the use of these macros is not sufficient anymore with recent hardware nor on x86-64. Some floating point operations are executed in the SSE/SSE2 engines which have their own control and status register. / #define _FPU_GETCW(cw) __asm__ __volatile__ ("fnstcw %0" : "=m" (&cw)) #define _FPU_SETCW(cw) __asm__ __volatile__ ("fldcw %0" : : "m" (&cw)) /* Default control word set at startup. / extern fpu_control_t __fpu_control; #endif / fpu_control.h */	3.5 KB	2026-02-17 11:01
📄 fstab.h /* * Copyright (c) 1980, 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. * * @(#)fstab.h 8.1 (Berkeley) 6/2/93 / #ifndef _FSTAB_H #define _FSTAB_H 1 #include <features.h> / * File system table, see fstab(5). * * Used by dump, mount, umount, swapon, fsck, df, ... * * For ufs fs_spec field is the block special name. Programs that want to * use the character special name must create that name by prepending a 'r' * after the right most slash. Quota files are always named "quotas", so * if type is "rq", then use concatenation of fs_file and "quotas" to locate * quota file. / #define _PATH_FSTAB "/etc/fstab" #define FSTAB "/etc/fstab" / deprecated / #define FSTAB_RW "rw" / read/write device / #define FSTAB_RQ "rq" / read/write with quotas / #define FSTAB_RO "ro" / read-only device / #define FSTAB_SW "sw" / swap device / #define FSTAB_XX "xx" / ignore totally / struct fstab { char fs_spec; /* block special device name / char fs_file; /* file system path prefix / char fs_vfstype; /* File system type, ufs, nfs / char fs_mntops; /* Mount options ala -o / const char fs_type; /* FSTAB_* from fs_mntops / int fs_freq; / dump frequency, in days / int fs_passno; / pass number on parallel dump / }; __BEGIN_DECLS extern struct fstab getfsent (void) __THROW; extern struct fstab getfsspec (const char __name) __THROW; extern struct fstab getfsfile (const char __name) __THROW; extern int setfsent (void) __THROW; extern void endfsent (void) __THROW; __END_DECLS #endif /* fstab.h */	3.04 KB	2026-02-17 11:01
📄 fts.h /* File tree traversal functions declarations. Copyright (C) 1994-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * 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. * * @(#)fts.h 8.3 (Berkeley) 8/14/94 / #ifndef _FTS_H #define _FTS_H 1 #include <features.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 / int fts_pathlen; / sizeof(path) / int fts_nitems; / elements in the sort array / int (fts_compar) (const void , const void ); /* compare fn / #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_WHITEOUT 0x0080 / return whiteout information / #define FTS_OPTIONMASK 0x00ff / valid user option mask / #define FTS_NAMEONLY 0x0100 / (private) child names only / #define FTS_STOP 0x0200 / (private) unrecoverable error / int fts_options; / fts_open options, global flags / } FTS; #ifdef __USE_LARGEFILE64 typedef struct { struct _ftsent64 fts_cur; /* current node / struct _ftsent64 fts_child; /* linked list of children / struct _ftsent64 fts_array; / sort array / dev_t fts_dev; / starting device # / char fts_path; /* path for this descent / int fts_rfd; / fd for root / int fts_pathlen; / sizeof(path) / int fts_nitems; / elements in the sort array / int (fts_compar) (const void , const void ); /* compare fn / int fts_options; / fts_open options, global flags / } FTS64; #endif 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 / unsigned short fts_pathlen; / strlen(fts_path) / unsigned short 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 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 / #define FTS_W 14 / whiteout object / 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; #ifdef __USE_LARGEFILE64 typedef struct _ftsent64 { struct _ftsent64 fts_cycle; /* cycle node / struct _ftsent64 fts_parent; /* parent directory / struct _ftsent64 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 / unsigned short fts_pathlen; / strlen(fts_path) / unsigned short fts_namelen; / strlen(fts_name) / ino64_t fts_ino; / inode / dev_t fts_dev; / device / nlink_t fts_nlink; / link count / short fts_level; / depth (-1 to N) / unsigned short fts_info; / user flags for FTSENT structure / unsigned short fts_flags; / private flags for FTSENT structure / unsigned short fts_instr; / fts_set() instructions / struct stat64 fts_statp; /* stat(2) information / char fts_name[1]; / file name / } FTSENT64; #endif __BEGIN_DECLS #ifndef __USE_FILE_OFFSET64 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) __THROW; #else # ifdef __REDIRECT # ifndef __USE_TIME_BITS64 FTSENT __REDIRECT (fts_children, (FTS , int), fts64_children); int __REDIRECT (fts_close, (FTS ), fts64_close); FTS __REDIRECT (fts_open, (char * const , int, int ()(const FTSENT , const FTSENT )), fts64_open); FTSENT __REDIRECT (fts_read, (FTS ), fts64_read); int __REDIRECT_NTH (fts_set, (FTS , FTSENT , int), fts64_set); # else FTSENT __REDIRECT (fts_children, (FTS , int), __fts64_children_time64); int __REDIRECT (fts_close, (FTS ), __fts64_close_time64); FTS __REDIRECT (fts_open, (char * const , int, int ()(const FTSENT , const FTSENT )), __fts64_open_time64); FTSENT __REDIRECT (fts_read, (FTS ), __fts64_read_time64); int __REDIRECT_NTH (fts_set, (FTS , FTSENT , int), __fts64_set_time64); # endif # else # ifndef __USE_TIME_BITS64 # define fts_children fts64_children # define fts_close fts64_close # define fts_open fts64_open # define fts_read fts64_read # define fts_set fts64_set # else # endif # endif #endif #ifdef __USE_LARGEFILE64 # ifndef __USE_TIME_BITS64 FTSENT64 fts64_children (FTS64 , int); int fts64_close (FTS64 ); FTS64 fts64_open (char * const , int, int ()(const FTSENT64 , const FTSENT64 )); FTSENT64 fts64_read (FTS64 ); int fts64_set (FTS64 , FTSENT64 , int) __THROW; # else # ifdef __REDIRECT FTSENT __REDIRECT (fts64_children, (FTS64 , int), __fts64_children_time64); int __REDIRECT (fts64_close, (FTS64 ), __fts64_close_time64); FTS __REDIRECT (fts64_open, (char * const , int, int ()(const FTSENT64 , const FTSENT64 )), __fts64_open_time64); FTSENT __REDIRECT (fts64_read, (FTS64 ), __fts64_read_time64); int __REDIRECT_NTH (fts64_set, (FTS64 , FTSENT64 , int), __fts64_set_time64); # else # define fts_children __fts64_children_time64 # define fts_close __fts64_close_time64 # define fts_open __fts64_open_time64 # define fts_read __fts64_read_time64 # define fts_set __fts64_set_time64 # endif # endif #endif __END_DECLS #endif /* fts.h */	9.35 KB	2026-02-17 11:01
📄 ftw.h /* Copyright (C) 1992-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * X/Open Portability Guide 4.2: ftw.h / #ifndef _FTW_H #define _FTW_H 1 #include <features.h> #include <sys/types.h> #include <sys/stat.h> __BEGIN_DECLS / Values for the FLAG argument to the user function passed to `ftw' and 'nftw'. / enum { FTW_F, / Regular file. / #define FTW_F FTW_F FTW_D, / Directory. / #define FTW_D FTW_D FTW_DNR, / Unreadable directory. / #define FTW_DNR FTW_DNR FTW_NS, / Unstatable file. / #define FTW_NS FTW_NS #if defined __USE_MISC \|\| defined __USE_XOPEN_EXTENDED FTW_SL, / Symbolic link. / # define FTW_SL FTW_SL #endif #ifdef __USE_XOPEN_EXTENDED / These flags are only passed from the `nftw' function. / FTW_DP, / Directory, all subdirs have been visited. / # define FTW_DP FTW_DP FTW_SLN / Symbolic link naming non-existing file. / # define FTW_SLN FTW_SLN #endif / extended X/Open / }; #ifdef __USE_XOPEN_EXTENDED / Flags for fourth argument of `nftw'. / enum { FTW_PHYS = 1, / Perform physical walk, ignore symlinks. / # define FTW_PHYS FTW_PHYS FTW_MOUNT = 2, / Report only files on same file system as the argument. / # define FTW_MOUNT FTW_MOUNT FTW_CHDIR = 4, / Change to current directory while processing it. / # define FTW_CHDIR FTW_CHDIR FTW_DEPTH = 8 / Report files in directory before directory itself./ # define FTW_DEPTH FTW_DEPTH # ifdef __USE_GNU , FTW_ACTIONRETVAL = 16 / Assume callback to return FTW_* values instead of zero to continue and non-zero to terminate. / # define FTW_ACTIONRETVAL FTW_ACTIONRETVAL # endif }; #ifdef __USE_GNU / Return values from callback functions. / enum { FTW_CONTINUE = 0, / Continue with next sibling or for FTW_D with the first child. / # define FTW_CONTINUE FTW_CONTINUE FTW_STOP = 1, / Return from `ftw' or `nftw' with FTW_STOP as return value. / # define FTW_STOP FTW_STOP FTW_SKIP_SUBTREE = 2, / Only meaningful for FTW_D: Don't walk through the subtree, instead just continue with its next sibling. / # define FTW_SKIP_SUBTREE FTW_SKIP_SUBTREE FTW_SKIP_SIBLINGS = 3,/ Continue with FTW_DP callback for current directory (if FTW_DEPTH) and then its siblings. / # define FTW_SKIP_SIBLINGS FTW_SKIP_SIBLINGS }; #endif / Structure used for fourth argument to callback function for `nftw'. / struct FTW { int base; int level; }; #endif / extended X/Open / / Convenient types for callback functions. / typedef int (__ftw_func_t) (const char __filename, const struct stat __status, int __flag); #ifdef __USE_LARGEFILE64 typedef int (__ftw64_func_t) (const char __filename, const struct stat64 __status, int __flag); #endif #ifdef __USE_XOPEN_EXTENDED typedef int (__nftw_func_t) (const char __filename, const struct stat __status, int __flag, struct FTW __info); # ifdef __USE_LARGEFILE64 typedef int (__nftw64_func_t) (const char __filename, const struct stat64 __status, int __flag, struct FTW __info); # endif #endif / Call a function on every element in a directory tree. This function is a possible cancellation point and therefore not marked with __THROW. / #ifndef __USE_FILE_OFFSET64 extern int ftw (const char __dir, __ftw_func_t __func, int __descriptors) __nonnull ((1, 2)); #else # ifdef __REDIRECT # ifndef __USE_TIME_BITS64 extern int __REDIRECT (ftw, (const char __dir, __ftw_func_t __func, int __descriptors), ftw64) __nonnull ((1, 2)); # else extern int __REDIRECT (ftw, (const char __dir, __ftw_func_t __func, int __descriptors), __ftw64_time64) __nonnull ((1, 2)); # endif # else # ifndef __USE_TIME_BITS64 # define ftw ftw64 # else # define ftw __ftw64_time64 # endif # endif #endif #ifdef __USE_LARGEFILE64 # ifndef __USE_TIME_BITS64 extern int ftw64 (const char __dir, __ftw64_func_t __func, int __descriptors) __nonnull ((1, 2)); # else # ifdef __REDIRECT extern int __REDIRECT (ftw64, (const char __dir, __ftw64_func_t __func, int __descriptors), __ftw64_time64) __nonnull ((1, 2)); # else # define nftw64 __nftw64_time64 # endif # endif #endif #ifdef __USE_XOPEN_EXTENDED /* Call a function on every element in a directory tree. FLAG allows to specify the behaviour more detailed. This function is a possible cancellation point and therefore not marked with __THROW. / # ifndef __USE_FILE_OFFSET64 extern int nftw (const char __dir, __nftw_func_t __func, int __descriptors, int __flag) __nonnull ((1, 2)); # else # ifdef __REDIRECT # ifndef __USE_TIME_BITS64 extern int __REDIRECT (nftw, (const char __dir, __nftw_func_t __func, int __descriptors, int __flag), nftw64) __nonnull ((1, 2)); # else extern int __REDIRECT (nftw, (const char __dir, __nftw_func_t __func, int __descriptors, int __flag), __nftw64_time64) __nonnull ((1, 2)); # endif # else # ifndef __USE_TIME_BITS64 # define nftw nftw64 # else # define nftw __nftw64_time64 # endif # endif # endif # ifdef __USE_LARGEFILE64 # ifndef __USE_TIME_BITS64 extern int nftw64 (const char __dir, __nftw64_func_t __func, int __descriptors, int __flag) __nonnull ((1, 2)); # else # ifdef __REDIRECT extern int __REDIRECT (nftw64, (const char __dir, __nftw64_func_t __func, int __descriptors, int __flag), __nftw64_time64) __nonnull ((1, 2)); # else # define nftw64 __nftw64_time64 # endif # endif # endif #endif __END_DECLS #endif /* ftw.h */	6.19 KB	2026-02-17 11:01
📁 fwctl	-	2026-03-27 02:43
📄 gconv.h /* Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / This header provides no interface for a user to the internals of the gconv implementation in the libc. Therefore there is no use for these definitions beside for writing additional gconv modules. / #ifndef _GCONV_H #define _GCONV_H 1 #include <features.h> #include <bits/types/__mbstate_t.h> #include <bits/types/wint_t.h> #define __need_size_t #define __need_wchar_t #include <stddef.h> / ISO 10646 value used to signal invalid value. / #define __UNKNOWN_10646_CHAR ((wchar_t) 0xfffd) / Error codes for gconv functions. / enum { __GCONV_OK = 0, __GCONV_NOCONV, __GCONV_NODB, __GCONV_NOMEM, __GCONV_EMPTY_INPUT, __GCONV_FULL_OUTPUT, __GCONV_ILLEGAL_INPUT, __GCONV_INCOMPLETE_INPUT, __GCONV_ILLEGAL_DESCRIPTOR, __GCONV_INTERNAL_ERROR }; / Flags the `__gconv_open' function can set. / enum { __GCONV_IS_LAST = 0x0001, __GCONV_IGNORE_ERRORS = 0x0002, __GCONV_SWAP = 0x0004, __GCONV_TRANSLIT = 0x0008 }; / Forward declarations. / struct __gconv_step; struct __gconv_step_data; struct __gconv_loaded_object; / Type of a conversion function. / typedef int (__gconv_fct) (struct __gconv_step , struct __gconv_step_data , const unsigned char *, const unsigned char , unsigned char *, size_t , int, int); /* Type of a specialized conversion function for a single byte to INTERNAL. / typedef wint_t (__gconv_btowc_fct) (struct __gconv_step , unsigned char); / Constructor and destructor for local data for conversion step. / typedef int (__gconv_init_fct) (struct __gconv_step ); typedef void (__gconv_end_fct) (struct __gconv_step ); / Description of a conversion step. / struct __gconv_step { struct __gconv_loaded_object __shlib_handle; const char __modname; / For internal use by glibc. (Accesses to this member must occur when the internal __gconv_lock mutex is acquired). / int __counter; char __from_name; char __to_name; __gconv_fct __fct; __gconv_btowc_fct __btowc_fct; __gconv_init_fct __init_fct; __gconv_end_fct __end_fct; / Information about the number of bytes needed or produced in this step. This helps optimizing the buffer sizes. / int __min_needed_from; int __max_needed_from; int __min_needed_to; int __max_needed_to; / Flag whether this is a stateful encoding or not. / int __stateful; void __data; /* Pointer to step-local data. / }; / Additional data for steps in use of conversion descriptor. This is allocated by the `init' function. / struct __gconv_step_data { unsigned char __outbuf; /* Output buffer for this step. / unsigned char __outbufend; /* Address of first byte after the output buffer. / / Is this the last module in the chain. / int __flags; / Counter for number of invocations of the module function for this descriptor. / int __invocation_counter; / Flag whether this is an internal use of the module (in the mbtowc and wctomb functions) or regular with iconv(3). / int __internal_use; __mbstate_t __statep; __mbstate_t __state; /* This element must not be used directly by any module; always use STATEP! / }; / Combine conversion step description with data. / typedef struct __gconv_info { size_t __nsteps; struct __gconv_step __steps; __extension__ struct __gconv_step_data __data[0]; } __gconv_t; #endif / gconv.h */	4.11 KB	2026-02-17 11:01
📁 gdb	-	2026-03-21 15:53
📄 gelf.h /* This file defines generic ELF types, structures, and macros. Copyright (C) 1999, 2000, 2001, 2002, 2004, 2005, 2007, 2015 Red Hat, Inc. This file is part of elfutils. This file is free software; you can redistribute it and/or modify it under the terms of either * the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version or * the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version or both in parallel, as here. elfutils is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received copies of the GNU General Public License and the GNU Lesser General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. / #ifndef _GELF_H #define _GELF_H 1 #include <libelf.h> #ifdef __cplusplus extern "C" { #endif / Class independent type definitions. Correctly speaking this is not true. We assume that 64-bit binaries are the largest class and therefore all other classes can be represented without loss. / / Type for a 16-bit quantity. / typedef Elf64_Half GElf_Half; / Types for signed and unsigned 32-bit quantities. / typedef Elf64_Word GElf_Word; typedef Elf64_Sword GElf_Sword; / Types for signed and unsigned 64-bit quantities. / typedef Elf64_Xword GElf_Xword; typedef Elf64_Sxword GElf_Sxword; / Type of addresses. / typedef Elf64_Addr GElf_Addr; / Type of file offsets. / typedef Elf64_Off GElf_Off; / The ELF file header. This appears at the start of every ELF file. / typedef Elf64_Ehdr GElf_Ehdr; / Section header. / typedef Elf64_Shdr GElf_Shdr; / Section index. / / XXX This should probably be a larger type in preparation of times when regular section indices can be larger. / typedef Elf64_Section GElf_Section; / Symbol table entry. / typedef Elf64_Sym GElf_Sym; / The syminfo section if available contains additional information about every dynamic symbol. / typedef Elf64_Syminfo GElf_Syminfo; / Relocation table entry without addend (in section of type SHT_REL). / typedef Elf64_Rel GElf_Rel; / Relocation table entry with addend (in section of type SHT_RELA). / typedef Elf64_Rela GElf_Rela; / Relative relocation entry (in section of type SHT_RELR). / typedef Elf64_Relr GElf_Relr; / Program segment header. / typedef Elf64_Phdr GElf_Phdr; / Header of a compressed section. / typedef Elf64_Chdr GElf_Chdr; / Dynamic section entry. / typedef Elf64_Dyn GElf_Dyn; / Version definition sections. / typedef Elf64_Verdef GElf_Verdef; / Auxiliary version information. / typedef Elf64_Verdaux GElf_Verdaux; / Version dependency section. / typedef Elf64_Verneed GElf_Verneed; / Auxiliary needed version information. / typedef Elf64_Vernaux GElf_Vernaux; / Type for version symbol information. / typedef Elf64_Versym GElf_Versym; / Auxiliary vector. / typedef Elf64_auxv_t GElf_auxv_t; / Note section contents. / typedef Elf64_Nhdr GElf_Nhdr; / Move structure. / typedef Elf64_Move GElf_Move; / Library list structure. / typedef Elf64_Lib GElf_Lib; / How to extract and insert information held in the st_info field. / #define GELF_ST_BIND(val) ELF64_ST_BIND (val) #define GELF_ST_TYPE(val) ELF64_ST_TYPE (val) #define GELF_ST_INFO(bind, type) ELF64_ST_INFO (bind, type) / How to extract information held in the st_other field. / #define GELF_ST_VISIBILITY(val) ELF64_ST_VISIBILITY (val) / How to extract and insert information held in the r_info field. / #define GELF_R_SYM(info) ELF64_R_SYM (info) #define GELF_R_TYPE(info) ELF64_R_TYPE (info) #define GELF_R_INFO(sym, type) ELF64_R_INFO (sym, type) / How to extract and insert information held in the m_info field. / #define GELF_M_SYM(info) ELF64_M_SYM (info) #define GELF_M_SIZE(info) ELF64_M_SIZE (info) #define GELF_M_INFO(sym, size) ELF64_M_INFO (sym, size) / Get class of the file associated with ELF. / extern int gelf_getclass (Elf __elf); /* Return size of array of COUNT elements of the type denoted by TYPE in the external representation. The binary class is taken from ELF. The result is based on version VERSION of the ELF standard. / extern size_t gelf_fsize (Elf __elf, Elf_Type __type, size_t __count, unsigned int __version); /* Retrieve object file header. / extern GElf_Ehdr gelf_getehdr (Elf __elf, GElf_Ehdr __dest); /* Update the ELF header. / extern int gelf_update_ehdr (Elf __elf, GElf_Ehdr __src); / Create new ELF header if none exists. Creates an Elf32_Ehdr if CLASS is ELFCLASS32 or an Elf64_Ehdr if CLASS is ELFCLASS64. Returns NULL on error. / extern void gelf_newehdr (Elf __elf, int __class); / Get section at OFFSET. / extern Elf_Scn gelf_offscn (Elf __elf, GElf_Off __offset); / Retrieve section header. / extern GElf_Shdr gelf_getshdr (Elf_Scn __scn, GElf_Shdr __dst); /* Update section header. / extern int gelf_update_shdr (Elf_Scn __scn, GElf_Shdr __src); / Retrieve program header table entry. / extern GElf_Phdr gelf_getphdr (Elf __elf, int __ndx, GElf_Phdr __dst); /* Update the program header. / extern int gelf_update_phdr (Elf __elf, int __ndx, GElf_Phdr __src); / Create new program header with PHNUM entries. Creates either an Elf32_Phdr or an Elf64_Phdr depending on whether the given ELF is ELFCLASS32 or ELFCLASS64. Returns NULL on error. / extern void gelf_newphdr (Elf __elf, size_t __phnum); / Get compression header of section if any. Returns NULL and sets elf_errno if the section isn't compressed or an error occurred. / extern GElf_Chdr gelf_getchdr (Elf_Scn __scn, GElf_Chdr __dst); /* Convert data structure from the representation in the file represented by ELF to their memory representation. / extern Elf_Data gelf_xlatetom (Elf __elf, Elf_Data __dest, const Elf_Data __src, unsigned int __encode); / Convert data structure from to the representation in memory represented by ELF file representation. / extern Elf_Data gelf_xlatetof (Elf __elf, Elf_Data __dest, const Elf_Data __src, unsigned int __encode); / Retrieve REL relocation info at the given index. / extern GElf_Rel gelf_getrel (Elf_Data __data, int __ndx, GElf_Rel __dst); /* Retrieve RELA relocation info at the given index. / extern GElf_Rela gelf_getrela (Elf_Data __data, int __ndx, GElf_Rela __dst); /* Update REL relocation information at given index. / extern int gelf_update_rel (Elf_Data __dst, int __ndx, GElf_Rel __src); / Update RELA relocation information at given index. / extern int gelf_update_rela (Elf_Data __dst, int __ndx, GElf_Rela __src); / Retrieve symbol information from the symbol table at the given index. / extern GElf_Sym gelf_getsym (Elf_Data __data, int __ndx, GElf_Sym __dst); /* Update symbol information in the symbol table at the given index. / extern int gelf_update_sym (Elf_Data __data, int __ndx, GElf_Sym __src); / Retrieve symbol information and separate section index from the symbol table at the given index. / extern GElf_Sym gelf_getsymshndx (Elf_Data __symdata, Elf_Data __shndxdata, int __ndx, GElf_Sym __sym, Elf32_Word __xshndx); /* Update symbol information and separate section index in the symbol table at the given index. / extern int gelf_update_symshndx (Elf_Data __symdata, Elf_Data __shndxdata, int __ndx, GElf_Sym __sym, Elf32_Word __xshndx); /* Retrieve additional symbol information from the symbol table at the given index. / extern GElf_Syminfo gelf_getsyminfo (Elf_Data __data, int __ndx, GElf_Syminfo __dst); /* Update additional symbol information in the symbol table at the given index. / extern int gelf_update_syminfo (Elf_Data __data, int __ndx, GElf_Syminfo __src); / Get information from dynamic table at the given index. / extern GElf_Dyn gelf_getdyn (Elf_Data __data, int __ndx, GElf_Dyn __dst); /* Update information in dynamic table at the given index. / extern int gelf_update_dyn (Elf_Data __dst, int __ndx, GElf_Dyn __src); / Get move structure at the given index. / extern GElf_Move gelf_getmove (Elf_Data __data, int __ndx, GElf_Move __dst); /* Update move structure at the given index. / extern int gelf_update_move (Elf_Data __data, int __ndx, GElf_Move __src); / Get library from table at the given index. / extern GElf_Lib gelf_getlib (Elf_Data __data, int __ndx, GElf_Lib __dst); /* Update library in table at the given index. / extern int gelf_update_lib (Elf_Data __data, int __ndx, GElf_Lib __src); / Retrieve symbol version information at given index. / extern GElf_Versym gelf_getversym (Elf_Data __data, int __ndx, GElf_Versym __dst); /* Update symbol version information. / extern int gelf_update_versym (Elf_Data __data, int __ndx, GElf_Versym __src); / Retrieve required symbol version information at given offset. / extern GElf_Verneed gelf_getverneed (Elf_Data __data, int __offset, GElf_Verneed __dst); /* Update required symbol version information. / extern int gelf_update_verneed (Elf_Data __data, int __offset, GElf_Verneed __src); / Retrieve additional required symbol version information at given offset. / extern GElf_Vernaux gelf_getvernaux (Elf_Data __data, int __offset, GElf_Vernaux __dst); /* Update additional required symbol version information. / extern int gelf_update_vernaux (Elf_Data __data, int __offset, GElf_Vernaux __src); / Retrieve symbol version definition information at given offset. / extern GElf_Verdef gelf_getverdef (Elf_Data __data, int __offset, GElf_Verdef __dst); /* Update symbol version definition information. / extern int gelf_update_verdef (Elf_Data __data, int __offset, GElf_Verdef __src); / Retrieve additional symbol version definition information at given offset. / extern GElf_Verdaux gelf_getverdaux (Elf_Data __data, int __offset, GElf_Verdaux __dst); /* Update additional symbol version definition information. / extern int gelf_update_verdaux (Elf_Data __data, int __offset, GElf_Verdaux __src); / Get auxv entry at the given index. / extern GElf_auxv_t gelf_getauxv (Elf_Data __data, int __ndx, GElf_auxv_t __dst); /* Update auxv entry at the given index. / extern int gelf_update_auxv (Elf_Data __data, int __ndx, GElf_auxv_t __src); / Get note header at the given offset into the data, and the offsets of the note's name and descriptor data. Returns the offset of the next note header, or 0 for an invalid offset or corrupt note header. / extern size_t gelf_getnote (Elf_Data __data, size_t __offset, GElf_Nhdr __result, size_t __name_offset, size_t __desc_offset); / Compute simple checksum from permanent parts of the ELF file. / extern long int gelf_checksum (Elf __elf); #ifdef __cplusplus } #endif #endif /* gelf.h */	11.14 KB	2025-04-25 20:16
📄 getopt.h /* Declarations for getopt. Copyright (C) 1989-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. Unlike the bulk of the getopt implementation, this file is NOT part of gnulib; gnulib also has a getopt.h but it is different. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _GETOPT_H #define _GETOPT_H 1 #include <features.h> / The type of the 'argv' argument to getopt_long and getopt_long_only is properly 'char *', since both functions may write to the array (in order to move all the options to the beginning). However, for compatibility with old versions of LSB, glibc has to use 'char const ' instead. / #ifndef __getopt_argv_const # define __getopt_argv_const const #endif #include <bits/getopt_core.h> #include <bits/getopt_ext.h> #endif /* getopt.h */	1.43 KB	2026-02-17 11:01
📄 glob.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _GLOB_H #define _GLOB_H 1 #include <sys/cdefs.h> __BEGIN_DECLS / We need `size_t' for the following definitions. / #ifndef __size_t typedef __SIZE_TYPE__ __size_t; # if defined __USE_XOPEN \|\| defined __USE_XOPEN2K8 typedef __SIZE_TYPE__ size_t; # endif #else / The GNU CC stddef.h version defines __size_t as empty. We need a real definition. / # undef __size_t # define __size_t size_t #endif / Bits set in the FLAGS argument to `glob'. / #define GLOB_ERR (1 << 0)/ Return on read errors. / #define GLOB_MARK (1 << 1)/ Append a slash to each name. / #define GLOB_NOSORT (1 << 2)/ Don't sort the names. / #define GLOB_DOOFFS (1 << 3)/ Insert PGLOB->gl_offs NULLs. / #define GLOB_NOCHECK (1 << 4)/ If nothing matches, return the pattern. / #define GLOB_APPEND (1 << 5)/ Append to results of a previous call. / #define GLOB_NOESCAPE (1 << 6)/ Backslashes don't quote metacharacters. / #define GLOB_PERIOD (1 << 7)/ Leading `.' can be matched by metachars. / #if !defined __USE_POSIX2 \|\| defined __USE_MISC # define GLOB_MAGCHAR (1 << 8)/ Set in gl_flags if any metachars seen. / # define GLOB_ALTDIRFUNC (1 << 9)/ Use gl_opendir et al functions. / # define GLOB_BRACE (1 << 10)/ Expand "{a,b}" to "a" "b". / # define GLOB_NOMAGIC (1 << 11)/ If no magic chars, return the pattern. / # define GLOB_TILDE (1 << 12)/ Expand ~user and ~ to home directories. / # define GLOB_ONLYDIR (1 << 13)/ Match only directories. / # define GLOB_TILDE_CHECK (1 << 14)/ Like GLOB_TILDE but return an error if the user name is not available. / # define __GLOB_FLAGS (GLOB_ERR\|GLOB_MARK\|GLOB_NOSORT\|GLOB_DOOFFS \ \|GLOB_NOESCAPE\|GLOB_NOCHECK\|GLOB_APPEND \ \|GLOB_PERIOD\|GLOB_ALTDIRFUNC\|GLOB_BRACE \ \|GLOB_NOMAGIC\|GLOB_TILDE\|GLOB_ONLYDIR\|GLOB_TILDE_CHECK) #else # define __GLOB_FLAGS (GLOB_ERR\|GLOB_MARK\|GLOB_NOSORT\|GLOB_DOOFFS \ \|GLOB_NOESCAPE\|GLOB_NOCHECK\|GLOB_APPEND \ \|GLOB_PERIOD) #endif / Error returns from `glob'. / #define GLOB_NOSPACE 1 / Ran out of memory. / #define GLOB_ABORTED 2 / Read error. / #define GLOB_NOMATCH 3 / No matches found. / #define GLOB_NOSYS 4 / Not implemented. / #ifdef __USE_GNU / Previous versions of this file defined GLOB_ABEND instead of GLOB_ABORTED. Provide a compatibility definition here. / # define GLOB_ABEND GLOB_ABORTED #endif / Structure describing a globbing run. / #ifdef __USE_GNU struct stat; #endif typedef struct { __size_t gl_pathc; / Count of paths matched by the pattern. / char gl_pathv; / List of matched pathnames. / __size_t gl_offs; / Slots to reserve in `gl_pathv'. / int gl_flags; / Set to FLAGS, maybe \| GLOB_MAGCHAR. / / If the GLOB_ALTDIRFUNC flag is set, the following functions are used instead of the normal file access functions. / void (gl_closedir) (void ); #ifdef __USE_GNU struct dirent (gl_readdir) (void ); #else void (gl_readdir) (void ); #endif void (gl_opendir) (const char ); #ifdef __USE_GNU int (gl_lstat) (const char __restrict, struct stat __restrict); int (gl_stat) (const char __restrict, struct stat __restrict); #else int (gl_lstat) (const char __restrict, void __restrict); int (gl_stat) (const char __restrict, void __restrict); #endif } glob_t; #ifdef __USE_LARGEFILE64 # ifdef __USE_GNU struct stat64; # endif typedef struct { __size_t gl_pathc; char *gl_pathv; __size_t gl_offs; int gl_flags; / If the GLOB_ALTDIRFUNC flag is set, the following functions are used instead of the normal file access functions. / void (gl_closedir) (void ); # ifdef __USE_GNU struct dirent64 (gl_readdir) (void ); # else void (gl_readdir) (void ); # endif void (gl_opendir) (const char ); # ifdef __USE_GNU int (gl_lstat) (const char __restrict, struct stat64 __restrict); int (gl_stat) (const char __restrict, struct stat64 __restrict); # else int (gl_lstat) (const char __restrict, void __restrict); int (gl_stat) (const char __restrict, void __restrict); # endif } glob64_t; #endif /* Do glob searching for PATTERN, placing results in PGLOB. The bits defined above may be set in FLAGS. If a directory cannot be opened or read and ERRFUNC is not nil, it is called with the pathname that caused the error, and the `errno' value from the failing call; if it returns non-zero `glob' returns GLOB_ABEND; if it returns zero, the error is ignored. If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned. Otherwise, `glob' returns zero. / #if !defined __USE_FILE_OFFSET64 extern int glob (const char __restrict __pattern, int __flags, int (__errfunc) (const char , int), glob_t __restrict __pglob) __THROWNL; / Free storage allocated in PGLOB by a previous `glob' call. / extern void globfree (glob_t __pglob) __THROW; #else # ifdef __USE_TIME_BITS64 extern int __REDIRECT_NTHNL (glob, (const char __restrict __pattern, int __flags, int (__errfunc) (const char , int), glob_t __restrict __pglob), __glob64_time64); extern void __REDIRECT_NTH (globfree, (glob_t __pglob), __globfree64_time64); # else extern int __REDIRECT_NTHNL (glob, (const char __restrict __pattern, int __flags, int (__errfunc) (const char , int), glob_t __restrict __pglob), glob64); extern void __REDIRECT_NTH (globfree, (glob_t __pglob), globfree64); # endif #endif #ifdef __USE_LARGEFILE64 # ifdef __USE_TIME_BITS64 extern int __REDIRECT_NTHNL (glob64, (const char __restrict __pattern, int __flags, int (__errfunc) (const char , int), glob64_t __restrict __pglob), __glob64_time64); extern void __REDIRECT_NTH (globfree64, (glob64_t __pglob), __globfree64_time64); # else extern int glob64 (const char __restrict __pattern, int __flags, int (__errfunc) (const char , int), glob64_t __restrict __pglob) __THROWNL; extern void globfree64 (glob64_t __pglob) __THROW; # endif #endif #ifdef __USE_GNU /* Return nonzero if PATTERN contains any metacharacters. Metacharacters can be quoted with backslashes if QUOTE is nonzero. This function is not part of the interface specified by POSIX.2 but several programs want to use it. / extern int glob_pattern_p (const char __pattern, int __quote) __THROW; #endif __END_DECLS #endif /* glob.h */	7.13 KB	2026-02-17 11:01
📁 gnu	-	2026-03-21 15:44
📄 gnu-versions.h /* Header with interface version macros for library pieces copied elsewhere. Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _GNU_VERSIONS_H #define _GNU_VERSIONS_H 1 / This file exists to define these few macros. Each specifies a version number associated with the library interface of a piece of the C library which is also distributed with other GNU packages. These pieces are both part of the GNU C library and also distributed with other GNU packages so those packages may use their facilities on systems lacking the GNU C library. The source files for each piece surround all their code with `#ifndef ELIDE_CODE' after defining it with this: #define OBSTACK_INTERFACE_VERSION 1 #if !defined (_LIBC) && defined (__GNU_LIBRARY__) && __GNU_LIBRARY__ > 1 #include <gnu-versions.h> #if _GNU_OBSTACK_INTERFACE_VERSION == OBSTACK_INTERFACE_VERSION #define ELIDE_CODE #endif #endif This allows those one to avoid compiling those files when part of a GNU package not libc, on a system using a GNU C library that supports the same interface. Please preserve the format of the comments after each macro. And remember, if any of these versions change, the libc.so major version number must change too (so avoid it)! / #define _GNU_OBSTACK_INTERFACE_VERSION 1 / vs malloc/obstack.c / #define _GNU_REGEX_INTERFACE_VERSION 1 / vs posix/regex.c / #define _GNU_GLOB_INTERFACE_VERSION 2 / vs posix/glob.c / #define _GNU_GETOPT_INTERFACE_VERSION 2 / vs posix/getopt.c and posix/getopt1.c / #endif / gnu-versions.h */	2.29 KB	2026-02-17 11:01
📄 gnumake.h /* External interfaces usable by dynamic objects loaded into GNU Make. --THIS API IS A "TECHNOLOGY PREVIEW" ONLY. IT IS NOT A STABLE INTERFACE-- Copyright (C) 2013-2020 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. / #ifndef _GNUMAKE_H_ #define _GNUMAKE_H_ / Specify the location of elements read from makefiles. / typedef struct { const char filenm; unsigned long lineno; } gmk_floc; typedef char (gmk_func_ptr)(const char nm, unsigned int argc, char argv); #ifdef _WIN32 # ifdef GMK_BUILDING_MAKE # define GMK_EXPORT __declspec(dllexport) # else # define GMK_EXPORT __declspec(dllimport) # endif #else # define GMK_EXPORT #endif / Free memory returned by the gmk_expand() function. / GMK_EXPORT void gmk_free (char str); /* Allocate memory in GNU make's context. / GMK_EXPORT char gmk_alloc (unsigned int len); /* Run $(eval ...) on the provided string BUFFER. / GMK_EXPORT void gmk_eval (const char buffer, const gmk_floc floc); / Run GNU make expansion on the provided string STR. Returns an allocated buffer that the caller must free with gmk_free(). / GMK_EXPORT char gmk_expand (const char str); / Register a new GNU make function NAME (maximum of 255 chars long). When the function is expanded in the makefile, FUNC will be invoked with the appropriate arguments. The return value of FUNC must be either NULL, in which case it expands to the empty string, or a pointer to the result of the expansion in a string created by gmk_alloc(). GNU make will free the memory when it's done. MIN_ARGS is the minimum number of arguments the function requires. MAX_ARGS is the maximum number of arguments (or 0 if there's no maximum). MIN_ARGS and MAX_ARGS may not exceed 255. The FLAGS value may be GMK_FUNC_DEFAULT, or one or more of the following flags OR'd together: GMK_FUNC_NOEXPAND: the arguments to the function will be not be expanded before FUNC is called. / GMK_EXPORT void gmk_add_function (const char name, gmk_func_ptr func, unsigned int min_args, unsigned int max_args, unsigned int flags); #define GMK_FUNC_DEFAULT 0x00 #define GMK_FUNC_NOEXPAND 0x01 #endif /* _GNUMAKE_H_ */	2.84 KB	2020-01-03 07:11
📄 grp.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * POSIX Standard: 9.2.1 Group Database Access <grp.h> / #ifndef _GRP_H #define _GRP_H 1 #include <features.h> __BEGIN_DECLS #include <bits/types.h> #define __need_size_t #include <stddef.h> / For the Single Unix specification we must define this type here. / #if (defined __USE_XOPEN \|\| defined __USE_XOPEN2K) && !defined __gid_t_defined typedef __gid_t gid_t; # define __gid_t_defined #endif / The group structure. / struct group { char gr_name; /* Group name. / char gr_passwd; /* Password. / __gid_t gr_gid; / Group ID. / char gr_mem; / Member list. / }; #ifdef __USE_MISC # include <bits/types/FILE.h> #endif #if defined __USE_MISC \|\| defined __USE_XOPEN_EXTENDED / Rewind the group-file stream. This function is a possible cancellation point and therefore not marked with __THROW. / extern void setgrent (void); / Close the group-file stream. This function is a possible cancellation point and therefore not marked with __THROW. / extern void endgrent (void); / Read an entry from the group-file stream, opening it if necessary. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct group getgrent (void); #endif #ifdef __USE_MISC /* Read a group entry from STREAM. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern struct group fgetgrent (FILE __stream); #endif #ifdef __USE_GNU / Write the given entry onto the given stream. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int putgrent (const struct group __restrict __p, FILE __restrict __f); #endif / Search for an entry with a matching group ID. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct group getgrgid (__gid_t __gid); /* Search for an entry with a matching group name. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct group getgrnam (const char __name); #ifdef __USE_POSIX # ifdef __USE_MISC / Reasonable value for the buffer sized used in the reentrant functions below. But better use `sysconf'. / # define NSS_BUFLEN_GROUP 1024 # endif / Reentrant versions of some of the functions above. PLEASE NOTE: the `getgrent_r' function is not (yet) standardized. The interface may change in later versions of this library. But the interface is designed following the principals used for the other reentrant functions so the chances are good this is what the POSIX people would choose. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / # ifdef __USE_GNU extern int getgrent_r (struct group __restrict __resultbuf, char __restrict __buffer, size_t __buflen, struct group __restrict __result); # endif / Search for an entry with a matching group ID. This function is a possible cancellation point and therefore not marked with __THROW. / extern int getgrgid_r (__gid_t __gid, struct group __restrict __resultbuf, char __restrict __buffer, size_t __buflen, struct group __restrict __result); / Search for an entry with a matching group name. This function is a possible cancellation point and therefore not marked with __THROW. / extern int getgrnam_r (const char __restrict __name, struct group __restrict __resultbuf, char __restrict __buffer, size_t __buflen, struct group *__restrict __result); # ifdef __USE_MISC / Read a group entry from STREAM. This function is not standardized an probably never will. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int fgetgrent_r (FILE __restrict __stream, struct group __restrict __resultbuf, char __restrict __buffer, size_t __buflen, struct group *__restrict __result); # endif #endif / POSIX or reentrant / #ifdef __USE_MISC # define __need_size_t # include <stddef.h> / Set the group set for the current user to GROUPS (N of them). / extern int setgroups (size_t __n, const __gid_t __groups) __THROW; /* Store at most NGROUPS members of the group set for USER into GROUPS. Also include GROUP. The actual number of groups found is returned in NGROUPS. Return -1 if the if NGROUPS is too small. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int getgrouplist (const char __user, __gid_t __group, __gid_t __groups, int __ngroups); /* Initialize the group set for the current user by reading the group database and using all groups of which USER is a member. Also include GROUP. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int initgroups (const char __user, __gid_t __group); #endif /* Use misc. / __END_DECLS #endif / grp.h */	6.53 KB	2026-02-17 11:01
📄 gshadow.h /* Copyright (C) 2009-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / Declaration of types and functions for shadow group suite. / #ifndef _GSHADOW_H #define _GSHADOW_H 1 #include <features.h> #include <paths.h> #include <bits/types/FILE.h> #define __need_size_t #include <stddef.h> / Path to the user database files. / #define GSHADOW _PATH_GSHADOW __BEGIN_DECLS / Structure of the group file. / struct sgrp { char sg_namp; /* Group name. / char sg_passwd; /* Encrypted password. / char sg_adm; / Group administrator list. / char sg_mem; / Group member list. / }; / Open database for reading. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern void setsgent (void); / Close database. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern void endsgent (void); / Get next entry from database, perhaps after opening the file. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern struct sgrp getsgent (void); /* Get shadow entry matching NAME. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern struct sgrp getsgnam (const char __name); / Read shadow entry from STRING. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern struct sgrp sgetsgent (const char __string); / Read next shadow entry from STREAM. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern struct sgrp fgetsgent (FILE __stream); / Write line containing shadow password entry to stream. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int putsgent (const struct sgrp __g, FILE __stream); #ifdef __USE_MISC / Reentrant versions of some of the functions above. These functions are not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation they are cancellation points and therefore not marked with __THROW. / extern int getsgent_r (struct sgrp __result_buf, char __buffer, size_t __buflen, struct sgrp __result); extern int getsgnam_r (const char __name, struct sgrp __result_buf, char __buffer, size_t __buflen, struct sgrp *__result); extern int sgetsgent_r (const char __string, struct sgrp __result_buf, char __buffer, size_t __buflen, struct sgrp *__result); extern int fgetsgent_r (FILE __stream, struct sgrp __result_buf, char __buffer, size_t __buflen, struct sgrp *__result); #endif / misc / __END_DECLS #endif / gshadow.h */	4.42 KB	2026-02-17 11:02
📁 gssapi	-	2026-03-21 15:53
📄 gssapi.h /* -- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -- / / * Wrapper so that #include <gssapi.h> will work without special include * paths. */ #include <gssapi/gssapi.h>	181 B	2023-07-10 20:58
📁 gssrpc	-	2026-03-21 15:53
📄 iconv.h /* Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _ICONV_H #define _ICONV_H 1 #include <features.h> #define __need_size_t #include <stddef.h> __BEGIN_DECLS / Identifier for conversion method from one codeset to another. / typedef void iconv_t; /* Allocate descriptor for code conversion from codeset FROMCODE to codeset TOCODE. This function is a possible cancellation point and therefore not marked with __THROW. / extern iconv_t iconv_open (const char __tocode, const char __fromcode); / Convert at most INBYTESLEFT bytes from INBUF according to the code conversion algorithm specified by CD and place up to OUTBYTESLEFT bytes in buffer at OUTBUF. / extern size_t iconv (iconv_t __cd, char __restrict __inbuf, size_t __restrict __inbytesleft, char *__restrict __outbuf, size_t __restrict __outbytesleft); /* Free resources allocated for descriptor CD for code conversion. This function is a possible cancellation point and therefore not marked with __THROW. / extern int iconv_close (iconv_t __cd); __END_DECLS #endif / iconv.h */	1.81 KB	2026-02-17 11:01
📄 idn2.h /* idn2.h - header file for idn2 Copyright (C) 2011-2017 Simon Josefsson Libidn2 is free software: you can redistribute it and/or modify it under the terms of either: * the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. or * the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. or both in parallel, as here. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received copies of the GNU General Public License and the GNU Lesser General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. / #ifndef IDN2_H #define IDN2_H / INDENT-OFF / / see https://www.gnu.org/software/gnulib/manual/html_node/Exported-Symbols-of-Shared-Libraries.html / #ifndef _IDN2_API # if defined IDN2_BUILDING && defined HAVE_VISIBILITY && HAVE_VISIBILITY # define _IDN2_API __attribute__((__visibility__("default"))) # elif defined IDN2_BUILDING && defined _MSC_VER && ! defined IDN2_STATIC # define _IDN2_API __declspec(dllexport) # elif defined _MSC_VER && ! defined IDN2_STATIC # define _IDN2_API __declspec(dllimport) # else # define _IDN2_API # endif #endif / INDENT-ON / #include <stdint.h> / uint32_t / #include <string.h> / size_t / #ifdef __cplusplus extern "C" { #endif /* * GCC_VERSION_AT_LEAST * @major: gcc major version number to compare with * @minor: gcc minor version number to compare with * * Pre-processor symbol to check the gcc version. / #if defined __GNUC__ && defined __GNUC_MINOR__ # define GCC_VERSION_AT_LEAST(major, minor) ((__GNUC__ > (major)) \|\| (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor))) #else # define GCC_VERSION_AT_LEAST(major, minor) 0 #endif / the following G_GNUC_ prefixes are for gtk-doc to recognize the attributes / /* * G_GNUC_IDN2_ATTRIBUTE_PURE * * Function attribute: Function is a pure function. / #if GCC_VERSION_AT_LEAST(2,96) # define G_GNUC_IDN2_ATTRIBUTE_PURE __attribute__ ((pure)) #else # define G_GNUC_IDN2_ATTRIBUTE_PURE #endif /* * G_GNUC_IDN2_ATTRIBUTE_CONST * * Function attribute: Function is a const function. / #if GCC_VERSION_AT_LEAST(2,5) # define G_GNUC_IDN2_ATTRIBUTE_CONST __attribute__ ((const)) #else # define G_GNUC_IDN2_ATTRIBUTE_CONST #endif /* * G_GNUC_DEPRECATED * * Function attribute: Function is deprecated. / #if GCC_VERSION_AT_LEAST(3,1) # define G_GNUC_DEPRECATED __attribute__((deprecated)) #elif defined(_MSC_VER) # define G_GNUC_DEPRECATED __declspec(deprecated) #else # define G_GNUC_DEPRECATED / empty / #endif /* * G_GNUC_UNUSED * * Parameter attribute: Parameter is not used. / #if GCC_VERSION_AT_LEAST(2,95) # define G_GNUC_UNUSED __attribute__ ((__unused__)) #else # define G_GNUC_UNUSED / empty / #endif /* * IDN2_VERSION * * Pre-processor symbol with a string that describe the header file * version number. Used together with idn2_check_version() to verify * header file and run-time library consistency. / #define IDN2_VERSION "2.3.0" /* * IDN2_VERSION_NUMBER * * Pre-processor symbol with a hexadecimal value describing the header * file version number. For example, when the header version is * 1.2.4711 this symbol will have the value 0x01021267. The last four * digits are used to enumerate development snapshots, but for all * public releases they will be 0000. / #define IDN2_VERSION_NUMBER 0x02030000 /* * IDN2_VERSION_MAJOR * * Pre-processor symbol for the major version number (decimal). * The version scheme is major.minor.patchlevel. / #define IDN2_VERSION_MAJOR 2 /* * IDN2_VERSION_MINOR * * Pre-processor symbol for the minor version number (decimal). * The version scheme is major.minor.patchlevel. / #define IDN2_VERSION_MINOR 3 /* * IDN2_VERSION_PATCH * * Pre-processor symbol for the patch level number (decimal). * The version scheme is major.minor.patchlevel. / #define IDN2_VERSION_PATCH 0 /* * IDN2_LABEL_MAX_LENGTH * * Constant specifying the maximum length of a DNS label to 63 * characters, as specified in RFC 1034. / #define IDN2_LABEL_MAX_LENGTH 63 /* * IDN2_DOMAIN_MAX_LENGTH * * Constant specifying the maximum size of the wire encoding of a DNS * domain to 255 characters, as specified in RFC 1034. Note that the * usual printed representation of a domain name is limited to 253 * characters if it does not end with a period, or 254 characters if * it ends with a period. / #define IDN2_DOMAIN_MAX_LENGTH 255 /* * idn2_flags: * @IDN2_NFC_INPUT: Normalize input string using normalization form C. * @IDN2_ALABEL_ROUNDTRIP: Perform optional IDNA2008 lookup roundtrip check (default). * @IDN2_NO_ALABEL_ROUNDTRIP: Disable ALabel lookup roundtrip check. * @IDN2_NO_TR46: Disable Unicode TR46 processing. * @IDN2_TRANSITIONAL: Perform Unicode TR46 transitional processing. * @IDN2_NONTRANSITIONAL: Perform Unicode TR46 non-transitional processing (default). * @IDN2_ALLOW_UNASSIGNED: Libidn compatibility flag, unused. * @IDN2_USE_STD3_ASCII_RULES: Use STD3 ASCII rules. * This is a #TR46 only flag, and will be ignored when set without either * @IDN2_TRANSITIONAL or @IDN2_NONTRANSITIONAL. * * Flags to IDNA2008 functions, to be binary or:ed together. Specify * only 0 if you want the default behaviour. / typedef enum { IDN2_NFC_INPUT = 1, IDN2_ALABEL_ROUNDTRIP = 2, IDN2_TRANSITIONAL = 4, IDN2_NONTRANSITIONAL = 8, IDN2_ALLOW_UNASSIGNED = 16, IDN2_USE_STD3_ASCII_RULES = 32, IDN2_NO_TR46 = 64, IDN2_NO_ALABEL_ROUNDTRIP = 128 } idn2_flags; / IDNA2008 with UTF-8 encoded inputs. / extern _IDN2_API int idn2_lookup_u8 (const uint8_t src, uint8_t ** lookupname, int flags); extern _IDN2_API int idn2_register_u8 (const uint8_t * ulabel, const uint8_t * alabel, uint8_t ** insertname, int flags); /* IDNA2008 with locale encoded inputs. / extern _IDN2_API int idn2_lookup_ul (const char src, char *lookupname, int flags); extern _IDN2_API int idn2_register_ul (const char ulabel, const char alabel, char insertname, int flags); /* * idn2_rc: * @IDN2_OK: Successful return. * @IDN2_MALLOC: Memory allocation error. * @IDN2_NO_CODESET: Could not determine locale string encoding format. * @IDN2_ICONV_FAIL: Could not transcode locale string to UTF-8. * @IDN2_ENCODING_ERROR: Unicode data encoding error. * @IDN2_NFC: Error normalizing string. * @IDN2_PUNYCODE_BAD_INPUT: Punycode invalid input. * @IDN2_PUNYCODE_BIG_OUTPUT: Punycode output buffer too small. * @IDN2_PUNYCODE_OVERFLOW: Punycode conversion would overflow. * @IDN2_TOO_BIG_DOMAIN: Domain name longer than 255 characters. * @IDN2_TOO_BIG_LABEL: Domain label longer than 63 characters. * @IDN2_INVALID_ALABEL: Input A-label is not valid. * @IDN2_UALABEL_MISMATCH: Input A-label and U-label does not match. * @IDN2_INVALID_FLAGS: Invalid combination of flags. * @IDN2_NOT_NFC: String is not NFC. * @IDN2_2HYPHEN: String has forbidden two hyphens. * @IDN2_HYPHEN_STARTEND: String has forbidden starting/ending hyphen. * @IDN2_LEADING_COMBINING: String has forbidden leading combining character. * @IDN2_DISALLOWED: String has disallowed character. * @IDN2_CONTEXTJ: String has forbidden context-j character. * @IDN2_CONTEXTJ_NO_RULE: String has context-j character with no rull. * @IDN2_CONTEXTO: String has forbidden context-o character. * @IDN2_CONTEXTO_NO_RULE: String has context-o character with no rull. * @IDN2_UNASSIGNED: String has forbidden unassigned character. * @IDN2_BIDI: String has forbidden bi-directional properties. * @IDN2_DOT_IN_LABEL: Label has forbidden dot (TR46). * @IDN2_INVALID_TRANSITIONAL: Label has character forbidden in transitional mode (TR46). * @IDN2_INVALID_NONTRANSITIONAL: Label has character forbidden in non-transitional mode (TR46). * @IDN2_ALABEL_ROUNDTRIP_FAILED: ALabel -> Ulabel -> ALabel result differs from input. * * Return codes for IDN2 functions. All return codes are negative * except for the successful code IDN2_OK which are guaranteed to be * 0. Positive values are reserved for non-error return codes. * * Note that the #idn2_rc enumeration may be extended at a later date * to include new return codes. / typedef enum { IDN2_OK = 0, IDN2_MALLOC = -100, IDN2_NO_CODESET = -101, IDN2_ICONV_FAIL = -102, IDN2_ENCODING_ERROR = -200, IDN2_NFC = -201, IDN2_PUNYCODE_BAD_INPUT = -202, IDN2_PUNYCODE_BIG_OUTPUT = -203, IDN2_PUNYCODE_OVERFLOW = -204, IDN2_TOO_BIG_DOMAIN = -205, IDN2_TOO_BIG_LABEL = -206, IDN2_INVALID_ALABEL = -207, IDN2_UALABEL_MISMATCH = -208, IDN2_INVALID_FLAGS = -209, IDN2_NOT_NFC = -300, IDN2_2HYPHEN = -301, IDN2_HYPHEN_STARTEND = -302, IDN2_LEADING_COMBINING = -303, IDN2_DISALLOWED = -304, IDN2_CONTEXTJ = -305, IDN2_CONTEXTJ_NO_RULE = -306, IDN2_CONTEXTO = -307, IDN2_CONTEXTO_NO_RULE = -308, IDN2_UNASSIGNED = -309, IDN2_BIDI = -310, IDN2_DOT_IN_LABEL = -311, IDN2_INVALID_TRANSITIONAL = -312, IDN2_INVALID_NONTRANSITIONAL = -313, IDN2_ALABEL_ROUNDTRIP_FAILED = -314, } idn2_rc; / Auxiliary functions. / extern _IDN2_API G_GNUC_DEPRECATED int idn2_to_ascii_4i (const uint32_t input, size_t inlen, char * output, int flags); extern _IDN2_API int idn2_to_ascii_4i2 (const uint32_t * input, size_t inlen, char ** output, int flags); extern _IDN2_API int idn2_to_ascii_4z (const uint32_t * input, char ** output, int flags); extern _IDN2_API int idn2_to_ascii_8z (const char * input, char ** output, int flags); extern _IDN2_API int idn2_to_ascii_lz (const char * input, char ** output, int flags); extern _IDN2_API int idn2_to_unicode_8z4z (const char * input, uint32_t ** output, int flags G_GNUC_UNUSED); extern _IDN2_API int idn2_to_unicode_4z4z (const uint32_t * input, uint32_t ** output, int flags); extern _IDN2_API int idn2_to_unicode_44i (const uint32_t * in, size_t inlen, uint32_t * out, size_t * outlen, int flags); extern _IDN2_API int idn2_to_unicode_8z8z (const char * input, char ** output, int flags); extern _IDN2_API int idn2_to_unicode_8zlz (const char * input, char ** output, int flags); extern _IDN2_API int idn2_to_unicode_lzlz (const char * input, char ** output, int flags); extern _IDN2_API G_GNUC_IDN2_ATTRIBUTE_CONST const char * idn2_strerror (int rc); extern _IDN2_API G_GNUC_IDN2_ATTRIBUTE_CONST const char * idn2_strerror_name (int rc); extern _IDN2_API G_GNUC_IDN2_ATTRIBUTE_PURE const char * idn2_check_version (const char req_version); extern _IDN2_API void idn2_free (void ptr); /* libidn compatibility layer / #if !defined IDNA_H && !defined IDN2_SKIP_LIBIDN_COMPAT /* * Idna_rc: * @IDNA_SUCCESS: Same as %IDN2_OK * @IDNA_STRINGPREP_ERROR: Same as %IDN2_ENCODING_ERROR * @IDNA_PUNYCODE_ERROR: Same as %IDN2_PUNYCODE_BAD_INPUT * @IDNA_CONTAINS_NON_LDH: Same as %IDN2_ENCODING_ERROR * @IDNA_CONTAINS_LDH: Same as %IDNA_CONTAINS_NON_LDH * @IDNA_CONTAINS_MINUS: Same as %IDN2_ENCODING_ERROR * @IDNA_INVALID_LENGTH: Same as %IDN2_DISALLOWED * @IDNA_NO_ACE_PREFIX: Same as %IDN2_ENCODING_ERROR * @IDNA_ROUNDTRIP_VERIFY_ERROR: Same as %IDN2_ENCODING_ERROR * @IDNA_CONTAINS_ACE_PREFIX: Same as %IDN2_ENCODING_ERROR * @IDNA_ICONV_ERROR: Same as %IDN2_ENCODING_ERROR * @IDNA_MALLOC_ERROR: Same as %IDN2_MALLOC * @IDNA_DLOPEN_ERROR: Same as %IDN2_MALLOC * * Return codes for transition to / compatibility with libidn2. * * Please be aware that return codes from idna_ functions might be unexpected * when linked / built with libidn2. / typedef enum { IDNA_SUCCESS = IDN2_OK, IDNA_STRINGPREP_ERROR = IDN2_ENCODING_ERROR, IDNA_PUNYCODE_ERROR = IDN2_PUNYCODE_BAD_INPUT, IDNA_CONTAINS_NON_LDH = IDN2_ENCODING_ERROR, IDNA_CONTAINS_LDH = IDNA_CONTAINS_NON_LDH, IDNA_CONTAINS_MINUS = IDN2_ENCODING_ERROR, IDNA_INVALID_LENGTH = IDN2_DISALLOWED, IDNA_NO_ACE_PREFIX = IDN2_ENCODING_ERROR, IDNA_ROUNDTRIP_VERIFY_ERROR = IDN2_ENCODING_ERROR, IDNA_CONTAINS_ACE_PREFIX = IDN2_ENCODING_ERROR, IDNA_ICONV_ERROR = IDN2_ENCODING_ERROR, IDNA_MALLOC_ERROR = IDN2_MALLOC, IDNA_DLOPEN_ERROR = IDN2_MALLOC } Idna_rc; /* * Idna_flags: * @IDNA_ALLOW_UNASSIGNED: Same as %IDN2_ALLOW_UNASSIGNED * @IDNA_USE_STD3_ASCII_RULES: Same as %IDN2_USE_STD3_ASCII_RULES * * Flags for transition to / compatibility with libidn2. / typedef enum { IDNA_ALLOW_UNASSIGNED = IDN2_ALLOW_UNASSIGNED, IDNA_USE_STD3_ASCII_RULES = IDN2_USE_STD3_ASCII_RULES } Idna_flags; #define idna_to_ascii_4i(i,l,o,f) idn2_to_ascii_4i(i,l,o,f\|IDN2_NFC_INPUT\|IDN2_NONTRANSITIONAL) #define idna_to_ascii_4z(i,o,f) idn2_to_ascii_4z(i,o,f\|IDN2_NFC_INPUT\|IDN2_NONTRANSITIONAL) #define idna_to_ascii_8z(i,o,f) idn2_to_ascii_8z(i,o,f\|IDN2_NFC_INPUT\|IDN2_NONTRANSITIONAL) #define idna_to_ascii_lz(i,o,f) idn2_to_ascii_lz(i,o,f\|IDN2_NFC_INPUT\|IDN2_NONTRANSITIONAL) #define idna_to_unicode_8z4z idn2_to_unicode_8z4z #define idna_to_unicode_4z4z idn2_to_unicode_4z4z #define idna_to_unicode_44i idn2_to_unicode_44i #define idna_to_unicode_8z8z idn2_to_unicode_8z8z #define idna_to_unicode_8zlz idn2_to_unicode_8zlz #define idna_to_unicode_lzlz idn2_to_unicode_lzlz #define idna_strerror idn2_strerror #define idn_free idn2_free #endif / IDNA_H / #ifdef __cplusplus } #endif #endif / IDN2_H */	13.57 KB	2022-02-09 20:58
📄 ieee754.h /* Copyright (C) 1992-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _IEEE754_H #define _IEEE754_H 1 #include <features.h> #include <bits/endian.h> __BEGIN_DECLS union ieee754_float { float f; / This is the IEEE 754 single-precision format. / struct { #if __BYTE_ORDER == __BIG_ENDIAN unsigned int negative:1; unsigned int exponent:8; unsigned int mantissa:23; #endif / Big endian. / #if __BYTE_ORDER == __LITTLE_ENDIAN unsigned int mantissa:23; unsigned int exponent:8; unsigned int negative:1; #endif / Little endian. / } ieee; / This format makes it easier to see if a NaN is a signalling NaN. / struct { #if __BYTE_ORDER == __BIG_ENDIAN unsigned int negative:1; unsigned int exponent:8; unsigned int quiet_nan:1; unsigned int mantissa:22; #endif / Big endian. / #if __BYTE_ORDER == __LITTLE_ENDIAN unsigned int mantissa:22; unsigned int quiet_nan:1; unsigned int exponent:8; unsigned int negative:1; #endif / Little endian. / } ieee_nan; }; #define IEEE754_FLOAT_BIAS 0x7f / Added to exponent. / union ieee754_double { double d; / This is the IEEE 754 double-precision format. / struct { #if __BYTE_ORDER == __BIG_ENDIAN unsigned int negative:1; unsigned int exponent:11; / Together these comprise the mantissa. / unsigned int mantissa0:20; unsigned int mantissa1:32; #endif / Big endian. / #if __BYTE_ORDER == __LITTLE_ENDIAN # if __FLOAT_WORD_ORDER == __BIG_ENDIAN unsigned int mantissa0:20; unsigned int exponent:11; unsigned int negative:1; unsigned int mantissa1:32; # else / Together these comprise the mantissa. / unsigned int mantissa1:32; unsigned int mantissa0:20; unsigned int exponent:11; unsigned int negative:1; # endif #endif / Little endian. / } ieee; / This format makes it easier to see if a NaN is a signalling NaN. / struct { #if __BYTE_ORDER == __BIG_ENDIAN unsigned int negative:1; unsigned int exponent:11; unsigned int quiet_nan:1; / Together these comprise the mantissa. / unsigned int mantissa0:19; unsigned int mantissa1:32; #else # if __FLOAT_WORD_ORDER == __BIG_ENDIAN unsigned int mantissa0:19; unsigned int quiet_nan:1; unsigned int exponent:11; unsigned int negative:1; unsigned int mantissa1:32; # else / Together these comprise the mantissa. / unsigned int mantissa1:32; unsigned int mantissa0:19; unsigned int quiet_nan:1; unsigned int exponent:11; unsigned int negative:1; # endif #endif } ieee_nan; }; #define IEEE754_DOUBLE_BIAS 0x3ff / Added to exponent. / union ieee854_long_double { long double d; / This is the IEEE 854 double-extended-precision format. / struct { #if __BYTE_ORDER == __BIG_ENDIAN unsigned int negative:1; unsigned int exponent:15; unsigned int empty:16; unsigned int mantissa0:32; unsigned int mantissa1:32; #endif #if __BYTE_ORDER == __LITTLE_ENDIAN # if __FLOAT_WORD_ORDER == __BIG_ENDIAN unsigned int exponent:15; unsigned int negative:1; unsigned int empty:16; unsigned int mantissa0:32; unsigned int mantissa1:32; # else unsigned int mantissa1:32; unsigned int mantissa0:32; unsigned int exponent:15; unsigned int negative:1; unsigned int empty:16; # endif #endif } ieee; / This is for NaNs in the IEEE 854 double-extended-precision format. / struct { #if __BYTE_ORDER == __BIG_ENDIAN unsigned int negative:1; unsigned int exponent:15; unsigned int empty:16; unsigned int one:1; unsigned int quiet_nan:1; unsigned int mantissa0:30; unsigned int mantissa1:32; #endif #if __BYTE_ORDER == __LITTLE_ENDIAN # if __FLOAT_WORD_ORDER == __BIG_ENDIAN unsigned int exponent:15; unsigned int negative:1; unsigned int empty:16; unsigned int mantissa0:30; unsigned int quiet_nan:1; unsigned int one:1; unsigned int mantissa1:32; # else unsigned int mantissa1:32; unsigned int mantissa0:30; unsigned int quiet_nan:1; unsigned int one:1; unsigned int exponent:15; unsigned int negative:1; unsigned int empty:16; # endif #endif } ieee_nan; }; #define IEEE854_LONG_DOUBLE_BIAS 0x3fff __END_DECLS #endif / ieee754.h */	4.8 KB	2026-02-17 11:01
📄 ifaddrs.h /* ifaddrs.h -- declarations for getting network interface addresses Copyright (C) 2002-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _IFADDRS_H #define _IFADDRS_H 1 #include <features.h> #include <sys/socket.h> __BEGIN_DECLS / The `getifaddrs' function generates a linked list of these structures. Each element of the list describes one network interface. / struct ifaddrs { struct ifaddrs ifa_next; /* Pointer to the next structure. / char ifa_name; /* Name of this network interface. / unsigned int ifa_flags; / Flags as from SIOCGIFFLAGS ioctl. / struct sockaddr ifa_addr; /* Network address of this interface. / struct sockaddr ifa_netmask; /* Netmask of this interface. / union { / At most one of the following two is valid. If the IFF_BROADCAST bit is set in `ifa_flags', then `ifa_broadaddr' is valid. If the IFF_POINTOPOINT bit is set, then `ifa_dstaddr' is valid. It is never the case that both these bits are set at once. / struct sockaddr ifu_broadaddr; /* Broadcast address of this interface. / struct sockaddr ifu_dstaddr; /* Point-to-point destination address. / } ifa_ifu; / These very same macros are defined by <net/if.h> for `struct ifaddr'. So if they are defined already, the existing definitions will be fine. / # ifndef ifa_broadaddr # define ifa_broadaddr ifa_ifu.ifu_broadaddr # endif # ifndef ifa_dstaddr # define ifa_dstaddr ifa_ifu.ifu_dstaddr # endif void ifa_data; /* Address-specific data (may be unused). / }; / Create a linked list of `struct ifaddrs' structures, one for each network interface on the host machine. If successful, store the list in IFAP and return 0. On errors, return -1 and set `errno'. The storage returned in IFAP is allocated dynamically and can only be properly freed by passing it to `freeifaddrs'. / extern int getifaddrs (struct ifaddrs __ifap) __THROW; / Reclaim the storage allocated by a previous `getifaddrs' call. / extern void freeifaddrs (struct ifaddrs __ifa) __THROW; __END_DECLS #endif /* ifaddrs.h */	2.77 KB	2026-02-17 11:02
📄 inttypes.h /* Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99: 7.8 Format conversion of integer types <inttypes.h> / #ifndef _INTTYPES_H #define _INTTYPES_H 1 #include <features.h> / Get the type definitions. / #include <stdint.h> / Get a definition for wchar_t. But we must not define wchar_t itself. / #ifndef ____gwchar_t_defined # ifdef __cplusplus # define __gwchar_t wchar_t # elif defined __WCHAR_TYPE__ typedef __WCHAR_TYPE__ __gwchar_t; # else # define __need_wchar_t # include <stddef.h> typedef wchar_t __gwchar_t; # endif # define ____gwchar_t_defined 1 #endif # if __WORDSIZE == 64 # define __PRI64_PREFIX "l" # define __PRIPTR_PREFIX "l" # else # define __PRI64_PREFIX "ll" # define __PRIPTR_PREFIX # endif / Macros for printing format specifiers. / / Decimal notation. / # define PRId8 "d" # define PRId16 "d" # define PRId32 "d" # define PRId64 __PRI64_PREFIX "d" # define PRIdLEAST8 "d" # define PRIdLEAST16 "d" # define PRIdLEAST32 "d" # define PRIdLEAST64 __PRI64_PREFIX "d" # define PRIdFAST8 "d" # define PRIdFAST16 __PRIPTR_PREFIX "d" # define PRIdFAST32 __PRIPTR_PREFIX "d" # define PRIdFAST64 __PRI64_PREFIX "d" # define PRIi8 "i" # define PRIi16 "i" # define PRIi32 "i" # define PRIi64 __PRI64_PREFIX "i" # define PRIiLEAST8 "i" # define PRIiLEAST16 "i" # define PRIiLEAST32 "i" # define PRIiLEAST64 __PRI64_PREFIX "i" # define PRIiFAST8 "i" # define PRIiFAST16 __PRIPTR_PREFIX "i" # define PRIiFAST32 __PRIPTR_PREFIX "i" # define PRIiFAST64 __PRI64_PREFIX "i" / Octal notation. / # define PRIo8 "o" # define PRIo16 "o" # define PRIo32 "o" # define PRIo64 __PRI64_PREFIX "o" # define PRIoLEAST8 "o" # define PRIoLEAST16 "o" # define PRIoLEAST32 "o" # define PRIoLEAST64 __PRI64_PREFIX "o" # define PRIoFAST8 "o" # define PRIoFAST16 __PRIPTR_PREFIX "o" # define PRIoFAST32 __PRIPTR_PREFIX "o" # define PRIoFAST64 __PRI64_PREFIX "o" / Unsigned integers. / # define PRIu8 "u" # define PRIu16 "u" # define PRIu32 "u" # define PRIu64 __PRI64_PREFIX "u" # define PRIuLEAST8 "u" # define PRIuLEAST16 "u" # define PRIuLEAST32 "u" # define PRIuLEAST64 __PRI64_PREFIX "u" # define PRIuFAST8 "u" # define PRIuFAST16 __PRIPTR_PREFIX "u" # define PRIuFAST32 __PRIPTR_PREFIX "u" # define PRIuFAST64 __PRI64_PREFIX "u" / lowercase hexadecimal notation. / # define PRIx8 "x" # define PRIx16 "x" # define PRIx32 "x" # define PRIx64 __PRI64_PREFIX "x" # define PRIxLEAST8 "x" # define PRIxLEAST16 "x" # define PRIxLEAST32 "x" # define PRIxLEAST64 __PRI64_PREFIX "x" # define PRIxFAST8 "x" # define PRIxFAST16 __PRIPTR_PREFIX "x" # define PRIxFAST32 __PRIPTR_PREFIX "x" # define PRIxFAST64 __PRI64_PREFIX "x" / UPPERCASE hexadecimal notation. / # define PRIX8 "X" # define PRIX16 "X" # define PRIX32 "X" # define PRIX64 __PRI64_PREFIX "X" # define PRIXLEAST8 "X" # define PRIXLEAST16 "X" # define PRIXLEAST32 "X" # define PRIXLEAST64 __PRI64_PREFIX "X" # define PRIXFAST8 "X" # define PRIXFAST16 __PRIPTR_PREFIX "X" # define PRIXFAST32 __PRIPTR_PREFIX "X" # define PRIXFAST64 __PRI64_PREFIX "X" / Macros for printing `intmax_t' and `uintmax_t'. / # define PRIdMAX __PRI64_PREFIX "d" # define PRIiMAX __PRI64_PREFIX "i" # define PRIoMAX __PRI64_PREFIX "o" # define PRIuMAX __PRI64_PREFIX "u" # define PRIxMAX __PRI64_PREFIX "x" # define PRIXMAX __PRI64_PREFIX "X" / Macros for printing `intptr_t' and `uintptr_t'. / # define PRIdPTR __PRIPTR_PREFIX "d" # define PRIiPTR __PRIPTR_PREFIX "i" # define PRIoPTR __PRIPTR_PREFIX "o" # define PRIuPTR __PRIPTR_PREFIX "u" # define PRIxPTR __PRIPTR_PREFIX "x" # define PRIXPTR __PRIPTR_PREFIX "X" / Macros for scanning format specifiers. / / Signed decimal notation. / # define SCNd8 "hhd" # define SCNd16 "hd" # define SCNd32 "d" # define SCNd64 __PRI64_PREFIX "d" # define SCNdLEAST8 "hhd" # define SCNdLEAST16 "hd" # define SCNdLEAST32 "d" # define SCNdLEAST64 __PRI64_PREFIX "d" # define SCNdFAST8 "hhd" # define SCNdFAST16 __PRIPTR_PREFIX "d" # define SCNdFAST32 __PRIPTR_PREFIX "d" # define SCNdFAST64 __PRI64_PREFIX "d" / Signed decimal notation. / # define SCNi8 "hhi" # define SCNi16 "hi" # define SCNi32 "i" # define SCNi64 __PRI64_PREFIX "i" # define SCNiLEAST8 "hhi" # define SCNiLEAST16 "hi" # define SCNiLEAST32 "i" # define SCNiLEAST64 __PRI64_PREFIX "i" # define SCNiFAST8 "hhi" # define SCNiFAST16 __PRIPTR_PREFIX "i" # define SCNiFAST32 __PRIPTR_PREFIX "i" # define SCNiFAST64 __PRI64_PREFIX "i" / Unsigned decimal notation. / # define SCNu8 "hhu" # define SCNu16 "hu" # define SCNu32 "u" # define SCNu64 __PRI64_PREFIX "u" # define SCNuLEAST8 "hhu" # define SCNuLEAST16 "hu" # define SCNuLEAST32 "u" # define SCNuLEAST64 __PRI64_PREFIX "u" # define SCNuFAST8 "hhu" # define SCNuFAST16 __PRIPTR_PREFIX "u" # define SCNuFAST32 __PRIPTR_PREFIX "u" # define SCNuFAST64 __PRI64_PREFIX "u" / Octal notation. / # define SCNo8 "hho" # define SCNo16 "ho" # define SCNo32 "o" # define SCNo64 __PRI64_PREFIX "o" # define SCNoLEAST8 "hho" # define SCNoLEAST16 "ho" # define SCNoLEAST32 "o" # define SCNoLEAST64 __PRI64_PREFIX "o" # define SCNoFAST8 "hho" # define SCNoFAST16 __PRIPTR_PREFIX "o" # define SCNoFAST32 __PRIPTR_PREFIX "o" # define SCNoFAST64 __PRI64_PREFIX "o" / Hexadecimal notation. / # define SCNx8 "hhx" # define SCNx16 "hx" # define SCNx32 "x" # define SCNx64 __PRI64_PREFIX "x" # define SCNxLEAST8 "hhx" # define SCNxLEAST16 "hx" # define SCNxLEAST32 "x" # define SCNxLEAST64 __PRI64_PREFIX "x" # define SCNxFAST8 "hhx" # define SCNxFAST16 __PRIPTR_PREFIX "x" # define SCNxFAST32 __PRIPTR_PREFIX "x" # define SCNxFAST64 __PRI64_PREFIX "x" / Macros for scanning `intmax_t' and `uintmax_t'. / # define SCNdMAX __PRI64_PREFIX "d" # define SCNiMAX __PRI64_PREFIX "i" # define SCNoMAX __PRI64_PREFIX "o" # define SCNuMAX __PRI64_PREFIX "u" # define SCNxMAX __PRI64_PREFIX "x" / Macros for scaning `intptr_t' and `uintptr_t'. / # define SCNdPTR __PRIPTR_PREFIX "d" # define SCNiPTR __PRIPTR_PREFIX "i" # define SCNoPTR __PRIPTR_PREFIX "o" # define SCNuPTR __PRIPTR_PREFIX "u" # define SCNxPTR __PRIPTR_PREFIX "x" __BEGIN_DECLS #if __WORDSIZE == 64 / We have to define the `uintmax_t' type using `ldiv_t'. / typedef struct { long int quot; / Quotient. / long int rem; / Remainder. / } imaxdiv_t; #else / We have to define the `uintmax_t' type using `lldiv_t'. / typedef struct { __extension__ long long int quot; / Quotient. / __extension__ long long int rem; / Remainder. / } imaxdiv_t; #endif / Compute absolute value of N. / extern intmax_t imaxabs (intmax_t __n) __THROW __attribute__ ((__const__)); / Return the `imaxdiv_t' representation of the value of NUMER over DENOM. / extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom) __THROW __attribute__ ((__const__)); / Like `strtol' but convert to `intmax_t'. / extern intmax_t strtoimax (const char __restrict __nptr, char *__restrict __endptr, int __base) __THROW; / Like `strtoul' but convert to `uintmax_t'. / extern uintmax_t strtoumax (const char __restrict __nptr, char ** __restrict __endptr, int __base) __THROW; /* Like `wcstol' but convert to `intmax_t'. / extern intmax_t wcstoimax (const __gwchar_t __restrict __nptr, __gwchar_t *__restrict __endptr, int __base) __THROW; / Like `wcstoul' but convert to `uintmax_t'. / extern uintmax_t wcstoumax (const __gwchar_t __restrict __nptr, __gwchar_t ** __restrict __endptr, int __base) __THROW; __END_DECLS #endif /* inttypes.h */	8.14 KB	2026-02-17 11:01
📁 kadm5	-	2026-03-21 15:53
📄 kdb.h /* -- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -- / / * Copyright 1990, 1991, 2016 by the Massachusetts Institute of Technology. * All Rights Reserved. * * Export of this software from the United States of America may * require a specific license from the United States Government. * It is the responsibility of any person or organization contemplating * export to obtain such a license before exporting. * * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and * distribute this software and its documentation for any purpose and * without fee is hereby granted, provided that the above copyright * notice appear in all copies and that both that copyright notice and * this permission notice appear in supporting documentation, and that * the name of M.I.T. not be used in advertising or publicity pertaining * to distribution of the software without specific, written prior * permission. Furthermore if you modify this software you must label * your software as modified software and not distribute it in such a * fashion that it might be confused with the original M.I.T. software. * M.I.T. makes no representations about the suitability of * this software for any purpose. It is provided "as is" without express * or implied warranty. / / * Copyright (C) 1998 by the FundsXpress, INC. * * All rights reserved. * * Export of this software from the United States of America may require * a specific license from the United States Government. It is the * responsibility of any person or organization contemplating export to * obtain such a license before exporting. * * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and * distribute this software and its documentation for any purpose and * without fee is hereby granted, provided that the above copyright * notice appear in all copies and that both that copyright notice and * this permission notice appear in supporting documentation, and that * the name of FundsXpress. not be used in advertising or publicity pertaining * to distribution of the software without specific, written prior * permission. FundsXpress makes no representations about the suitability of * this software for any purpose. It is provided "as is" without express * or implied warranty. * * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. / / * Copyright 2009 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. / / KDC Database interface definitions / / This API is not considered as stable as the main krb5 API. * * - We may make arbitrary incompatible changes between feature * releases (e.g. from 1.7 to 1.8). * - We will make some effort to avoid making incompatible changes for * bugfix releases, but will make them if necessary. / #ifndef KRB5_KDB5__ #define KRB5_KDB5__ #include <time.h> #include <krb5.h> / This version will be incremented when incompatible changes are made to the * KDB API, and will be kept in sync with the libkdb major version. / #define KRB5_KDB_API_VERSION 10 / Salt types / #define KRB5_KDB_SALTTYPE_NORMAL 0 / #define KRB5_KDB_SALTTYPE_V4 1 / #define KRB5_KDB_SALTTYPE_NOREALM 2 #define KRB5_KDB_SALTTYPE_ONLYREALM 3 #define KRB5_KDB_SALTTYPE_SPECIAL 4 / #define KRB5_KDB_SALTTYPE_AFS3 5 / #define KRB5_KDB_SALTTYPE_CERTHASH 6 / Attributes / #define KRB5_KDB_DISALLOW_POSTDATED 0x00000001 #define KRB5_KDB_DISALLOW_FORWARDABLE 0x00000002 #define KRB5_KDB_DISALLOW_TGT_BASED 0x00000004 #define KRB5_KDB_DISALLOW_RENEWABLE 0x00000008 #define KRB5_KDB_DISALLOW_PROXIABLE 0x00000010 #define KRB5_KDB_DISALLOW_DUP_SKEY 0x00000020 #define KRB5_KDB_DISALLOW_ALL_TIX 0x00000040 #define KRB5_KDB_REQUIRES_PRE_AUTH 0x00000080 #define KRB5_KDB_REQUIRES_HW_AUTH 0x00000100 #define KRB5_KDB_REQUIRES_PWCHANGE 0x00000200 #define KRB5_KDB_DISALLOW_SVR 0x00001000 #define KRB5_KDB_PWCHANGE_SERVICE 0x00002000 #define KRB5_KDB_SUPPORT_DESMD5 0x00004000 #define KRB5_KDB_NEW_PRINC 0x00008000 #define KRB5_KDB_OK_AS_DELEGATE 0x00100000 #define KRB5_KDB_OK_TO_AUTH_AS_DELEGATE 0x00200000 / S4U2Self OK / #define KRB5_KDB_NO_AUTH_DATA_REQUIRED 0x00400000 #define KRB5_KDB_LOCKDOWN_KEYS 0x00800000 / Creation flags / #define KRB5_KDB_CREATE_BTREE 0x00000001 #define KRB5_KDB_CREATE_HASH 0x00000002 / Entry get flags / / Okay to generate a referral on lookup / #define KRB5_KDB_FLAG_REFERRAL_OK 0x00000010 / Client principal lookup (client referrals only) / #define KRB5_KDB_FLAG_CLIENT 0x00000040 / Map cross-realm principals / #define KRB5_KDB_FLAG_MAP_PRINCIPALS 0x00000080 / Protocol transition / #define KRB5_KDB_FLAG_PROTOCOL_TRANSITION 0x00000100 / Constrained delegation / #define KRB5_KDB_FLAG_CONSTRAINED_DELEGATION 0x00000200 / User-to-user / #define KRB5_KDB_FLAG_USER_TO_USER 0x00000800 / Cross-realm / #define KRB5_KDB_FLAG_CROSS_REALM 0x00001000 / Issuing referral / #define KRB5_KDB_FLAG_ISSUING_REFERRAL 0x00004000 #define KRB5_KDB_FLAGS_S4U ( KRB5_KDB_FLAG_PROTOCOL_TRANSITION \| \ KRB5_KDB_FLAG_CONSTRAINED_DELEGATION ) / KDB iteration flags / #define KRB5_DB_ITER_WRITE 0x00000001 #define KRB5_DB_ITER_REV 0x00000002 #define KRB5_DB_ITER_RECURSE 0x00000004 / String attribute names recognized by krb5 / #define KRB5_KDB_SK_PAC_PRIVSVR_ENCTYPE "pac_privsvr_enctype" #define KRB5_KDB_SK_SESSION_ENCTYPES "session_enctypes" #define KRB5_KDB_SK_REQUIRE_AUTH "require_auth" #define KRB5_KDB_SK_OPTIONAL_PAC_TKT_CHKSUM "optional_pac_tkt_chksum" #if !defined(_WIN32) / * Note --- these structures cannot be modified without changing the * database version number in libkdb.a, but should be expandable by * adding new tl_data types. / typedef struct _krb5_tl_data { struct _krb5_tl_data tl_data_next; /* NOT saved / krb5_int16 tl_data_type; krb5_ui_2 tl_data_length; krb5_octet tl_data_contents; } krb5_tl_data; /* String attributes (currently stored inside tl-data) map C string keys to * values. They can be set via kadmin and consumed by KDC plugins. / typedef struct krb5_string_attr_st { char key; char value; } krb5_string_attr; / * If this ever changes up the version number and make the arrays be as * big as necessary. * * Currently the first type is the enctype and the second is the salt type. / typedef struct _krb5_key_data { krb5_int16 key_data_ver; / Version / krb5_ui_2 key_data_kvno; / Key Version / krb5_int16 key_data_type[2]; / Array of types / krb5_ui_2 key_data_length[2]; / Array of lengths / krb5_octet key_data_contents[2]; /* Array of pointers / } krb5_key_data; #define KRB5_KDB_V1_KEY_DATA_ARRAY 2 / # of array elements / typedef struct _krb5_keysalt { krb5_int16 type; krb5_data data; / Length, data / } krb5_keysalt; / * A principal database entry. Extensions to this structure currently use the * tl_data list. The e_data and e_length fields are not used by any calling * code except kdb5_util dump and load, which marshal and unmarshal the array * in the dump record. KDB modules may use these fields internally as long as * they set e_length appropriately (non-zero if the data should be marshalled * across dump and load, zero if not) and handle null e_data values in * caller-constructed principal entries. / typedef struct _krb5_db_entry_new { krb5_magic magic; / NOT saved / krb5_ui_2 len; krb5_ui_4 mask; / members currently changed/set / krb5_flags attributes; krb5_deltat max_life; krb5_deltat max_renewable_life; krb5_timestamp expiration; / When the client expires / krb5_timestamp pw_expiration; / When its passwd expires / krb5_timestamp last_success; / Last successful passwd / krb5_timestamp last_failed; / Last failed passwd attempt / krb5_kvno fail_auth_count; / # of failed passwd attempt / krb5_int16 n_tl_data; krb5_int16 n_key_data; krb5_ui_2 e_length; / Length of extra data / krb5_octet e_data; /* Extra data to be saved / krb5_principal princ; / Length, data / krb5_tl_data tl_data; /* Linked list / / key_data must be sorted by kvno in descending order. / krb5_key_data key_data; /* Array / } krb5_db_entry; typedef struct _osa_policy_ent_t { int version; char name; krb5_ui_4 pw_min_life; krb5_ui_4 pw_max_life; krb5_ui_4 pw_min_length; krb5_ui_4 pw_min_classes; krb5_ui_4 pw_history_num; krb5_ui_4 policy_refcnt; /* no longer used / / Only valid if version > 1 / krb5_ui_4 pw_max_fail; / pwdMaxFailure / krb5_ui_4 pw_failcnt_interval; / pwdFailureCountInterval / krb5_ui_4 pw_lockout_duration; / pwdLockoutDuration / / Only valid if version > 2 / krb5_ui_4 attributes; krb5_ui_4 max_life; krb5_ui_4 max_renewable_life; char allowed_keysalts; krb5_int16 n_tl_data; krb5_tl_data * tl_data; } osa_policy_ent_rec, osa_policy_ent_t; typedef void (osa_adb_iter_policy_func) (void , osa_policy_ent_t); typedef struct __krb5_key_salt_tuple { krb5_enctype ks_enctype; krb5_int32 ks_salttype; } krb5_key_salt_tuple; #define KRB5_KDB_MAGIC_NUMBER 0xdbdbdbdb #define KRB5_KDB_V1_BASE_LENGTH 38 #define KRB5_KDB_MAX_ALLOWED_KS_LEN 512 #define KRB5_TL_LAST_PWD_CHANGE 0x0001 #define KRB5_TL_MOD_PRINC 0x0002 #define KRB5_TL_KADM_DATA 0x0003 #define KRB5_TL_KADM5_E_DATA 0x0004 #define KRB5_TL_RB1_CHALLENGE 0x0005 #ifdef SECURID #define KRB5_TL_SECURID_STATE 0x0006 #endif / SECURID / #define KRB5_TL_USER_CERTIFICATE 0x0007 #define KRB5_TL_MKVNO 0x0008 #define KRB5_TL_ACTKVNO 0x0009 #define KRB5_TL_MKEY_AUX 0x000a / String attributes may not always be represented in tl-data. kadmin clients * must use the get_strings and set_string RPCs. / #define KRB5_TL_STRING_ATTRS 0x000b #define KRB5_TL_PAC_LOGON_INFO 0x0100 / NDR encoded validation info / #define KRB5_TL_SERVER_REFERRAL 0x0200 / ASN.1 encoded ServerReferralInfo / #define KRB5_TL_SVR_REFERRAL_DATA 0x0300 / ASN.1 encoded PA-SVR-REFERRAL-DATA / #define KRB5_TL_CONSTRAINED_DELEGATION_ACL 0x0400 / Each entry is a permitted SPN / #define KRB5_TL_LM_KEY 0x0500 / LM OWF / #define KRB5_TL_X509_SUBJECT_ISSUER_NAME 0x0600 / <I>IssuerDN<S>SubjectDN / #define KRB5_TL_LAST_ADMIN_UNLOCK 0x0700 / Timestamp of admin unlock / #define KRB5_TL_DB_ARGS 0x7fff / version number for KRB5_TL_ACTKVNO data / #define KRB5_TL_ACTKVNO_VER 1 / version number for KRB5_TL_MKEY_AUX data / #define KRB5_TL_MKEY_AUX_VER 1 typedef struct _krb5_actkvno_node { struct _krb5_actkvno_node next; krb5_kvno act_kvno; krb5_timestamp act_time; } krb5_actkvno_node; typedef struct _krb5_mkey_aux_node { struct _krb5_mkey_aux_node next; krb5_kvno mkey_kvno; / kvno of mkey protecting the latest_mkey / krb5_key_data latest_mkey; / most recent mkey / } krb5_mkey_aux_node; typedef struct _krb5_keylist_node { krb5_keyblock keyblock; krb5_kvno kvno; struct _krb5_keylist_node next; } krb5_keylist_node; /* * Determines the number of failed KDC requests before DISALLOW_ALL_TIX is set * on the principal. / #define KRB5_MAX_FAIL_COUNT 5 / XXX depends on knowledge of krb5_parse_name() formats / #define KRB5_KDB_M_NAME "K/M" / Kerberos/Master / / prompts used by default when reading the KDC password from the keyboard. / #define KRB5_KDC_MKEY_1 "Enter KDC database master key" #define KRB5_KDC_MKEY_2 "Re-enter KDC database master key to verify" extern char krb5_mkey_pwd_prompt1; extern char krb5_mkey_pwd_prompt2; / * These macros specify the encoding of data within the database. * * Data encoding is little-endian. / #ifdef _KRB5_INT_H #include "k5-platform.h" #define krb5_kdb_decode_int16(cp, i16) \ ((krb5_int16 ) &(i16)) = load_16_le(cp) #define krb5_kdb_decode_int32(cp, i32) \ ((krb5_int32 ) &(i32)) = load_32_le(cp) #define krb5_kdb_encode_int16(i16, cp) store_16_le(i16, cp) #define krb5_kdb_encode_int32(i32, cp) store_32_le(i32, cp) #endif / _KRB5_INT_H / #define KRB5_KDB_OPEN_RW 0 #define KRB5_KDB_OPEN_RO 1 #ifndef KRB5_KDB_SRV_TYPE_KDC #define KRB5_KDB_SRV_TYPE_KDC 0x0100 #endif #ifndef KRB5_KDB_SRV_TYPE_ADMIN #define KRB5_KDB_SRV_TYPE_ADMIN 0x0200 #endif / 0x0300 was KRB5_KDB_SRV_TYPE_PASSWD but it is no longer used. / #ifndef KRB5_KDB_SRV_TYPE_OTHER #define KRB5_KDB_SRV_TYPE_OTHER 0x0400 #endif #define KRB5_KDB_OPT_SET_DB_NAME 0 #define KRB5_KDB_OPT_SET_LOCK_MODE 1 #define KRB5_DB_LOCKMODE_SHARED 0x0001 #define KRB5_DB_LOCKMODE_EXCLUSIVE 0x0002 #define KRB5_DB_LOCKMODE_PERMANENT 0x0008 / libkdb.spec / krb5_error_code krb5_db_setup_lib_handle(krb5_context kcontext); krb5_error_code krb5_db_open( krb5_context kcontext, char db_args, int mode ); krb5_error_code krb5_db_init ( krb5_context kcontext ); krb5_error_code krb5_db_create ( krb5_context kcontext, char db_args ); krb5_error_code krb5_db_inited ( krb5_context kcontext ); krb5_error_code kdb5_db_create ( krb5_context kcontext, char db_args ); krb5_error_code krb5_db_fini ( krb5_context kcontext ); const char krb5_db_errcode2string ( krb5_context kcontext, long err_code ); krb5_error_code krb5_db_destroy ( krb5_context kcontext, char db_args ); krb5_error_code krb5_db_promote ( krb5_context kcontext, char db_args ); krb5_error_code krb5_db_get_age ( krb5_context kcontext, char db_name, time_t t ); krb5_error_code krb5_db_lock ( krb5_context kcontext, int lock_mode ); krb5_error_code krb5_db_unlock ( krb5_context kcontext ); krb5_error_code krb5_db_get_principal ( krb5_context kcontext, krb5_const_principal search_for, unsigned int flags, krb5_db_entry *entry ); void krb5_db_free_principal ( krb5_context kcontext, krb5_db_entry entry ); krb5_error_code krb5_db_put_principal ( krb5_context kcontext, krb5_db_entry entry ); krb5_error_code krb5_db_delete_principal ( krb5_context kcontext, krb5_principal search_for ); krb5_error_code krb5_db_rename_principal ( krb5_context kcontext, krb5_principal source, krb5_principal target ); / * Iterate over principals in the KDB. If the callback may write to the DB, * the caller must get an exclusive lock with krb5_db_lock before iterating, * and release it with krb5_db_unlock after iterating. / krb5_error_code krb5_db_iterate ( krb5_context kcontext, char match_entry, int (func) (krb5_pointer, krb5_db_entry ), krb5_pointer func_arg, krb5_flags iterflags ); krb5_error_code krb5_db_store_master_key ( krb5_context kcontext, char keyfile, krb5_principal mname, krb5_kvno kvno, krb5_keyblock key, char master_pwd); krb5_error_code krb5_db_store_master_key_list ( krb5_context kcontext, char keyfile, krb5_principal mname, char master_pwd); krb5_error_code krb5_db_fetch_mkey ( krb5_context context, krb5_principal mname, krb5_enctype etype, krb5_boolean fromkeyboard, krb5_boolean twice, char db_args, krb5_kvno kvno, krb5_data salt, krb5_keyblock key); krb5_error_code krb5_db_fetch_mkey_list( krb5_context context, krb5_principal mname, const krb5_keyblock mkey ); krb5_error_code krb5_dbe_find_enctype( krb5_context kcontext, krb5_db_entry dbentp, krb5_int32 ktype, krb5_int32 stype, krb5_int32 kvno, krb5_key_data kdatap); krb5_error_code krb5_dbe_search_enctype ( krb5_context kcontext, krb5_db_entry dbentp, krb5_int32 start, krb5_int32 ktype, krb5_int32 stype, krb5_int32 kvno, krb5_key_data kdatap); krb5_error_code krb5_db_setup_mkey_name ( krb5_context context, const char keyname, const char realm, char fullname, krb5_principal principal); /** * Decrypts the key given in @@a key_data. If @a mkey is specified, that * master key is used. If @a mkey is NULL, then all master keys are tried. / krb5_error_code krb5_dbe_decrypt_key_data( krb5_context context, const krb5_keyblock mkey, const krb5_key_data * key_data, krb5_keyblock * dbkey, krb5_keysalt * keysalt); krb5_error_code krb5_dbe_encrypt_key_data( krb5_context context, const krb5_keyblock * mkey, const krb5_keyblock * dbkey, const krb5_keysalt * keysalt, int keyver, krb5_key_data * key_data); krb5_error_code krb5_dbe_fetch_act_key_list(krb5_context context, krb5_principal princ, krb5_actkvno_node *act_key_list); krb5_error_code krb5_dbe_find_act_mkey( krb5_context context, krb5_actkvno_node act_mkey_list, krb5_kvno * act_kvno, krb5_keyblock ** act_mkey); krb5_error_code krb5_dbe_find_mkey( krb5_context context, krb5_db_entry * entry, krb5_keyblock ** mkey); /* Set mkvno to mkvno in entry tl_data, or 0 if not present. / krb5_error_code krb5_dbe_lookup_mkvno( krb5_context context, krb5_db_entry * entry, krb5_kvno * mkvno); krb5_keylist_node * krb5_db_mkey_list_alias( krb5_context kcontext ); /* Set mkvno to mkvno in entry tl_data, or minimum value from mkey_list. / krb5_error_code krb5_dbe_get_mkvno( krb5_context context, krb5_db_entry * entry, krb5_kvno * mkvno); krb5_error_code krb5_dbe_lookup_mod_princ_data( krb5_context context, krb5_db_entry * entry, krb5_timestamp * mod_time, krb5_principal * mod_princ); krb5_error_code krb5_dbe_lookup_mkey_aux( krb5_context context, krb5_db_entry * entry, krb5_mkey_aux_node ** mkey_aux_data_list); krb5_error_code krb5_dbe_update_mkvno( krb5_context context, krb5_db_entry * entry, krb5_kvno mkvno); krb5_error_code krb5_dbe_lookup_actkvno( krb5_context context, krb5_db_entry * entry, krb5_actkvno_node ** actkvno_list); krb5_error_code krb5_dbe_update_mkey_aux( krb5_context context, krb5_db_entry * entry, krb5_mkey_aux_node * mkey_aux_data_list); krb5_error_code krb5_dbe_update_actkvno(krb5_context context, krb5_db_entry * entry, const krb5_actkvno_node actkvno_list); krb5_error_code krb5_dbe_update_last_pwd_change( krb5_context context, krb5_db_entry entry, krb5_timestamp stamp); krb5_error_code krb5_dbe_update_last_admin_unlock( krb5_context context, krb5_db_entry * entry, krb5_timestamp stamp); krb5_error_code krb5_dbe_lookup_tl_data( krb5_context context, krb5_db_entry * entry, krb5_tl_data * ret_tl_data); krb5_error_code krb5_dbe_create_key_data( krb5_context context, krb5_db_entry * entry); krb5_error_code krb5_dbe_update_mod_princ_data( krb5_context context, krb5_db_entry * entry, krb5_timestamp mod_date, krb5_const_principal mod_princ); /* * These are wrappers around realloc() and free(). Applications and KDB * modules can use them when manipulating principal and policy entries to * ensure that they allocate and free memory in a manner compatible with the * library. Using libkrb5 or libkbd5 functions to construct values (such as * krb5_copy_principal() to construct the princ field of a krb5_db_entry) is * also safe. On Unix platforms, just using malloc() and free() is safe as * long as the application or module does not use a malloc replacement. / void krb5_db_alloc( krb5_context kcontext, void ptr, size_t size ); void krb5_db_free( krb5_context kcontext, void ptr); krb5_error_code krb5_dbe_lookup_last_pwd_change( krb5_context context, krb5_db_entry * entry, krb5_timestamp * stamp); krb5_error_code krb5_dbe_lookup_last_admin_unlock( krb5_context context, krb5_db_entry * entry, krb5_timestamp * stamp); /* Retrieve the set of string attributes in entry, in no particular order. * Free strings_out with krb5_dbe_free_strings when done. / krb5_error_code krb5_dbe_get_strings(krb5_context context, krb5_db_entry entry, krb5_string_attr strings_out, int count_out); /* Retrieve a single string attribute from entry, or NULL if there is no * attribute for key. Free value_out with krb5_dbe_free_string when done. / krb5_error_code krb5_dbe_get_string(krb5_context context, krb5_db_entry entry, const char key, char *value_out); / Change or add a string attribute in entry, or delete it if value is NULL. / krb5_error_code krb5_dbe_set_string(krb5_context context, krb5_db_entry entry, const char key, const char value); krb5_error_code krb5_dbe_delete_tl_data( krb5_context context, krb5_db_entry * entry, krb5_int16 tl_data_type); krb5_error_code krb5_db_update_tl_data(krb5_context context, krb5_int16 * n_tl_datap, krb5_tl_data *tl_datap, krb5_tl_data new_tl_data); krb5_error_code krb5_dbe_update_tl_data( krb5_context context, krb5_db_entry * entry, krb5_tl_data * new_tl_data); /* Compute the salt for a key data entry given the corresponding principal. / krb5_error_code krb5_dbe_compute_salt(krb5_context context, const krb5_key_data key, krb5_const_principal princ, krb5_int16 salttype_out, krb5_data salt_out); / * Modify the key data of entry to explicitly store salt values using the * KRB5_KDB_SALTTYPE_SPECIAL salt type. / krb5_error_code krb5_dbe_specialize_salt(krb5_context context, krb5_db_entry entry); krb5_error_code krb5_dbe_cpw( krb5_context kcontext, krb5_keyblock * master_key, krb5_key_salt_tuple * ks_tuple, int ks_tuple_count, char * passwd, int new_kvno, krb5_boolean keepold, krb5_db_entry * db_entry); krb5_error_code krb5_dbe_ark( krb5_context context, krb5_keyblock * master_key, krb5_key_salt_tuple * ks_tuple, int ks_tuple_count, krb5_db_entry * db_entry); krb5_error_code krb5_dbe_crk( krb5_context context, krb5_keyblock * master_key, krb5_key_salt_tuple * ks_tuple, int ks_tuple_count, krb5_boolean keepold, krb5_db_entry * db_entry); krb5_error_code krb5_dbe_apw( krb5_context context, krb5_keyblock * master_key, krb5_key_salt_tuple * ks_tuple, int ks_tuple_count, char * passwd, krb5_db_entry * db_entry); int krb5_db_get_key_data_kvno( krb5_context context, int count, krb5_key_data * data); krb5_error_code krb5_db_check_transited_realms(krb5_context kcontext, const krb5_data tr_contents, const krb5_data client_realm, const krb5_data server_realm); krb5_error_code krb5_db_check_policy_as(krb5_context kcontext, krb5_kdc_req request, krb5_db_entry client, krb5_db_entry server, krb5_timestamp kdc_time, const char status, krb5_pa_data e_data); krb5_error_code krb5_db_check_policy_tgs(krb5_context kcontext, krb5_kdc_req request, krb5_db_entry server, krb5_ticket ticket, const char status, krb5_pa_data e_data); void krb5_db_audit_as_req(krb5_context kcontext, krb5_kdc_req request, const krb5_address local_addr, const krb5_address remote_addr, krb5_db_entry client, krb5_db_entry server, krb5_timestamp authtime, krb5_error_code error_code); void krb5_db_refresh_config(krb5_context kcontext); krb5_error_code krb5_db_check_allowed_to_delegate(krb5_context kcontext, krb5_const_principal client, const krb5_db_entry server, krb5_const_principal proxy); krb5_error_code krb5_db_get_s4u_x509_principal(krb5_context kcontext, const krb5_data client_cert, krb5_const_principal in_princ, unsigned int flags, krb5_db_entry *entry); krb5_error_code krb5_db_allowed_to_delegate_from(krb5_context context, krb5_const_principal client, krb5_const_principal server, krb5_pac server_pac, const krb5_db_entry proxy); /** * Sort an array of @a krb5_key_data keys in descending order by their kvno. * Key data order within a kvno is preserved. * * @param key_data * The @a krb5_key_data array to sort. This is sorted in place so the * array will be modified. * @param key_data_length * The length of @a key_data. / void krb5_dbe_sort_key_data(krb5_key_data key_data, size_t key_data_length); krb5_error_code krb5_db_issue_pac(krb5_context context, unsigned int flags, krb5_db_entry client, krb5_keyblock replaced_reply_key, krb5_db_entry server, krb5_db_entry krbtgt, krb5_timestamp authtime, krb5_pac old_pac, krb5_pac new_pac, krb5_data **auth_indicators); / default functions. Should not be directly called / / * Default functions prototype / krb5_error_code krb5_dbe_def_search_enctype( krb5_context kcontext, krb5_db_entry dbentp, krb5_int32 start, krb5_int32 ktype, krb5_int32 stype, krb5_int32 kvno, krb5_key_data kdatap); krb5_error_code krb5_def_store_mkey_list( krb5_context context, char keyfile, krb5_principal mname, krb5_keylist_node keylist, char master_pwd); krb5_error_code krb5_db_def_fetch_mkey( krb5_context context, krb5_principal mname, krb5_keyblock key, krb5_kvno kvno, char db_args); krb5_error_code krb5_def_fetch_mkey_list( krb5_context context, krb5_principal mprinc, const krb5_keyblock mkey, krb5_keylist_node *mkeys_list); krb5_error_code krb5_dbe_def_cpw( krb5_context context, krb5_keyblock master_key, krb5_key_salt_tuple * ks_tuple, int ks_tuple_count, char * passwd, int new_kvno, krb5_boolean keepold, krb5_db_entry * db_entry); krb5_error_code krb5_dbe_def_decrypt_key_data( krb5_context context, const krb5_keyblock * mkey, const krb5_key_data * key_data, krb5_keyblock * dbkey, krb5_keysalt * keysalt); krb5_error_code krb5_dbe_def_encrypt_key_data( krb5_context context, const krb5_keyblock * mkey, const krb5_keyblock * dbkey, const krb5_keysalt * keysalt, int keyver, krb5_key_data * key_data); krb5_error_code krb5_db_def_rename_principal( krb5_context kcontext, krb5_const_principal source, krb5_const_principal target); krb5_error_code krb5_db_create_policy( krb5_context kcontext, osa_policy_ent_t policy); krb5_error_code krb5_db_get_policy ( krb5_context kcontext, char name, osa_policy_ent_t policy ); krb5_error_code krb5_db_put_policy( krb5_context kcontext, osa_policy_ent_t policy); krb5_error_code krb5_db_iter_policy( krb5_context kcontext, char match_entry, osa_adb_iter_policy_func func, void data); krb5_error_code krb5_db_delete_policy( krb5_context kcontext, char policy); void krb5_db_free_policy( krb5_context kcontext, osa_policy_ent_t policy); krb5_error_code krb5_db_set_context(krb5_context, void db_context); krb5_error_code krb5_db_get_context(krb5_context, void *db_context); void krb5_dbe_free_key_data_contents(krb5_context, krb5_key_data ); void krb5_dbe_free_key_list(krb5_context, krb5_keylist_node ); void krb5_dbe_free_actkvno_list(krb5_context, krb5_actkvno_node ); void krb5_dbe_free_mkey_aux_list(krb5_context, krb5_mkey_aux_node ); void krb5_dbe_free_tl_data(krb5_context, krb5_tl_data ); void krb5_dbe_free_strings(krb5_context, krb5_string_attr , int count); void krb5_dbe_free_string(krb5_context, char ); /* * Register the KDB keytab type, allowing "KDB:" to be used as a keytab name. * For this type to work, the context used for keytab operations must have an * associated database handle (via krb5_db_open()). / krb5_error_code krb5_db_register_keytab(krb5_context context); #define KRB5_KDB_DEF_FLAGS 0 #define KDB_MAX_DB_NAME 128 #define KDB_REALM_SECTION "realms" #define KDB_MODULE_POINTER "database_module" #define KDB_MODULE_DEF_SECTION "dbdefaults" #define KDB_MODULE_SECTION "dbmodules" #define KDB_LIB_POINTER "db_library" #define KDB_DATABASE_CONF_FILE DEFAULT_SECURE_PROFILE_PATH #define KDB_DATABASE_ENV_PROF KDC_PROFILE_ENV #define KRB5_KDB_OPEN_RW 0 #define KRB5_KDB_OPEN_RO 1 #define KRB5_KDB_OPT_SET_DB_NAME 0 #define KRB5_KDB_OPT_SET_LOCK_MODE 1 / * This number indicates the date of the last incompatible change to the DAL. * The maj_ver field of the module's vtable structure must match this version. / #define KRB5_KDB_DAL_MAJOR_VERSION 9 / * Note the following when converting a module to DAL version 9: * * - get_authdata_info() and sign_authdata() have been removed, and issue_pac() * has been added. * * - check_allowed_to_delegate() must handle a null proxy argument, returning * success if server has any authorized delegation targets in the traditional * scheme. * * - allowed_to_delegate_from() accepts a krb5_pac parameter (in place * server_ad_info) for the impersonator's PAC. * * - check_allowed_to_delegate() and allowed_to_delegate_from() must return * KRB5KDC_ERR_BADOPTION on authorization failure. * * - the KRB5_KDB_FLAG_ISSUE_PAC and KRB5_FLAG_CLIENT_REFERRALS_ONLY flags have * been combined into KRB5_KDB_FLAG_CLIENT. * * - the KRB5_KDB_FLAG_CANONICALIZE flag has been renamed to * KRB5_KDB_FLAG_REFERRAL_OK, and is only passed to get_principal() when a * realm referral is allowed (AS client and TGS server lookups, when the * CANONICALIZE option is requested or, for AS requests, when the client is * an enterprise principal). As of DAL version 8 the KDB module should * always canonicalize aliases within a realm; the KDC will decide whether to * use the original or canonical principal. / / * A krb5_context can hold one database object. Modules should use * krb5_db_set_context and krb5_db_get_context to store state associated with * the database object. * * Some module functions are mandatory for KDC operation; others are optional * or apply only to administrative operations. If a function is optional, a * module can leave the function pointer as NULL. Alternatively, modules can * return KRB5_PLUGIN_OP_NOTSUPP when asked to perform an inapplicable action. * * Some module functions have default implementations which will call back into * the vtable interface. Leave these functions as NULL to use the default * implementations. * * The documentation in these comments describes the DAL as it is currently * implemented and used, not as it should be. So if anything seems off, that * probably means the current state of things is off. * * Modules must allocate memory for principal entries, policy entries, and * other structures using an allocator compatible with malloc() as seen by * libkdb5 and libkrb5. Modules may link against libkdb5 and call * krb5_db_alloc() to be certain that the same malloc implementation is used. / typedef struct _kdb_vftabl { short int maj_ver; short int min_ver; / * Mandatory: Invoked after the module library is loaded, when the first DB * using the module is opened, across all contexts. / krb5_error_code (init_library)(void); /* * Mandatory: Invoked before the module library is unloaded, after the last * DB using the module is closed, across all contexts. / krb5_error_code (fini_library)(void); /* * Mandatory: Initialize a database object. Profile settings should be * read from conf_section inside KDB_MODULE_SECTION. db_args communicates * command-line arguments for module-specific flags. mode will be one of * KRB5_KDB_OPEN_{RW,RO} or'd with one of * KRB5_KDB_SRV_TYPE_{KDC,ADMIN,PASSWD,OTHER}. / krb5_error_code (init_module)(krb5_context kcontext, char conf_section, char db_args, int mode); / * Mandatory: Finalize the database object contained in a context. Free * any state contained in the db_context pointer and null it out. / krb5_error_code (fini_module)(krb5_context kcontext); /* * Optional: Initialize a database object while creating the underlying * database. conf_section and db_args have the same meaning as in * init_module. This function may return an error if the database already * exists. Used by kdb5_util create. * * If db_args contains the value "temporary", the module should create an * exclusively locked side copy of the database suitable for loading in a * propagation from primary to replica. This side copy will later be * promoted with promote_db, allowing complete updates of the DB with no * loss in read availability. If the module cannot comply with this * architecture, it should return an error. / krb5_error_code (create)(krb5_context kcontext, char conf_section, char db_args); / * Optional: Destroy a database. conf_section and db_args have the same * meaning as in init_module. Used by kdb5_util destroy. In current * usage, the database is destroyed while open, so the module should handle * that. / krb5_error_code (destroy)(krb5_context kcontext, char conf_section, char db_args); / * Deprecated: No longer used as of krb5 1.10; can be removed in the next * DAL revision. Modules should leave as NULL. / krb5_error_code (get_age)(krb5_context kcontext, char db_name, time_t age); /* * Optional: Lock the database, with semantics depending on the mode * argument: * * KRB5_DB_LOCKMODE_SHARED: Lock may coexist with other shared locks. * KRB5_DB_LOCKMODE_EXCLUSIVE: Lock may not coexist with other locks. * KRB5_DB_LOCKMODE_PERMANENT: Exclusive lock surviving process exit. * * Used by the "kadmin lock" command, incremental propagation, and * kdb5_util dump. Incremental propagation support requires shared locks * to operate. kdb5_util dump will continue unlocked if the module returns * KRB5_PLUGIN_OP_NOTSUPP. / krb5_error_code (lock)(krb5_context kcontext, int mode); /* Optional: Release a lock created with db_lock. / krb5_error_code (unlock)(krb5_context kcontext); /* * Mandatory: Set entry to an allocated entry for the principal search_for. If the principal is not found, return KRB5_KDB_NOENTRY. * * The meaning of flags are as follows: * * KRB5_KDB_FLAG_REFERRAL_OK: Set by the KDC when looking up entries for an * AS client with canonicalization requested or for an enterprise * principal, or for a TGS request server with canonicalization * requested. Determines whether the module should return out-of-realm * referrals. * * KRB5_KDB_FLAG_CLIENT: Set by the KDC when looking up a client principal * during an AS or TGS request. Affects how the module should return * out-of-realm referrals. * * KRB5_KDB_FLAG_MAP_PRINCIPALS: Set by the KDC when looking up the client * entry during TGS requests, except for S4U TGS requests and requests * where the server entry has the KRB5_KDB_NO_AUTH_DATA_REQUIRED * attribute. Indicates that the module should map foreign principals * to local principals if it supports doing so. * * KRB5_KDB_FLAG_PROTOCOL_TRANSITION: Set by the KDC when looking up the * client entry during an S4U2Self TGS request. This affects the PAC * information which should be included when authorization data is * generated; see the Microsoft S4U specification for details. * * KRB5_KDB_FLAG_CONSTRAINED_DELEGATION: Set by the KDC when looking up the * client entry during an S4U2Proxy TGS request. Also affects PAC * generation. * * KRB5_KDB_FLAG_CROSS_REALM: Set by the KDC after looking up a server * entry during a TGS request, if the header ticket was issued by a * different realm. * * KRB5_KDB_FLAG_ISSUING_REFERRAL: Set by the KDC after looking up a server * entry during a TGS request, if the requested server principal is not * part of the realm being served, and a referral or alternate TGT will * be issued instead. * * A module may return an in-realm alias by setting (entry)->princ to the canonical name. The KDC will decide based on the request whether to use * the requested name or the canonical name in the issued ticket. * * A module can return a referral to another realm if flags contains * KRB5_KDB_FLAG_REFERRAL_OK. If KRB5_KDB_FLAG_CLIENT is also set, the * module should return a referral by simply filling in an out-of-realm * name in (entry)->princ and setting all other fields to NULL. Otherwise, the module should return the entry for the cross-realm TGS of * the referred-to realm. / krb5_error_code (get_principal)(krb5_context kcontext, krb5_const_principal search_for, unsigned int flags, krb5_db_entry *entry); / * Optional: Create or modify a principal entry. db_args communicates * command-line arguments for module-specific flags. * * The mask field of an entry indicates the changed fields. Mask values * are defined in kadmin's admin.h header. If KADM5_PRINCIPAL is set in * the mask, the entry is new; otherwise it already exists. All fields of * an entry are expected to contain correct values, regardless of whether * they are specified in the mask, so it is acceptable for a module to * ignore the mask and update the entire entry. / krb5_error_code (put_principal)(krb5_context kcontext, krb5_db_entry entry, char db_args); / * Optional: Delete the entry for the principal search_for. If the * principal did not exist, return KRB5_KDB_NOENTRY. / krb5_error_code (delete_principal)(krb5_context kcontext, krb5_const_principal search_for); /* * Optional with default: Rename a principal. If the source principal does * not exist, return KRB5_KDB_NOENTRY. If the target exists, return an * error. * * NOTE: If the module chooses to implement a custom function for renaming * a principal instead of using the default, then rename operations will * fail if iprop logging is enabled. / krb5_error_code (rename_principal)(krb5_context kcontext, krb5_const_principal source, krb5_const_principal target); /* * Optional: For each principal entry in the database, invoke func with the * arguments func_arg and the entry data. If match_entry is specified, the * module may narrow the iteration to principal names matching that regular * expression; a module may alternatively ignore match_entry. / krb5_error_code (iterate)(krb5_context kcontext, char match_entry, int (func)(krb5_pointer, krb5_db_entry ), krb5_pointer func_arg, krb5_flags iterflags); / * Optional: Create a password policy entry. Return an error if the policy * already exists. / krb5_error_code (create_policy)(krb5_context kcontext, osa_policy_ent_t policy); /* * Optional: Set policy to the policy entry of the specified name. If the entry does not exist, return KRB5_KDB_NOENTRY. / krb5_error_code (get_policy)(krb5_context kcontext, char name, osa_policy_ent_t policy); /* * Optional: Modify an existing password policy entry to match the values * in policy. Return an error if the policy does not already exist. / krb5_error_code (put_policy)(krb5_context kcontext, osa_policy_ent_t policy); /* * Optional: For each password policy entry in the database, invoke func * with the arguments data and the entry data. If match_entry is * specified, the module may narrow the iteration to policy names matching * that regular expression; a module may alternatively ignore match_entry. / krb5_error_code (iter_policy)(krb5_context kcontext, char match_entry, osa_adb_iter_policy_func func, void data); /* * Optional: Delete the password policy entry with the name policy. Return * an error if the entry does not exist. / krb5_error_code (delete_policy)(krb5_context kcontext, char policy); / * Optional with default: Retrieve a master keyblock from the stash file * db_args, filling in key and kvno. mname is the name of the master * principal for the realm. * * The default implementation reads the master keyblock from a keytab or * old-format stash file. / krb5_error_code (fetch_master_key)(krb5_context kcontext, krb5_principal mname, krb5_keyblock key, krb5_kvno kvno, char db_args); / * Optional with default: Given a keyblock for some version of the * database's master key, fetch the decrypted master key values from the * database and store the list into mkeys_list. The caller will free mkeys_list using a libkdb5 function which uses the standard free() function, so the module must not use a custom allocator. * * The caller may not know the version number of the master key it has, in * which case it will pass IGNORE_VNO. * * The default implementation ignores kvno and tries the key against the * current master key data and all KRB5_TL_MKEY_AUX values, which contain * copies of the master keys encrypted with old master keys. / krb5_error_code (fetch_master_key_list)(krb5_context kcontext, krb5_principal mname, const krb5_keyblock key, krb5_keylist_node mkeys_list); / * Optional with default: Save a list of master keyblocks, obtained from * fetch_master_key_list, into the stash file db_arg. The caller will set * master_pwd to NULL, so the module should just ignore it. mname is the * name of the master principal for the realm. * * The default implementation saves the list of master keys in a * keytab-format file. / krb5_error_code (store_master_key_list)(krb5_context kcontext, char db_arg, krb5_principal mname, krb5_keylist_node keylist, char master_pwd); / * Optional with default: Starting at position start, scan the key data of a database entry for a key matching the enctype ktype, the salt type * stype, and the version kvno. Store the resulting key into kdatap and set start to the position after the key found. If ktype is negative, match any enctype. If stype is negative, match any salt type. If kvno * is zero or negative, find the most recent key version satisfying the * other constraints. / krb5_error_code (dbe_search_enctype)(krb5_context kcontext, krb5_db_entry dbentp, krb5_int32 start, krb5_int32 ktype, krb5_int32 stype, krb5_int32 kvno, krb5_key_data *kdatap); / * Optional with default: Change the key data for db_entry to include keys * derived from the password passwd in each of the specified key-salt * types, at version new_kvno. Discard the old key data if keepold is not * set. * * The default implementation uses the keyblock master_key to encrypt each * new key, via the function encrypt_key_data. / krb5_error_code (change_pwd)(krb5_context context, krb5_keyblock master_key, krb5_key_salt_tuple ks_tuple, int ks_tuple_count, char passwd, int new_kvno, krb5_boolean keepold, krb5_db_entry db_entry); /* * Optional: Promote a temporary database to be the live one. context must * be initialized with an exclusively locked database created with the * "temporary" db_arg. On success, the database object contained in * context will be finalized. * * This method is used by kdb5_util load to replace the live database with * minimal loss of read availability. / krb5_error_code (promote_db)(krb5_context context, char conf_section, char db_args); / * Optional with default: Decrypt the key in key_data with master keyblock * mkey, placing the result into dbkey. Copy the salt from key_data, if * any, into keysalt. Either dbkey or keysalt may be left unmodified on * successful return if key_data does not contain key or salt information. * * The default implementation expects the encrypted key (in krb5_c_encrypt * format) to be stored in key_data_contents[0], with length given by * key_data_length[0]. If key_data_ver is 2, it expects the salt to be * stored, unencrypted, in key_data_contents[1], with length given by * key_data_length[1]. / krb5_error_code (decrypt_key_data)(krb5_context kcontext, const krb5_keyblock mkey, const krb5_key_data key_data, krb5_keyblock dbkey, krb5_keysalt keysalt); /* * Optional with default: Encrypt dbkey with master keyblock mkey, placing * the result into key_data along with keysalt. * * The default implementation stores the encrypted key (in krb5_c_encrypt * format) in key_data_contents[0] and the length in key_data_length[0]. * If keysalt is specified, it sets key_data_ver to 2, and stores the salt * in key_data_contents[1] and its length in key_data_length[1]. If * keysalt is not specified, key_data_ver is set to 1. / krb5_error_code (encrypt_key_data)(krb5_context kcontext, const krb5_keyblock mkey, const krb5_keyblock dbkey, const krb5_keysalt keysalt, int keyver, krb5_key_data key_data); /* * Optional: Perform a policy check on a cross-realm ticket's transited * field. Return 0 if the check authoritatively succeeds, * KRB5_PLUGIN_NO_HANDLE to use the core transited-checking mechanisms, or * another error (other than KRB5_PLUGIN_OP_NOTSUPP) if the check fails. / krb5_error_code (check_transited_realms)(krb5_context kcontext, const krb5_data tr_contents, const krb5_data client_realm, const krb5_data server_realm); / * Optional: Perform a policy check on an AS request, in addition to the * standard policy checks. Return 0 if the AS request is allowed. If the * AS request is not allowed: * - Place a short string literal into status. - If desired, place data into e_data. Any data placed here will be * freed by the caller using the standard free function. * - Return an appropriate error (such as KRB5KDC_ERR_POLICY). / krb5_error_code (check_policy_as)(krb5_context kcontext, krb5_kdc_req request, krb5_db_entry client, krb5_db_entry server, krb5_timestamp kdc_time, const char status, krb5_pa_data *e_data); / * Optional: Perform a policy check on a TGS request, in addition to the * standard policy checks. Return 0 if the TGS request is allowed. If the * TGS request is not allowed: * - Place a short string literal into status. - If desired, place data into e_data. Any data placed here will be * freed by the caller using the standard free function. * - Return an appropriate error (such as KRB5KDC_ERR_POLICY). * The input parameter ticket contains the TGT used in the TGS request. / krb5_error_code (check_policy_tgs)(krb5_context kcontext, krb5_kdc_req request, krb5_db_entry server, krb5_ticket ticket, const char status, krb5_pa_data *e_data); / * Optional: This method informs the module of a successful or unsuccessful * AS request. / void (audit_as_req)(krb5_context kcontext, krb5_kdc_req request, const krb5_address local_addr, const krb5_address remote_addr, krb5_db_entry client, krb5_db_entry server, krb5_timestamp authtime, krb5_error_code error_code); / Note: there is currently no method for auditing TGS requests. / / * Optional: This method informs the module of a request to reload * configuration or other state (that is, the KDC received a SIGHUP). / void (refresh_config)(krb5_context kcontext); /* * Optional: Perform a policy check on server being allowed to obtain * tickets from client to proxy. If proxy is NULL, check if server has any * authorized delegation targets (client will also be NULL in this case). * (Note that proxy is the target of the delegation, not the delegating * service; the term "proxy" is from the viewpoint of the delegating * service asking another service to perform some of its work in the * authentication context of the client. This terminology comes from the * Microsoft S4U protocol documentation.) Return 0 if policy allows * delegation to the specified target (or to any target if proxy is NULL), * or KRB5KDC_ERR_BADOPTION if not. If this method is not implemented, all * S4U2Proxy delegation requests will be rejected. / krb5_error_code (check_allowed_to_delegate)(krb5_context context, krb5_const_principal client, const krb5_db_entry server, krb5_const_principal proxy); / * Optional: Free the e_data pointer of a database entry. If this method * is not implemented, the e_data pointer in principal entries will be * freed with free() as seen by libkdb5. / void (free_principal_e_data)(krb5_context kcontext, krb5_octet e_data); / * Optional: get a client principal entry based on an X.509 certificate. * * If flags include KRB5_KDB_FLAG_REFERRAL_OK, the certificate was * presented in an AS request. princ->realm indicates the request realm, * but the data components should be ignored. The module can return an * out-of-realm client referral as it would for get_principal(). * * Otherwise, princ is from a TGS request. If it contains data components * (and not just a realm), the module should verify that it is the same as * the lookup result for client_cert. The module should not return a * referral. / krb5_error_code (get_s4u_x509_principal)(krb5_context kcontext, const krb5_data client_cert, krb5_const_principal princ, unsigned int flags, krb5_db_entry entry_out); / * Optional: Perform a policy check on server being allowed to obtain * tickets from client to proxy. This method is similar to * check_allowed_to_delegate, but it operates on the target server DB entry * (called "proxy" here as in Microsoft's protocol documentation) rather * than the intermediate server entry. server_pac is the verified PAC from * the authdata of the intermediate server. Return 0 if policy allows the * delegation, or KRB5KDC_ERR_BADOPTION if not. * * This method is called for S4U2Proxy requests and implements the * resource-based constrained delegation variant, which can support * cross-realm delegation. If this method is not implemented or if it * returns a policy error, the KDC will fall back to * check_allowed_to_delegate if the intermediate and target servers are in * the same realm and the evidence ticket is forwardable. / krb5_error_code (allowed_to_delegate_from)(krb5_context context, krb5_const_principal client, krb5_const_principal server, krb5_pac server_pac, const krb5_db_entry proxy); / * Optional: Add buffers to new_pac using krb5_pac_add_buffer() before it * is signed. * * The caller will handle the following buffer types, so do not copy or add * them: * * KRB5_PAC_SERVER_CHECKSUM * KRB5_PAC_PRIVSVR_CHECKSUM * KRB5_PAC_TICKET_CHECKSUM * KRB5_PAC_CLIENT_INFO * KRB5_PAC_DELEGATION_INFO * * For TGS requests, old_pac is the PAC of the header ticket, except when * KRB5_KDB_FLAG_CONTRAINED_DELEGATION is present in flags, in which case * it is the PAC of the second ticket. If * KRB5_KDB_FLAG_PROTOCOL_TRANSITION is present in flags and client is not * NULL, old_pac is the PAC of the requesting service, not the subject of * the S4U2Self request, and its buffers should not be copied into new_pac. * The signatures and PAC_CLIENT_INFO of old_pac have been verified by the * caller. * * If replaced_reply_key is not null, the request is an AS request and the * reply key was replaced by a preauth mechanism such as PKINIT, meaning * the Kerberos password or long-term key was not used. The module may use * this key to encrypt a PAC_CREDENTIALS_INFO buffer containing credentials * (such as an NTLM hash) that the client would ordinarily derive from the * Kerberos password or long-term key. * * server is the database entry of the server the ticket will be issued to, * which may be a referral TGS. * * signing_krbtgt is the database entry of the krbtgt principal used to * verify old_pac (or null if old_pac is null). If * KRB5_KDB_FLAG_CROSS_REALM is present in flags, this entry will be an * incoming cross-realm TGS, and the PAC fields should undergo appropriate * filtering based on the trust level of the cross-realm relationship. * * auth_indicators points to NULL or a null-terminated list of krb5_data * pointers, each containing an authentication indicator (RFC 8129). The * method may modify this list, or free it and replace auth_indicators with NULL, to change which auth indicators will be included in the * ticket. / krb5_error_code (issue_pac)(krb5_context context, unsigned int flags, krb5_db_entry client, krb5_keyblock replaced_reply_key, krb5_db_entry server, krb5_db_entry signing_krbtgt, krb5_timestamp authtime, krb5_pac old_pac, krb5_pac new_pac, krb5_data **auth_indicators); / End of minor version 0 for major version 9. / } kdb_vftabl; #endif / !defined(_WIN32) / #endif / KRB5_KDB5__ */	62.83 KB	2025-06-24 12:42
📄 keyutils.h /* keyutils.h: key utility library interface * * Copyright (C) 2005,2011 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. / #ifndef KEYUTILS_H #define KEYUTILS_H #include <sys/types.h> #include <stdint.h> #ifdef __cplusplus extern "C" { #endif extern const char keyutils_version_string[]; extern const char keyutils_build_string[]; / key serial number / typedef int32_t key_serial_t; / special process keyring shortcut IDs / #define KEY_SPEC_THREAD_KEYRING -1 / - key ID for thread-specific keyring / #define KEY_SPEC_PROCESS_KEYRING -2 / - key ID for process-specific keyring / #define KEY_SPEC_SESSION_KEYRING -3 / - key ID for session-specific keyring / #define KEY_SPEC_USER_KEYRING -4 / - key ID for UID-specific keyring / #define KEY_SPEC_USER_SESSION_KEYRING -5 / - key ID for UID-session keyring / #define KEY_SPEC_GROUP_KEYRING -6 / - key ID for GID-specific keyring / #define KEY_SPEC_REQKEY_AUTH_KEY -7 / - key ID for assumed request_key auth key / / request-key default keyrings / #define KEY_REQKEY_DEFL_NO_CHANGE -1 #define KEY_REQKEY_DEFL_DEFAULT 0 #define KEY_REQKEY_DEFL_THREAD_KEYRING 1 #define KEY_REQKEY_DEFL_PROCESS_KEYRING 2 #define KEY_REQKEY_DEFL_SESSION_KEYRING 3 #define KEY_REQKEY_DEFL_USER_KEYRING 4 #define KEY_REQKEY_DEFL_USER_SESSION_KEYRING 5 #define KEY_REQKEY_DEFL_GROUP_KEYRING 6 / key handle permissions mask / typedef uint32_t key_perm_t; #define KEY_POS_VIEW 0x01000000 / possessor can view a key's attributes / #define KEY_POS_READ 0x02000000 / possessor can read key payload / view keyring / #define KEY_POS_WRITE 0x04000000 / possessor can update key payload / add link to keyring / #define KEY_POS_SEARCH 0x08000000 / possessor can find a key in search / search a keyring / #define KEY_POS_LINK 0x10000000 / possessor can create a link to a key/keyring / #define KEY_POS_SETATTR 0x20000000 / possessor can set key attributes / #define KEY_POS_ALL 0x3f000000 #define KEY_USR_VIEW 0x00010000 / user permissions... / #define KEY_USR_READ 0x00020000 #define KEY_USR_WRITE 0x00040000 #define KEY_USR_SEARCH 0x00080000 #define KEY_USR_LINK 0x00100000 #define KEY_USR_SETATTR 0x00200000 #define KEY_USR_ALL 0x003f0000 #define KEY_GRP_VIEW 0x00000100 / group permissions... / #define KEY_GRP_READ 0x00000200 #define KEY_GRP_WRITE 0x00000400 #define KEY_GRP_SEARCH 0x00000800 #define KEY_GRP_LINK 0x00001000 #define KEY_GRP_SETATTR 0x00002000 #define KEY_GRP_ALL 0x00003f00 #define KEY_OTH_VIEW 0x00000001 / third party permissions... / #define KEY_OTH_READ 0x00000002 #define KEY_OTH_WRITE 0x00000004 #define KEY_OTH_SEARCH 0x00000008 #define KEY_OTH_LINK 0x00000010 #define KEY_OTH_SETATTR 0x00000020 #define KEY_OTH_ALL 0x0000003f / keyctl commands / #define KEYCTL_GET_KEYRING_ID 0 / ask for a keyring's ID / #define KEYCTL_JOIN_SESSION_KEYRING 1 / join or start named session keyring / #define KEYCTL_UPDATE 2 / update a key / #define KEYCTL_REVOKE 3 / revoke a key / #define KEYCTL_CHOWN 4 / set ownership of a key / #define KEYCTL_SETPERM 5 / set perms on a key / #define KEYCTL_DESCRIBE 6 / describe a key / #define KEYCTL_CLEAR 7 / clear contents of a keyring / #define KEYCTL_LINK 8 / link a key into a keyring / #define KEYCTL_UNLINK 9 / unlink a key from a keyring / #define KEYCTL_SEARCH 10 / search for a key in a keyring / #define KEYCTL_READ 11 / read a key or keyring's contents / #define KEYCTL_INSTANTIATE 12 / instantiate a partially constructed key / #define KEYCTL_NEGATE 13 / negate a partially constructed key / #define KEYCTL_SET_REQKEY_KEYRING 14 / set default request-key keyring / #define KEYCTL_SET_TIMEOUT 15 / set timeout on a key / #define KEYCTL_ASSUME_AUTHORITY 16 / assume authority to instantiate key / #define KEYCTL_GET_SECURITY 17 / get key security label / #define KEYCTL_SESSION_TO_PARENT 18 / set my session keyring on my parent process / #define KEYCTL_REJECT 19 / reject a partially constructed key / #define KEYCTL_INSTANTIATE_IOV 20 / instantiate a partially constructed key / #define KEYCTL_INVALIDATE 21 / invalidate a key / #define KEYCTL_GET_PERSISTENT 22 / get a user's persistent keyring / #define KEYCTL_DH_COMPUTE 23 / Compute Diffie-Hellman values / #define KEYCTL_PKEY_QUERY 24 / Query public key parameters / #define KEYCTL_PKEY_ENCRYPT 25 / Encrypt a blob using a public key / #define KEYCTL_PKEY_DECRYPT 26 / Decrypt a blob using a public key / #define KEYCTL_PKEY_SIGN 27 / Create a public key signature / #define KEYCTL_PKEY_VERIFY 28 / Verify a public key signature / #define KEYCTL_RESTRICT_KEYRING 29 / Restrict keys allowed to link to a keyring / #define KEYCTL_MOVE 30 / Move keys between keyrings / #define KEYCTL_CAPABILITIES 31 / Find capabilities of keyrings subsystem / #define KEYCTL_WATCH_KEY 32 / Watch a key or ring of keys for changes / / keyctl structures / struct keyctl_dh_params { key_serial_t priv; key_serial_t prime; key_serial_t base; }; struct keyctl_kdf_params { char hashname; char otherinfo; uint32_t otherinfolen; uint32_t __spare[8]; }; #define KEYCTL_SUPPORTS_ENCRYPT 0x01 #define KEYCTL_SUPPORTS_DECRYPT 0x02 #define KEYCTL_SUPPORTS_SIGN 0x04 #define KEYCTL_SUPPORTS_VERIFY 0x08 struct keyctl_pkey_query { unsigned int supported_ops; / Which ops are supported / unsigned int key_size; / Size of the key in bits / unsigned short max_data_size; / Maximum size of raw data to sign in bytes / unsigned short max_sig_size; / Maximum size of signature in bytes / unsigned short max_enc_size; / Maximum size of encrypted blob in bytes / unsigned short max_dec_size; / Maximum size of decrypted blob in bytes / unsigned int __spare[10]; }; struct keyctl_pkey_params { key_serial_t key_id; / Serial no. of public key to use / unsigned int in_len; / Input data size / union { unsigned int out_len; / Output buffer size (encrypt/decrypt/sign) / unsigned int in2_len; / Second input data size (verify) / }; unsigned int __spare[7]; }; #define KEYCTL_MOVE_EXCL 0x00000001 / Do not displace from the to-keyring / / * Capabilities flags. The capabilities list is an array of 8-bit integers; * each integer can carry up to 8 flags. / #define KEYCTL_CAPS0_CAPABILITIES 0x01 / KEYCTL_CAPABILITIES supported / #define KEYCTL_CAPS0_PERSISTENT_KEYRINGS 0x02 / Persistent keyrings enabled / #define KEYCTL_CAPS0_DIFFIE_HELLMAN 0x04 / Diffie-Hellman ops enabled / #define KEYCTL_CAPS0_PUBLIC_KEY 0x08 / Public key ops enabled / #define KEYCTL_CAPS0_BIG_KEY 0x10 / big_key-type enabled / #define KEYCTL_CAPS0_INVALIDATE 0x20 / KEYCTL_INVALIDATE supported / #define KEYCTL_CAPS0_RESTRICT_KEYRING 0x40 / KEYCTL_RESTRICT_KEYRING supported / #define KEYCTL_CAPS0_MOVE 0x80 / KEYCTL_MOVE supported / #define KEYCTL_CAPS1_NS_KEYRING_NAME 0x01 / Keyring names are per-user_namespace / #define KEYCTL_CAPS1_NS_KEY_TAG 0x02 / Key indexing can include a namespace tag / #define KEYCTL_CAPS1_NOTIFICATIONS 0x04 / Keys generate watchable notifications / / * syscall wrappers / extern key_serial_t add_key(const char type, const char description, const void payload, size_t plen, key_serial_t ringid); extern key_serial_t request_key(const char type, const char description, const char callout_info, key_serial_t destringid); extern long keyctl(int cmd, ...); / * keyctl function wrappers / extern key_serial_t keyctl_get_keyring_ID(key_serial_t id, int create); extern key_serial_t keyctl_join_session_keyring(const char name); extern long keyctl_update(key_serial_t id, const void payload, size_t plen); extern long keyctl_revoke(key_serial_t id); extern long keyctl_chown(key_serial_t id, uid_t uid, gid_t gid); extern long keyctl_setperm(key_serial_t id, key_perm_t perm); extern long keyctl_describe(key_serial_t id, char buffer, size_t buflen); extern long keyctl_clear(key_serial_t ringid); extern long keyctl_link(key_serial_t id, key_serial_t ringid); extern long keyctl_unlink(key_serial_t id, key_serial_t ringid); extern long keyctl_search(key_serial_t ringid, const char type, const char description, key_serial_t destringid); extern long keyctl_read(key_serial_t id, char buffer, size_t buflen); extern long keyctl_instantiate(key_serial_t id, const void payload, size_t plen, key_serial_t ringid); extern long keyctl_negate(key_serial_t id, unsigned timeout, key_serial_t ringid); extern long keyctl_set_reqkey_keyring(int reqkey_defl); extern long keyctl_set_timeout(key_serial_t key, unsigned timeout); extern long keyctl_assume_authority(key_serial_t key); extern long keyctl_get_security(key_serial_t key, char buffer, size_t buflen); extern long keyctl_session_to_parent(void); extern long keyctl_reject(key_serial_t id, unsigned timeout, unsigned error, key_serial_t ringid); struct iovec; extern long keyctl_instantiate_iov(key_serial_t id, const struct iovec payload_iov, unsigned ioc, key_serial_t ringid); extern long keyctl_invalidate(key_serial_t id); extern long keyctl_get_persistent(uid_t uid, key_serial_t id); extern long keyctl_dh_compute(key_serial_t priv, key_serial_t prime, key_serial_t base, char buffer, size_t buflen); extern long keyctl_dh_compute_kdf(key_serial_t priv, key_serial_t prime, key_serial_t base, char hashname, char otherinfo, size_t otherinfolen, char buffer, size_t buflen); extern long keyctl_restrict_keyring(key_serial_t keyring, const char type, const char restriction); extern long keyctl_pkey_query(key_serial_t key_id, const char info, struct keyctl_pkey_query result); extern long keyctl_pkey_encrypt(key_serial_t key_id, const char info, const void data, size_t data_len, void enc, size_t enc_len); extern long keyctl_pkey_decrypt(key_serial_t key_id, const char info, const void enc, size_t enc_len, void data, size_t data_len); extern long keyctl_pkey_sign(key_serial_t key_id, const char info, const void data, size_t data_len, void sig, size_t sig_len); extern long keyctl_pkey_verify(key_serial_t key_id, const char info, const void data, size_t data_len, const void sig, size_t sig_len); extern long keyctl_move(key_serial_t id, key_serial_t from_ringid, key_serial_t to_ringid, unsigned int flags); extern long keyctl_capabilities(unsigned char buffer, size_t buflen); extern long keyctl_watch_key(key_serial_t id, int watch_queue_fd, int watch_id); / * utilities / extern int keyctl_describe_alloc(key_serial_t id, char _buffer); extern int keyctl_read_alloc(key_serial_t id, void _buffer); extern int keyctl_get_security_alloc(key_serial_t id, char _buffer); extern int keyctl_dh_compute_alloc(key_serial_t priv, key_serial_t prime, key_serial_t base, void _buffer); typedef int (recursive_key_scanner_t)(key_serial_t parent, key_serial_t key, char desc, int desc_len, void data); extern int recursive_key_scan(key_serial_t key, recursive_key_scanner_t func, void data); extern int recursive_session_key_scan(recursive_key_scanner_t func, void data); extern key_serial_t find_key_by_type_and_desc(const char type, const char desc, key_serial_t destringid); #ifdef __cplusplus } #endif #endif /* KEYUTILS_H */	11.52 KB	2023-04-05 19:15
📄 krad.h /* -- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -- / / * Copyright 2013 Red Hat, 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 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. / / * This API is not considered as stable as the main krb5 API. * * - We may make arbitrary incompatible changes between feature releases * (e.g. from 1.12 to 1.13). * - We will make some effort to avoid making incompatible changes for * bugfix releases, but will make them if necessary. / #ifndef KRAD_H_ #define KRAD_H_ #include <krb5.h> #include <verto.h> #include <stddef.h> #include <stdio.h> #define KRAD_PACKET_SIZE_MAX 4096 #define KRAD_SERVICE_TYPE_LOGIN 1 #define KRAD_SERVICE_TYPE_FRAMED 2 #define KRAD_SERVICE_TYPE_CALLBACK_LOGIN 3 #define KRAD_SERVICE_TYPE_CALLBACK_FRAMED 4 #define KRAD_SERVICE_TYPE_OUTBOUND 5 #define KRAD_SERVICE_TYPE_ADMINISTRATIVE 6 #define KRAD_SERVICE_TYPE_NAS_PROMPT 7 #define KRAD_SERVICE_TYPE_AUTHENTICATE_ONLY 8 #define KRAD_SERVICE_TYPE_CALLBACK_NAS_PROMPT 9 #define KRAD_SERVICE_TYPE_CALL_CHECK 10 #define KRAD_SERVICE_TYPE_CALLBACK_ADMINISTRATIVE 11 typedef struct krad_attrset_st krad_attrset; typedef struct krad_packet_st krad_packet; typedef struct krad_client_st krad_client; typedef unsigned char krad_code; typedef unsigned char krad_attr; / Called when a response is received or the request times out. / typedef void (krad_cb)(krb5_error_code retval, const krad_packet request, const krad_packet response, void data); / * Called to iterate over a set of requests. Either the callback will be * called until it returns NULL, or it will be called with cancel = TRUE to * terminate in the middle of an iteration. / typedef const krad_packet (krad_packet_iter_cb)(void data, krb5_boolean cancel); /* * Code / / Convert a code name to its number. Only works for codes defined * by RFC 2875 or 2882. Returns 0 if the name was not found. / krad_code krad_code_name2num(const char name); /* Convert a code number to its name. Only works for attributes defined * by RFC 2865 or 2882. Returns NULL if the name was not found. / const char krad_code_num2name(krad_code code); /* * Attribute / / Convert an attribute name to its number. Only works for attributes defined * by RFC 2865. Returns 0 if the name was not found. / krad_attr krad_attr_name2num(const char name); /* Convert an attribute number to its name. Only works for attributes defined * by RFC 2865. Returns NULL if the name was not found. / const char krad_attr_num2name(krad_attr type); /* * Attribute set / / Create a new attribute set. / krb5_error_code krad_attrset_new(krb5_context ctx, krad_attrset set); / Create a deep copy of an attribute set. / krb5_error_code krad_attrset_copy(const krad_attrset set, krad_attrset *copy); / Free an attribute set. / void krad_attrset_free(krad_attrset set); /* Add an attribute to a set. / krb5_error_code krad_attrset_add(krad_attrset set, krad_attr type, const krb5_data data); / Add a four-octet unsigned number attribute to the given set. / krb5_error_code krad_attrset_add_number(krad_attrset set, krad_attr type, krb5_ui_4 num); /* Delete the specified attribute. / void krad_attrset_del(krad_attrset set, krad_attr type, size_t indx); /* Get the specified attribute. / const krb5_data krad_attrset_get(const krad_attrset set, krad_attr type, size_t indx); / * Packet / / Determine the bytes needed from the socket to get the whole packet. Don't * cache the return value as it can change! Returns -1 on EBADMSG. / ssize_t krad_packet_bytes_needed(const krb5_data buffer); /* Free a packet. / void krad_packet_free(krad_packet pkt); /* * Create a new request packet. * * This function takes the attributes specified in set and converts them into a * radius packet. The packet will have a randomized id. If cb is not NULL, it * will be called passing data as the argument to iterate over a set of * outstanding requests. In this case, the id will be both random and unique * across the set of requests. / krb5_error_code krad_packet_new_request(krb5_context ctx, const char secret, krad_code code, const krad_attrset set, krad_packet_iter_cb cb, void data, krad_packet *request); / * Create a new response packet. * * This function is similar to krad_packet_new_requst() except that it crafts a * packet in response to a request packet. This new packet will borrow values * from the request such as the id and the authenticator. / krb5_error_code krad_packet_new_response(krb5_context ctx, const char secret, krad_code code, const krad_attrset set, const krad_packet request, krad_packet *response); / * Decode a request radius packet from krb5_data. * * The resulting decoded packet will be a request packet stored in reqpkt. * If cb is NULL, duppkt will always be NULL. * If cb is not NULL, it will be called (with the data argument) to iterate * over a set of requests currently being processed. In this case, if the * packet is a duplicate of an already received request, the original request * will be set in duppkt. / krb5_error_code krad_packet_decode_request(krb5_context ctx, const char secret, const krb5_data buffer, krad_packet_iter_cb cb, void data, const krad_packet duppkt, krad_packet reqpkt); / * Decode a response radius packet from krb5_data. * * The resulting decoded packet will be a response packet stored in rsppkt. * If cb is NULL, reqpkt will always be NULL. * If cb is not NULL, it will be called (with the data argument) to iterate * over a set of requests awaiting responses. In this case, if the response * packet matches one of these requests, the original request will be set in * reqpkt. / krb5_error_code krad_packet_decode_response(krb5_context ctx, const char secret, const krb5_data buffer, krad_packet_iter_cb cb, void data, const krad_packet reqpkt, krad_packet rsppkt); / Encode packet. / const krb5_data krad_packet_encode(const krad_packet pkt); / Get the code for the given packet. / krad_code krad_packet_get_code(const krad_packet pkt); /* Get the specified attribute. / const krb5_data krad_packet_get_attr(const krad_packet pkt, krad_attr type, size_t indx); / * Client / / Create a new client. / krb5_error_code krad_client_new(krb5_context kctx, verto_ctx vctx, krad_client *client); / Free the client. / void krad_client_free(krad_client client); /* * Send a request to a radius server. * * The remote host may be specified by one of the following formats: * - /path/to/unix.socket * - IPv4 * - IPv4:port * - IPv4:service * - [IPv6] * - [IPv6]:port * - [IPv6]:service * - hostname * - hostname:port * - hostname:service * * The timeout parameter (milliseconds) is the total timeout across all remote * hosts (when DNS returns multiple entries) and all retries. For stream * sockets, the retries parameter is ignored and no retries are performed. * * The cb function will be called with the data argument when either a response * is received or the request times out on all possible remote hosts. / krb5_error_code krad_client_send(krad_client rc, krad_code code, const krad_attrset attrs, const char remote, const char secret, int timeout, size_t retries, krad_cb cb, void data); #endif /* KRAD_H_ */	8.72 KB	2023-07-10 20:58
📁 krb5	-	2026-03-21 15:53
📄 krb5.h /* -- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -- / / The MIT Kerberos header file krb5.h used to live here. As of the 1.5 release, we're installing multiple Kerberos headers, so they're all moving to a krb5/ subdirectory. This file is present just to keep old software still compiling. Please update your code to use the new path for the header. */ #include <krb5/krb5.h>	402 B	2023-07-10 20:58
📄 langinfo.h /* Access to locale-dependent parameters. Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _LANGINFO_H #define _LANGINFO_H 1 / Get the type definition. / #include <nl_types.h> #include <bits/locale.h> / Define the __LC_* category names. / __BEGIN_DECLS / Construct an `nl_item' value for `nl_langinfo' from a locale category (LC_) and an item index within the category. Some code may depend on the item values within a category increasing monotonically with the indices. / #define _NL_ITEM(category, index) (((category) << 16) \| (index)) /* Extract the category and item index from a constructed `nl_item' value. / #define _NL_ITEM_CATEGORY(item) ((int) (item) >> 16) #define _NL_ITEM_INDEX(item) ((int) (item) & 0xffff) / Enumeration of locale items that can be queried with `nl_langinfo'. / enum { / LC_TIME category: date and time formatting. / / Abbreviated days of the week. / ABDAY_1 = _NL_ITEM (__LC_TIME, 0), / Sun / #define ABDAY_1 ABDAY_1 ABDAY_2, #define ABDAY_2 ABDAY_2 ABDAY_3, #define ABDAY_3 ABDAY_3 ABDAY_4, #define ABDAY_4 ABDAY_4 ABDAY_5, #define ABDAY_5 ABDAY_5 ABDAY_6, #define ABDAY_6 ABDAY_6 ABDAY_7, #define ABDAY_7 ABDAY_7 / Long-named days of the week. / DAY_1, / Sunday / #define DAY_1 DAY_1 DAY_2, / Monday / #define DAY_2 DAY_2 DAY_3, / Tuesday / #define DAY_3 DAY_3 DAY_4, / Wednesday / #define DAY_4 DAY_4 DAY_5, / Thursday / #define DAY_5 DAY_5 DAY_6, / Friday / #define DAY_6 DAY_6 DAY_7, / Saturday / #define DAY_7 DAY_7 / Abbreviated month names, in the grammatical form used when the month is a part of a complete date. / ABMON_1, / Jan / #define ABMON_1 ABMON_1 ABMON_2, #define ABMON_2 ABMON_2 ABMON_3, #define ABMON_3 ABMON_3 ABMON_4, #define ABMON_4 ABMON_4 ABMON_5, #define ABMON_5 ABMON_5 ABMON_6, #define ABMON_6 ABMON_6 ABMON_7, #define ABMON_7 ABMON_7 ABMON_8, #define ABMON_8 ABMON_8 ABMON_9, #define ABMON_9 ABMON_9 ABMON_10, #define ABMON_10 ABMON_10 ABMON_11, #define ABMON_11 ABMON_11 ABMON_12, #define ABMON_12 ABMON_12 / Long month names, in the grammatical form used when the month is a part of a complete date. / MON_1, / January / #define MON_1 MON_1 MON_2, #define MON_2 MON_2 MON_3, #define MON_3 MON_3 MON_4, #define MON_4 MON_4 MON_5, #define MON_5 MON_5 MON_6, #define MON_6 MON_6 MON_7, #define MON_7 MON_7 MON_8, #define MON_8 MON_8 MON_9, #define MON_9 MON_9 MON_10, #define MON_10 MON_10 MON_11, #define MON_11 MON_11 MON_12, #define MON_12 MON_12 AM_STR, / Ante meridiem string. / #define AM_STR AM_STR PM_STR, / Post meridiem string. / #define PM_STR PM_STR D_T_FMT, / Date and time format for strftime. / #define D_T_FMT D_T_FMT D_FMT, / Date format for strftime. / #define D_FMT D_FMT T_FMT, / Time format for strftime. / #define T_FMT T_FMT T_FMT_AMPM, / 12-hour time format for strftime. / #define T_FMT_AMPM T_FMT_AMPM ERA, / Alternate era. / #define ERA ERA __ERA_YEAR, / Year in alternate era format. / #ifdef __USE_GNU # define ERA_YEAR __ERA_YEAR #endif ERA_D_FMT, / Date in alternate era format. / #define ERA_D_FMT ERA_D_FMT ALT_DIGITS, / Alternate symbols for digits. / #define ALT_DIGITS ALT_DIGITS ERA_D_T_FMT, / Date and time in alternate era format. / #define ERA_D_T_FMT ERA_D_T_FMT ERA_T_FMT, / Time in alternate era format. / #define ERA_T_FMT ERA_T_FMT _NL_TIME_ERA_NUM_ENTRIES, / Number entries in the era arrays. / _NL_TIME_ERA_ENTRIES, / Structure with era entries in usable form./ _NL_WABDAY_1, / Sun / _NL_WABDAY_2, _NL_WABDAY_3, _NL_WABDAY_4, _NL_WABDAY_5, _NL_WABDAY_6, _NL_WABDAY_7, / Long-named days of the week. / _NL_WDAY_1, / Sunday / _NL_WDAY_2, / Monday / _NL_WDAY_3, / Tuesday / _NL_WDAY_4, / Wednesday / _NL_WDAY_5, / Thursday / _NL_WDAY_6, / Friday / _NL_WDAY_7, / Saturday / / Abbreviated month names, in the grammatical form used when the month is a part of a complete date. / _NL_WABMON_1, / Jan / _NL_WABMON_2, _NL_WABMON_3, _NL_WABMON_4, _NL_WABMON_5, _NL_WABMON_6, _NL_WABMON_7, _NL_WABMON_8, _NL_WABMON_9, _NL_WABMON_10, _NL_WABMON_11, _NL_WABMON_12, / Long month names, in the grammatical form used when the month is a part of a complete date. / _NL_WMON_1, / January / _NL_WMON_2, _NL_WMON_3, _NL_WMON_4, _NL_WMON_5, _NL_WMON_6, _NL_WMON_7, _NL_WMON_8, _NL_WMON_9, _NL_WMON_10, _NL_WMON_11, _NL_WMON_12, _NL_WAM_STR, / Ante meridiem string. / _NL_WPM_STR, / Post meridiem string. / _NL_WD_T_FMT, / Date and time format for strftime. / _NL_WD_FMT, / Date format for strftime. / _NL_WT_FMT, / Time format for strftime. / _NL_WT_FMT_AMPM, / 12-hour time format for strftime. / _NL_WERA_YEAR, / Year in alternate era format. / _NL_WERA_D_FMT, / Date in alternate era format. / _NL_WALT_DIGITS, / Alternate symbols for digits. / _NL_WERA_D_T_FMT, / Date and time in alternate era format. / _NL_WERA_T_FMT, / Time in alternate era format. / _NL_TIME_WEEK_NDAYS, _NL_TIME_WEEK_1STDAY, _NL_TIME_WEEK_1STWEEK, _NL_TIME_FIRST_WEEKDAY, _NL_TIME_FIRST_WORKDAY, _NL_TIME_CAL_DIRECTION, _NL_TIME_TIMEZONE, _DATE_FMT, / strftime format for date. / #define _DATE_FMT _DATE_FMT _NL_W_DATE_FMT, _NL_TIME_CODESET, / Long month names, in the grammatical form used when the month is named by itself. / __ALTMON_1, / January / __ALTMON_2, __ALTMON_3, __ALTMON_4, __ALTMON_5, __ALTMON_6, __ALTMON_7, __ALTMON_8, __ALTMON_9, __ALTMON_10, __ALTMON_11, __ALTMON_12, #ifdef __USE_GNU # define ALTMON_1 __ALTMON_1 # define ALTMON_2 __ALTMON_2 # define ALTMON_3 __ALTMON_3 # define ALTMON_4 __ALTMON_4 # define ALTMON_5 __ALTMON_5 # define ALTMON_6 __ALTMON_6 # define ALTMON_7 __ALTMON_7 # define ALTMON_8 __ALTMON_8 # define ALTMON_9 __ALTMON_9 # define ALTMON_10 __ALTMON_10 # define ALTMON_11 __ALTMON_11 # define ALTMON_12 __ALTMON_12 #endif / Long month names, in the grammatical form used when the month is named by itself. / _NL_WALTMON_1, / January / _NL_WALTMON_2, _NL_WALTMON_3, _NL_WALTMON_4, _NL_WALTMON_5, _NL_WALTMON_6, _NL_WALTMON_7, _NL_WALTMON_8, _NL_WALTMON_9, _NL_WALTMON_10, _NL_WALTMON_11, _NL_WALTMON_12, / Abbreviated month names, in the grammatical form used when the month is named by itself. / _NL_ABALTMON_1, / Jan / _NL_ABALTMON_2, _NL_ABALTMON_3, _NL_ABALTMON_4, _NL_ABALTMON_5, _NL_ABALTMON_6, _NL_ABALTMON_7, _NL_ABALTMON_8, _NL_ABALTMON_9, _NL_ABALTMON_10, _NL_ABALTMON_11, _NL_ABALTMON_12, / Abbreviated month names, in the grammatical form used when the month is named by itself. / _NL_WABALTMON_1, / Jan / _NL_WABALTMON_2, _NL_WABALTMON_3, _NL_WABALTMON_4, _NL_WABALTMON_5, _NL_WABALTMON_6, _NL_WABALTMON_7, _NL_WABALTMON_8, _NL_WABALTMON_9, _NL_WABALTMON_10, _NL_WABALTMON_11, _NL_WABALTMON_12, _NL_NUM_LC_TIME, / Number of indices in LC_TIME category. / / LC_COLLATE category: text sorting. This information is accessed by the strcoll and strxfrm functions. These `nl_langinfo' names are used only internally. / _NL_COLLATE_NRULES = _NL_ITEM (__LC_COLLATE, 0), _NL_COLLATE_RULESETS, _NL_COLLATE_TABLEMB, _NL_COLLATE_WEIGHTMB, _NL_COLLATE_EXTRAMB, _NL_COLLATE_INDIRECTMB, _NL_COLLATE_GAP1, _NL_COLLATE_GAP2, _NL_COLLATE_GAP3, _NL_COLLATE_TABLEWC, _NL_COLLATE_WEIGHTWC, _NL_COLLATE_EXTRAWC, _NL_COLLATE_INDIRECTWC, _NL_COLLATE_SYMB_HASH_SIZEMB, _NL_COLLATE_SYMB_TABLEMB, _NL_COLLATE_SYMB_EXTRAMB, _NL_COLLATE_COLLSEQMB, _NL_COLLATE_COLLSEQWC, _NL_COLLATE_CODESET, _NL_NUM_LC_COLLATE, / LC_CTYPE category: character classification. This information is accessed by the functions in <ctype.h>. These `nl_langinfo' names are used only internally. / _NL_CTYPE_CLASS = _NL_ITEM (__LC_CTYPE, 0), _NL_CTYPE_TOUPPER, _NL_CTYPE_GAP1, _NL_CTYPE_TOLOWER, _NL_CTYPE_GAP2, _NL_CTYPE_CLASS32, _NL_CTYPE_GAP3, _NL_CTYPE_GAP4, _NL_CTYPE_GAP5, _NL_CTYPE_GAP6, _NL_CTYPE_CLASS_NAMES, _NL_CTYPE_MAP_NAMES, _NL_CTYPE_WIDTH, _NL_CTYPE_MB_CUR_MAX, _NL_CTYPE_CODESET_NAME, CODESET = _NL_CTYPE_CODESET_NAME, #define CODESET CODESET _NL_CTYPE_TOUPPER32, _NL_CTYPE_TOLOWER32, _NL_CTYPE_CLASS_OFFSET, _NL_CTYPE_MAP_OFFSET, _NL_CTYPE_INDIGITS_MB_LEN, _NL_CTYPE_INDIGITS0_MB, _NL_CTYPE_INDIGITS1_MB, _NL_CTYPE_INDIGITS2_MB, _NL_CTYPE_INDIGITS3_MB, _NL_CTYPE_INDIGITS4_MB, _NL_CTYPE_INDIGITS5_MB, _NL_CTYPE_INDIGITS6_MB, _NL_CTYPE_INDIGITS7_MB, _NL_CTYPE_INDIGITS8_MB, _NL_CTYPE_INDIGITS9_MB, _NL_CTYPE_INDIGITS_WC_LEN, _NL_CTYPE_INDIGITS0_WC, _NL_CTYPE_INDIGITS1_WC, _NL_CTYPE_INDIGITS2_WC, _NL_CTYPE_INDIGITS3_WC, _NL_CTYPE_INDIGITS4_WC, _NL_CTYPE_INDIGITS5_WC, _NL_CTYPE_INDIGITS6_WC, _NL_CTYPE_INDIGITS7_WC, _NL_CTYPE_INDIGITS8_WC, _NL_CTYPE_INDIGITS9_WC, _NL_CTYPE_OUTDIGIT0_MB, _NL_CTYPE_OUTDIGIT1_MB, _NL_CTYPE_OUTDIGIT2_MB, _NL_CTYPE_OUTDIGIT3_MB, _NL_CTYPE_OUTDIGIT4_MB, _NL_CTYPE_OUTDIGIT5_MB, _NL_CTYPE_OUTDIGIT6_MB, _NL_CTYPE_OUTDIGIT7_MB, _NL_CTYPE_OUTDIGIT8_MB, _NL_CTYPE_OUTDIGIT9_MB, _NL_CTYPE_OUTDIGIT0_WC, _NL_CTYPE_OUTDIGIT1_WC, _NL_CTYPE_OUTDIGIT2_WC, _NL_CTYPE_OUTDIGIT3_WC, _NL_CTYPE_OUTDIGIT4_WC, _NL_CTYPE_OUTDIGIT5_WC, _NL_CTYPE_OUTDIGIT6_WC, _NL_CTYPE_OUTDIGIT7_WC, _NL_CTYPE_OUTDIGIT8_WC, _NL_CTYPE_OUTDIGIT9_WC, _NL_CTYPE_TRANSLIT_TAB_SIZE, _NL_CTYPE_TRANSLIT_FROM_IDX, _NL_CTYPE_TRANSLIT_FROM_TBL, _NL_CTYPE_TRANSLIT_TO_IDX, _NL_CTYPE_TRANSLIT_TO_TBL, _NL_CTYPE_TRANSLIT_DEFAULT_MISSING_LEN, _NL_CTYPE_TRANSLIT_DEFAULT_MISSING, _NL_CTYPE_TRANSLIT_IGNORE_LEN, _NL_CTYPE_TRANSLIT_IGNORE, _NL_CTYPE_MAP_TO_NONASCII, _NL_CTYPE_NONASCII_CASE, _NL_CTYPE_EXTRA_MAP_1, _NL_CTYPE_EXTRA_MAP_2, _NL_CTYPE_EXTRA_MAP_3, _NL_CTYPE_EXTRA_MAP_4, _NL_CTYPE_EXTRA_MAP_5, _NL_CTYPE_EXTRA_MAP_6, _NL_CTYPE_EXTRA_MAP_7, _NL_CTYPE_EXTRA_MAP_8, _NL_CTYPE_EXTRA_MAP_9, _NL_CTYPE_EXTRA_MAP_10, _NL_CTYPE_EXTRA_MAP_11, _NL_CTYPE_EXTRA_MAP_12, _NL_CTYPE_EXTRA_MAP_13, _NL_CTYPE_EXTRA_MAP_14, _NL_NUM_LC_CTYPE, / LC_MONETARY category: formatting of monetary quantities. These items each correspond to a member of `struct lconv', defined in <locale.h>. / __INT_CURR_SYMBOL = _NL_ITEM (__LC_MONETARY, 0), #ifdef __USE_GNU # define INT_CURR_SYMBOL __INT_CURR_SYMBOL #endif __CURRENCY_SYMBOL, #ifdef __USE_GNU # define CURRENCY_SYMBOL __CURRENCY_SYMBOL #endif __MON_DECIMAL_POINT, #ifdef __USE_GNU # define MON_DECIMAL_POINT __MON_DECIMAL_POINT #endif __MON_THOUSANDS_SEP, #ifdef __USE_GNU # define MON_THOUSANDS_SEP __MON_THOUSANDS_SEP #endif __MON_GROUPING, #ifdef __USE_GNU # define MON_GROUPING __MON_GROUPING #endif __POSITIVE_SIGN, #ifdef __USE_GNU # define POSITIVE_SIGN __POSITIVE_SIGN #endif __NEGATIVE_SIGN, #ifdef __USE_GNU # define NEGATIVE_SIGN __NEGATIVE_SIGN #endif __INT_FRAC_DIGITS, #ifdef __USE_GNU # define INT_FRAC_DIGITS __INT_FRAC_DIGITS #endif __FRAC_DIGITS, #ifdef __USE_GNU # define FRAC_DIGITS __FRAC_DIGITS #endif __P_CS_PRECEDES, #ifdef __USE_GNU # define P_CS_PRECEDES __P_CS_PRECEDES #endif __P_SEP_BY_SPACE, #ifdef __USE_GNU # define P_SEP_BY_SPACE __P_SEP_BY_SPACE #endif __N_CS_PRECEDES, #ifdef __USE_GNU # define N_CS_PRECEDES __N_CS_PRECEDES #endif __N_SEP_BY_SPACE, #ifdef __USE_GNU # define N_SEP_BY_SPACE __N_SEP_BY_SPACE #endif __P_SIGN_POSN, #ifdef __USE_GNU # define P_SIGN_POSN __P_SIGN_POSN #endif __N_SIGN_POSN, #ifdef __USE_GNU # define N_SIGN_POSN __N_SIGN_POSN #endif _NL_MONETARY_CRNCYSTR, #define CRNCYSTR _NL_MONETARY_CRNCYSTR __INT_P_CS_PRECEDES, #ifdef __USE_GNU # define INT_P_CS_PRECEDES __INT_P_CS_PRECEDES #endif __INT_P_SEP_BY_SPACE, #ifdef __USE_GNU # define INT_P_SEP_BY_SPACE __INT_P_SEP_BY_SPACE #endif __INT_N_CS_PRECEDES, #ifdef __USE_GNU # define INT_N_CS_PRECEDES __INT_N_CS_PRECEDES #endif __INT_N_SEP_BY_SPACE, #ifdef __USE_GNU # define INT_N_SEP_BY_SPACE __INT_N_SEP_BY_SPACE #endif __INT_P_SIGN_POSN, #ifdef __USE_GNU # define INT_P_SIGN_POSN __INT_P_SIGN_POSN #endif __INT_N_SIGN_POSN, #ifdef __USE_GNU # define INT_N_SIGN_POSN __INT_N_SIGN_POSN #endif _NL_MONETARY_DUO_INT_CURR_SYMBOL, _NL_MONETARY_DUO_CURRENCY_SYMBOL, _NL_MONETARY_DUO_INT_FRAC_DIGITS, _NL_MONETARY_DUO_FRAC_DIGITS, _NL_MONETARY_DUO_P_CS_PRECEDES, _NL_MONETARY_DUO_P_SEP_BY_SPACE, _NL_MONETARY_DUO_N_CS_PRECEDES, _NL_MONETARY_DUO_N_SEP_BY_SPACE, _NL_MONETARY_DUO_INT_P_CS_PRECEDES, _NL_MONETARY_DUO_INT_P_SEP_BY_SPACE, _NL_MONETARY_DUO_INT_N_CS_PRECEDES, _NL_MONETARY_DUO_INT_N_SEP_BY_SPACE, _NL_MONETARY_DUO_P_SIGN_POSN, _NL_MONETARY_DUO_N_SIGN_POSN, _NL_MONETARY_DUO_INT_P_SIGN_POSN, _NL_MONETARY_DUO_INT_N_SIGN_POSN, _NL_MONETARY_UNO_VALID_FROM, _NL_MONETARY_UNO_VALID_TO, _NL_MONETARY_DUO_VALID_FROM, _NL_MONETARY_DUO_VALID_TO, _NL_MONETARY_CONVERSION_RATE, _NL_MONETARY_DECIMAL_POINT_WC, _NL_MONETARY_THOUSANDS_SEP_WC, _NL_MONETARY_CODESET, _NL_NUM_LC_MONETARY, / LC_NUMERIC category: formatting of numbers. These also correspond to members of `struct lconv'; see <locale.h>. / __DECIMAL_POINT = _NL_ITEM (__LC_NUMERIC, 0), #ifdef __USE_GNU # define DECIMAL_POINT __DECIMAL_POINT #endif RADIXCHAR = __DECIMAL_POINT, #define RADIXCHAR RADIXCHAR __THOUSANDS_SEP, #ifdef __USE_GNU # define THOUSANDS_SEP __THOUSANDS_SEP #endif THOUSEP = __THOUSANDS_SEP, #define THOUSEP THOUSEP __GROUPING, #ifdef __USE_GNU # define GROUPING __GROUPING #endif _NL_NUMERIC_DECIMAL_POINT_WC, _NL_NUMERIC_THOUSANDS_SEP_WC, _NL_NUMERIC_CODESET, _NL_NUM_LC_NUMERIC, __YESEXPR = _NL_ITEM (__LC_MESSAGES, 0), / Regex matching ``yes'' input. / #define YESEXPR __YESEXPR __NOEXPR, / Regex matching ``no'' input. / #define NOEXPR __NOEXPR __YESSTR, / Output string for ``yes''. / #if defined __USE_GNU \|\| (defined __USE_XOPEN && !defined __USE_XOPEN2K) # define YESSTR __YESSTR #endif __NOSTR, / Output string for ``no''. / #if defined __USE_GNU \|\| (defined __USE_XOPEN && !defined __USE_XOPEN2K) # define NOSTR __NOSTR #endif _NL_MESSAGES_CODESET, _NL_NUM_LC_MESSAGES, _NL_PAPER_HEIGHT = _NL_ITEM (__LC_PAPER, 0), _NL_PAPER_WIDTH, _NL_PAPER_CODESET, _NL_NUM_LC_PAPER, _NL_NAME_NAME_FMT = _NL_ITEM (__LC_NAME, 0), _NL_NAME_NAME_GEN, _NL_NAME_NAME_MR, _NL_NAME_NAME_MRS, _NL_NAME_NAME_MISS, _NL_NAME_NAME_MS, _NL_NAME_CODESET, _NL_NUM_LC_NAME, _NL_ADDRESS_POSTAL_FMT = _NL_ITEM (__LC_ADDRESS, 0), _NL_ADDRESS_COUNTRY_NAME, _NL_ADDRESS_COUNTRY_POST, _NL_ADDRESS_COUNTRY_AB2, _NL_ADDRESS_COUNTRY_AB3, _NL_ADDRESS_COUNTRY_CAR, _NL_ADDRESS_COUNTRY_NUM, _NL_ADDRESS_COUNTRY_ISBN, _NL_ADDRESS_LANG_NAME, _NL_ADDRESS_LANG_AB, _NL_ADDRESS_LANG_TERM, _NL_ADDRESS_LANG_LIB, _NL_ADDRESS_CODESET, _NL_NUM_LC_ADDRESS, _NL_TELEPHONE_TEL_INT_FMT = _NL_ITEM (__LC_TELEPHONE, 0), _NL_TELEPHONE_TEL_DOM_FMT, _NL_TELEPHONE_INT_SELECT, _NL_TELEPHONE_INT_PREFIX, _NL_TELEPHONE_CODESET, _NL_NUM_LC_TELEPHONE, _NL_MEASUREMENT_MEASUREMENT = _NL_ITEM (__LC_MEASUREMENT, 0), _NL_MEASUREMENT_CODESET, _NL_NUM_LC_MEASUREMENT, _NL_IDENTIFICATION_TITLE = _NL_ITEM (__LC_IDENTIFICATION, 0), _NL_IDENTIFICATION_SOURCE, _NL_IDENTIFICATION_ADDRESS, _NL_IDENTIFICATION_CONTACT, _NL_IDENTIFICATION_EMAIL, _NL_IDENTIFICATION_TEL, _NL_IDENTIFICATION_FAX, _NL_IDENTIFICATION_LANGUAGE, _NL_IDENTIFICATION_TERRITORY, _NL_IDENTIFICATION_AUDIENCE, _NL_IDENTIFICATION_APPLICATION, _NL_IDENTIFICATION_ABBREVIATION, _NL_IDENTIFICATION_REVISION, _NL_IDENTIFICATION_DATE, _NL_IDENTIFICATION_CATEGORY, _NL_IDENTIFICATION_CODESET, _NL_NUM_LC_IDENTIFICATION, / This marks the highest value used. / _NL_NUM }; / This macro produces an item you can pass to `nl_langinfo' or `nl_langinfo_l' to get the name of the locale in use for CATEGORY. / #define _NL_LOCALE_NAME(category) _NL_ITEM ((category), \ _NL_ITEM_INDEX (-1)) #ifdef __USE_GNU # define NL_LOCALE_NAME(category) _NL_LOCALE_NAME (category) #endif / Return the current locale's value for ITEM. If ITEM is invalid, an empty string is returned. The string returned will not change until `setlocale' is called; it is usually in read-only memory and cannot be modified. / extern char nl_langinfo (nl_item __item) __THROW; #ifdef __USE_XOPEN2K8 /* POSIX.1-2008 extended locale interface (see locale.h). / # include <bits/types/locale_t.h> / Just like nl_langinfo but get the information from the locale object L. / extern char nl_langinfo_l (nl_item __item, locale_t __l); #endif __END_DECLS #endif /* langinfo.h */	17.43 KB	2026-02-17 11:01
📄 lastlog.h /* This header file is used in 4.3BSD to define `struct lastlog', which we define in <bits/utmp.h>. */ #include <utmp.h>	126 B	2026-02-17 11:02
📄 lauxlib.h /* $Id: lauxlib.h $ Auxiliary functions for building Lua libraries ** See Copyright Notice in lua.h / #ifndef lauxlib_h #define lauxlib_h #include <stddef.h> #include <stdio.h> #include "luaconf.h" #include "lua.h" / global table / #define LUA_GNAME "_G" typedef struct luaL_Buffer luaL_Buffer; / extra error code for 'luaL_loadfilex' / #define LUA_ERRFILE (LUA_ERRERR+1) / key, in the registry, for table of loaded modules / #define LUA_LOADED_TABLE "_LOADED" / key, in the registry, for table of preloaded loaders / #define LUA_PRELOAD_TABLE "_PRELOAD" typedef struct luaL_Reg { const char name; lua_CFunction func; } luaL_Reg; #define LUAL_NUMSIZES (sizeof(lua_Integer)16 + sizeof(lua_Number)) LUALIB_API void (luaL_checkversion_) (lua_State L, lua_Number ver, size_t sz); #define luaL_checkversion(L) \ luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES) LUALIB_API int (luaL_getmetafield) (lua_State L, int obj, const char e); LUALIB_API int (luaL_callmeta) (lua_State L, int obj, const char e); LUALIB_API const char (luaL_tolstring) (lua_State L, int idx, size_t len); LUALIB_API int (luaL_argerror) (lua_State L, int arg, const char extramsg); LUALIB_API int (luaL_typeerror) (lua_State L, int arg, const char tname); LUALIB_API const char (luaL_checklstring) (lua_State L, int arg, size_t l); LUALIB_API const char (luaL_optlstring) (lua_State L, int arg, const char def, size_t l); LUALIB_API lua_Number (luaL_checknumber) (lua_State L, int arg); LUALIB_API lua_Number (luaL_optnumber) (lua_State L, int arg, lua_Number def); LUALIB_API lua_Integer (luaL_checkinteger) (lua_State L, int arg); LUALIB_API lua_Integer (luaL_optinteger) (lua_State L, int arg, lua_Integer def); LUALIB_API void (luaL_checkstack) (lua_State L, int sz, const char msg); LUALIB_API void (luaL_checktype) (lua_State L, int arg, int t); LUALIB_API void (luaL_checkany) (lua_State L, int arg); LUALIB_API int (luaL_newmetatable) (lua_State L, const char tname); LUALIB_API void (luaL_setmetatable) (lua_State L, const char tname); LUALIB_API void (luaL_testudata) (lua_State L, int ud, const char tname); LUALIB_API void (luaL_checkudata) (lua_State L, int ud, const char tname); LUALIB_API void (luaL_where) (lua_State L, int lvl); LUALIB_API int (luaL_error) (lua_State L, const char fmt, ...); LUALIB_API int (luaL_checkoption) (lua_State L, int arg, const char def, const char const lst[]); LUALIB_API int (luaL_fileresult) (lua_State L, int stat, const char fname); LUALIB_API int (luaL_execresult) (lua_State L, int stat); / predefined references / #define LUA_NOREF (-2) #define LUA_REFNIL (-1) LUALIB_API int (luaL_ref) (lua_State L, int t); LUALIB_API void (luaL_unref) (lua_State L, int t, int ref); LUALIB_API int (luaL_loadfilex) (lua_State L, const char filename, const char mode); #define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL) LUALIB_API int (luaL_loadbufferx) (lua_State L, const char buff, size_t sz, const char name, const char mode); LUALIB_API int (luaL_loadstring) (lua_State L, const char s); LUALIB_API lua_State (luaL_newstate) (void); LUALIB_API lua_Integer (luaL_len) (lua_State L, int idx); LUALIB_API void (luaL_addgsub) (luaL_Buffer b, const char s, const char p, const char r); LUALIB_API const char (luaL_gsub) (lua_State L, const char s, const char p, const char r); LUALIB_API void (luaL_setfuncs) (lua_State L, const luaL_Reg l, int nup); LUALIB_API int (luaL_getsubtable) (lua_State L, int idx, const char fname); LUALIB_API void (luaL_traceback) (lua_State L, lua_State L1, const char msg, int level); LUALIB_API void (luaL_requiref) (lua_State L, const char modname, lua_CFunction openf, int glb); /* =============================================================== some useful macros ** =============================================================== / #define luaL_newlibtable(L,l) \ lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1) #define luaL_newlib(L,l) \ (luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0)) #define luaL_argcheck(L, cond,arg,extramsg) \ ((void)(luai_likely(cond) \|\| luaL_argerror(L, (arg), (extramsg)))) #define luaL_argexpected(L,cond,arg,tname) \ ((void)(luai_likely(cond) \|\| luaL_typeerror(L, (arg), (tname)))) #define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL)) #define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL)) #define luaL_typename(L,i) lua_typename(L, lua_type(L,(i))) #define luaL_dofile(L, fn) \ (luaL_loadfile(L, fn) \|\| lua_pcall(L, 0, LUA_MULTRET, 0)) #define luaL_dostring(L, s) \ (luaL_loadstring(L, s) \|\| lua_pcall(L, 0, LUA_MULTRET, 0)) #define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n))) #define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n))) #define luaL_loadbuffer(L,s,sz,n) luaL_loadbufferx(L,s,sz,n,NULL) / Perform arithmetic operations on lua_Integer values with wrap-around semantics, as the Lua core does. / #define luaL_intop(op,v1,v2) \ ((lua_Integer)((lua_Unsigned)(v1) op (lua_Unsigned)(v2))) / push the value used to represent failure/error / #define luaL_pushfail(L) lua_pushnil(L) / ** Internal assertions for in-house debugging / #if !defined(lua_assert) #if defined LUAI_ASSERT #include <assert.h> #define lua_assert(c) assert(c) #else #define lua_assert(c) ((void)0) #endif #endif / {====================================================== Generic Buffer manipulation ** ======================================================= / struct luaL_Buffer { char b; /* buffer address / size_t size; / buffer size / size_t n; / number of characters in buffer / lua_State L; union { LUAI_MAXALIGN; /* ensure maximum alignment for buffer / char b[LUAL_BUFFERSIZE]; / initial buffer / } init; }; #define luaL_bufflen(bf) ((bf)->n) #define luaL_buffaddr(bf) ((bf)->b) #define luaL_addchar(B,c) \ ((void)((B)->n < (B)->size \|\| luaL_prepbuffsize((B), 1)), \ ((B)->b[(B)->n++] = (c))) #define luaL_addsize(B,s) ((B)->n += (s)) #define luaL_buffsub(B,s) ((B)->n -= (s)) LUALIB_API void (luaL_buffinit) (lua_State L, luaL_Buffer B); LUALIB_API char (luaL_prepbuffsize) (luaL_Buffer B, size_t sz); LUALIB_API void (luaL_addlstring) (luaL_Buffer B, const char s, size_t l); LUALIB_API void (luaL_addstring) (luaL_Buffer B, const char s); LUALIB_API void (luaL_addvalue) (luaL_Buffer B); LUALIB_API void (luaL_pushresult) (luaL_Buffer B); LUALIB_API void (luaL_pushresultsize) (luaL_Buffer B, size_t sz); LUALIB_API char (luaL_buffinitsize) (lua_State L, luaL_Buffer B, size_t sz); #define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE) / }====================================================== / / {====================================================== File handles for IO library ** ======================================================= / / A file handle is a userdata with metatable 'LUA_FILEHANDLE' and initial structure 'luaL_Stream' (it may contain other fields ** after that initial structure). / #define LUA_FILEHANDLE "FILE" typedef struct luaL_Stream { FILE f; / stream (NULL for incompletely created streams) / lua_CFunction closef; / to close stream (NULL for closed streams) / } luaL_Stream; / }====================================================== / / {================================================================== "Abstraction Layer" for basic report of messages and errors ** =================================================================== / / print a string / #if !defined(lua_writestring) #define lua_writestring(s,l) fwrite((s), sizeof(char), (l), stdout) #endif / print a newline and flush the output / #if !defined(lua_writeline) #define lua_writeline() (lua_writestring("\n", 1), fflush(stdout)) #endif / print an error message / #if !defined(lua_writestringerror) #define lua_writestringerror(s,p) \ (fprintf(stderr, (s), (p)), fflush(stderr)) #endif / }================================================================== / / {============================================================ Compatibility with deprecated conversions ** ============================================================= / #if defined(LUA_COMPAT_APIINTCASTS) #define luaL_checkunsigned(L,a) ((lua_Unsigned)luaL_checkinteger(L,a)) #define luaL_optunsigned(L,a,d) \ ((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d))) #define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n))) #define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d))) #define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n))) #define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d))) #endif / }============================================================ */ #endif	9.1 KB	2023-09-26 18:28
📄 lber.h /* $OpenLDAP$ / / This work is part of OpenLDAP Software <http://www.openldap.org/>. * * Copyright 1998-2024 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted only as authorized by the OpenLDAP * Public License. * * A copy of this license is available in file LICENSE in the * top-level directory of the distribution or, alternatively, at * <http://www.OpenLDAP.org/license.html>. / / Portions Copyright (c) 1990 Regents of the University of Michigan. * All rights reserved. * * Redistribution and use in source and binary forms are permitted * provided that this notice is preserved and that due credit is given * to the University of Michigan at Ann Arbor. The name of the University * may not be used to endorse or promote products derived from this * software without specific prior written permission. This software * is provided ``as is'' without express or implied warranty. / #ifndef _LBER_H #define _LBER_H #include <lber_types.h> #include <string.h> LDAP_BEGIN_DECL / * ber_tag_t represents the identifier octets at the beginning of BER * elements. OpenLDAP treats them as mere big-endian unsigned integers. * * Actually the BER identifier octets look like this: * * Bits of 1st octet: * ______ * 8 7 \| CLASS * 0 0 = UNIVERSAL * 0 1 = APPLICATION * 1 0 = CONTEXT-SPECIFIC * 1 1 = PRIVATE * _____ * \| 6 \| DATA-TYPE * 0 = PRIMITIVE * 1 = CONSTRUCTED * ___________ * \| 5 ... 1 \| TAG-NUMBER * * For ASN.1 tag numbers >= 0x1F, TAG-NUMBER above is 0x1F and the next * BER octets contain the actual ASN.1 tag number: Big-endian, base * 128, 8.bit = 1 in all but the last octet, minimum number of octets. / / BER classes and mask (in 1st identifier octet) / #define LBER_CLASS_UNIVERSAL ((ber_tag_t) 0x00U) #define LBER_CLASS_APPLICATION ((ber_tag_t) 0x40U) #define LBER_CLASS_CONTEXT ((ber_tag_t) 0x80U) #define LBER_CLASS_PRIVATE ((ber_tag_t) 0xc0U) #define LBER_CLASS_MASK ((ber_tag_t) 0xc0U) / BER encoding type and mask (in 1st identifier octet) / #define LBER_PRIMITIVE ((ber_tag_t) 0x00U) #define LBER_CONSTRUCTED ((ber_tag_t) 0x20U) #define LBER_ENCODING_MASK ((ber_tag_t) 0x20U) #define LBER_BIG_TAG_MASK ((ber_tag_t) 0x1fU) #define LBER_MORE_TAG_MASK ((ber_tag_t) 0x80U) / * LBER_ERROR and LBER_DEFAULT are values that can never appear * as valid BER tags, so it is safe to use them to report errors. * Valid tags have (tag & (ber_tag_t) 0xFF) != 0xFF. / #define LBER_ERROR ((ber_tag_t) -1) #define LBER_DEFAULT ((ber_tag_t) -1) / general BER types we know about / #define LBER_BOOLEAN ((ber_tag_t) 0x01UL) #define LBER_INTEGER ((ber_tag_t) 0x02UL) #define LBER_BITSTRING ((ber_tag_t) 0x03UL) #define LBER_OCTETSTRING ((ber_tag_t) 0x04UL) #define LBER_NULL ((ber_tag_t) 0x05UL) #define LBER_ENUMERATED ((ber_tag_t) 0x0aUL) #define LBER_SEQUENCE ((ber_tag_t) 0x30UL) / constructed / #define LBER_SET ((ber_tag_t) 0x31UL) / constructed / / LBER BerElement options / #define LBER_USE_DER 0x01 / get/set options for BerElement / #define LBER_OPT_BER_OPTIONS 0x01 #define LBER_OPT_BER_DEBUG 0x02 #define LBER_OPT_BER_REMAINING_BYTES 0x03 #define LBER_OPT_BER_TOTAL_BYTES 0x04 #define LBER_OPT_BER_BYTES_TO_WRITE 0x05 #define LBER_OPT_BER_MEMCTX 0x06 #define LBER_OPT_DEBUG_LEVEL LBER_OPT_BER_DEBUG #define LBER_OPT_REMAINING_BYTES LBER_OPT_BER_REMAINING_BYTES #define LBER_OPT_TOTAL_BYTES LBER_OPT_BER_TOTAL_BYTES #define LBER_OPT_BYTES_TO_WRITE LBER_OPT_BER_BYTES_TO_WRITE #define LBER_OPT_LOG_PRINT_FN 0x8001 #define LBER_OPT_MEMORY_FNS 0x8002 #define LBER_OPT_ERROR_FN 0x8003 #define LBER_OPT_LOG_PRINT_FILE 0x8004 / get/set Memory Debug options / #define LBER_OPT_MEMORY_INUSE 0x8005 / for memory debugging / #define LBER_OPT_LOG_PROC 0x8006 / for external logging function / typedef int (BER_ERRNO_FN) LDAP_P(( void )); typedef void (BER_LOG_PRINT_FN) LDAP_P(( LDAP_CONST char buf )); typedef void (BER_MEMALLOC_FN) LDAP_P(( ber_len_t size, void ctx )); typedef void (BER_MEMCALLOC_FN) LDAP_P(( ber_len_t n, ber_len_t size, void ctx )); typedef void (BER_MEMREALLOC_FN) LDAP_P(( void p, ber_len_t size, void ctx )); typedef void (BER_MEMFREE_FN) LDAP_P(( void p, void ctx )); typedef struct lber_memory_fns { BER_MEMALLOC_FN bmf_malloc; BER_MEMCALLOC_FN bmf_calloc; BER_MEMREALLOC_FN bmf_realloc; BER_MEMFREE_FN bmf_free; } BerMemoryFunctions; /* LBER Sockbuf_IO options / #define LBER_SB_OPT_GET_FD 1 #define LBER_SB_OPT_SET_FD 2 #define LBER_SB_OPT_HAS_IO 3 #define LBER_SB_OPT_SET_NONBLOCK 4 #define LBER_SB_OPT_GET_SSL 7 #define LBER_SB_OPT_DATA_READY 8 #define LBER_SB_OPT_SET_READAHEAD 9 #define LBER_SB_OPT_DRAIN 10 #define LBER_SB_OPT_NEEDS_READ 11 #define LBER_SB_OPT_NEEDS_WRITE 12 #define LBER_SB_OPT_GET_MAX_INCOMING 13 #define LBER_SB_OPT_SET_MAX_INCOMING 14 / Only meaningful ifdef LDAP_PF_LOCAL_SENDMSG / #define LBER_SB_OPT_UNGET_BUF 15 / Largest option used by the library / #define LBER_SB_OPT_OPT_MAX 15 / LBER IO operations stacking levels / #define LBER_SBIOD_LEVEL_PROVIDER 10 #define LBER_SBIOD_LEVEL_TRANSPORT 20 #define LBER_SBIOD_LEVEL_APPLICATION 30 / get/set options for Sockbuf / #define LBER_OPT_SOCKBUF_DESC 0x1000 #define LBER_OPT_SOCKBUF_OPTIONS 0x1001 #define LBER_OPT_SOCKBUF_DEBUG 0x1002 / on/off values / LBER_V( char ) ber_pvt_opt_on; #define LBER_OPT_ON ((void ) &ber_pvt_opt_on) #define LBER_OPT_OFF ((void ) 0) #define LBER_OPT_SUCCESS (0) #define LBER_OPT_ERROR (-1) typedef struct berelement BerElement; typedef struct sockbuf Sockbuf; typedef struct sockbuf_io Sockbuf_IO; / Structure for LBER IO operation descriptor / typedef struct sockbuf_io_desc { int sbiod_level; Sockbuf sbiod_sb; Sockbuf_IO sbiod_io; void sbiod_pvt; struct sockbuf_io_desc sbiod_next; } Sockbuf_IO_Desc; / Structure for LBER IO operation functions / struct sockbuf_io { int (sbi_setup)( Sockbuf_IO_Desc sbiod, void arg ); int (sbi_remove)( Sockbuf_IO_Desc sbiod ); int (sbi_ctrl)( Sockbuf_IO_Desc sbiod, int opt, void arg); ber_slen_t (sbi_read)( Sockbuf_IO_Desc sbiod, void buf, ber_len_t len ); ber_slen_t (sbi_write)( Sockbuf_IO_Desc sbiod, void buf, ber_len_t len ); int (sbi_close)( Sockbuf_IO_Desc sbiod ); }; / Helper macros for LBER IO functions / #define LBER_SBIOD_READ_NEXT( sbiod, buf, len ) \ ( (sbiod)->sbiod_next->sbiod_io->sbi_read( (sbiod)->sbiod_next, \ buf, len ) ) #define LBER_SBIOD_WRITE_NEXT( sbiod, buf, len ) \ ( (sbiod)->sbiod_next->sbiod_io->sbi_write( (sbiod)->sbiod_next, \ buf, len ) ) #define LBER_SBIOD_CTRL_NEXT( sbiod, opt, arg ) \ ( (sbiod)->sbiod_next ? \ ( (sbiod)->sbiod_next->sbiod_io->sbi_ctrl( \ (sbiod)->sbiod_next, opt, arg ) ) : 0 ) / structure for returning a sequence of octet strings + length / typedef struct berval { ber_len_t bv_len; char bv_val; } BerValue; typedef BerValue BerVarray; / To distinguish from a single bv / / this should be moved to lber-int.h / / * in bprint.c: / LBER_F( void ) ber_error_print LDAP_P(( LDAP_CONST char data )); LBER_F( void ) ber_bprint LDAP_P(( LDAP_CONST char data, ber_len_t len )); LBER_F( void ) ber_dump LDAP_P(( BerElement ber, int inout )); /* * in decode.c: / typedef int (BERDecodeCallback) LDAP_P(( BerElement ber, void data, int mode )); LBER_F( ber_tag_t ) ber_get_tag LDAP_P(( BerElement ber )); LBER_F( ber_tag_t ) ber_skip_tag LDAP_P(( BerElement ber, ber_len_t len )); LBER_F( ber_tag_t ) ber_peek_tag LDAP_P(( BerElement ber, ber_len_t len )); LBER_F( ber_tag_t ) ber_skip_raw LDAP_P(( BerElement ber, struct berval bv )); LBER_F( ber_tag_t ) ber_skip_element LDAP_P(( BerElement ber, struct berval bv )); LBER_F( ber_tag_t ) ber_peek_element LDAP_P(( LDAP_CONST BerElement ber, struct berval bv )); LBER_F( ber_tag_t ) ber_get_int LDAP_P(( BerElement ber, ber_int_t num )); LBER_F( ber_tag_t ) ber_get_enum LDAP_P(( BerElement ber, ber_int_t num )); LBER_F( int ) ber_decode_int LDAP_P(( const struct berval bv, ber_int_t num )); LBER_F( ber_tag_t ) ber_get_stringb LDAP_P(( BerElement ber, char buf, ber_len_t len )); #define LBER_BV_ALLOC 0x01 /* allocate/copy result, otherwise in-place / #define LBER_BV_NOTERM 0x02 / omit NUL-terminator if parsing in-place / #define LBER_BV_STRING 0x04 / fail if berval contains embedded \0 / / LBER_BV_STRING currently accepts a terminating \0 in the berval, because * Active Directory sends that in at least the diagonsticMessage field. / LBER_F( ber_tag_t ) ber_get_stringbv LDAP_P(( BerElement ber, struct berval bv, int options )); LBER_F( ber_tag_t ) ber_get_stringa LDAP_P(( BerElement ber, char *buf )); LBER_F( ber_tag_t ) ber_get_stringal LDAP_P(( BerElement ber, struct berval *bv )); LBER_F( ber_tag_t ) ber_get_bitstringa LDAP_P(( BerElement ber, char *buf, ber_len_t len )); LBER_F( ber_tag_t ) ber_get_null LDAP_P(( BerElement ber )); LBER_F( ber_tag_t ) ber_get_boolean LDAP_P(( BerElement ber, ber_int_t boolval )); LBER_F( ber_tag_t ) ber_first_element LDAP_P(( BerElement ber, ber_len_t len, char last )); LBER_F( ber_tag_t ) ber_next_element LDAP_P(( BerElement ber, ber_len_t len, LDAP_CONST char last )); LBER_F( ber_tag_t ) ber_scanf LDAP_P(( BerElement ber, LDAP_CONST char fmt, ... )); LBER_F( int ) ber_decode_oid LDAP_P(( struct berval in, struct berval out )); /* * in encode.c / LBER_F( int ) ber_encode_oid LDAP_P(( struct berval in, struct berval out )); typedef int (BEREncodeCallback) LDAP_P(( BerElement ber, void data )); LBER_F( int ) ber_put_enum LDAP_P(( BerElement ber, ber_int_t num, ber_tag_t tag )); LBER_F( int ) ber_put_int LDAP_P(( BerElement ber, ber_int_t num, ber_tag_t tag )); LBER_F( int ) ber_put_ostring LDAP_P(( BerElement ber, LDAP_CONST char str, ber_len_t len, ber_tag_t tag )); LBER_F( int ) ber_put_berval LDAP_P(( BerElement ber, struct berval bv, ber_tag_t tag )); LBER_F( int ) ber_put_string LDAP_P(( BerElement ber, LDAP_CONST char str, ber_tag_t tag )); LBER_F( int ) ber_put_bitstring LDAP_P(( BerElement ber, LDAP_CONST char str, ber_len_t bitlen, ber_tag_t tag )); LBER_F( int ) ber_put_null LDAP_P(( BerElement ber, ber_tag_t tag )); LBER_F( int ) ber_put_boolean LDAP_P(( BerElement ber, ber_int_t boolval, ber_tag_t tag )); LBER_F( int ) ber_start_seq LDAP_P(( BerElement ber, ber_tag_t tag )); LBER_F( int ) ber_start_set LDAP_P(( BerElement ber, ber_tag_t tag )); LBER_F( int ) ber_put_seq LDAP_P(( BerElement ber )); LBER_F( int ) ber_put_set LDAP_P(( BerElement ber )); LBER_F( int ) ber_printf LDAP_P(( BerElement ber, LDAP_CONST char fmt, ... )); /* * in io.c: / LBER_F( ber_slen_t ) ber_skip_data LDAP_P(( BerElement ber, ber_len_t len )); LBER_F( ber_slen_t ) ber_read LDAP_P(( BerElement ber, char buf, ber_len_t len )); LBER_F( ber_slen_t ) ber_write LDAP_P(( BerElement ber, LDAP_CONST char buf, ber_len_t len, int zero )); /* nonzero is unsupported from OpenLDAP 2.4.18 / LBER_F( void ) ber_free LDAP_P(( BerElement ber, int freebuf )); LBER_F( void ) ber_free_buf LDAP_P(( BerElement ber )); LBER_F( int ) ber_flush2 LDAP_P(( Sockbuf sb, BerElement ber, int freeit )); #define LBER_FLUSH_FREE_NEVER (0x0) / traditional behavior / #define LBER_FLUSH_FREE_ON_SUCCESS (0x1) / traditional behavior / #define LBER_FLUSH_FREE_ON_ERROR (0x2) #define LBER_FLUSH_FREE_ALWAYS (LBER_FLUSH_FREE_ON_SUCCESS\|LBER_FLUSH_FREE_ON_ERROR) LBER_F( int ) ber_flush LDAP_P(( Sockbuf sb, BerElement ber, int freeit )); / DEPRECATED / LBER_F( BerElement ) ber_alloc LDAP_P(( void )); /* DEPRECATED / LBER_F( BerElement ) der_alloc LDAP_P(( void )); /* DEPRECATED / LBER_F( BerElement ) ber_alloc_t LDAP_P(( int beroptions )); LBER_F( BerElement * ) ber_dup LDAP_P(( BerElement ber )); LBER_F( ber_tag_t ) ber_get_next LDAP_P(( Sockbuf sb, ber_len_t len, BerElement ber )); LBER_F( void ) ber_init2 LDAP_P(( BerElement ber, struct berval bv, int options )); LBER_F( void ) ber_init_w_nullc LDAP_P(( /* DEPRECATED / BerElement ber, int options )); LBER_F( void ) ber_reset LDAP_P(( BerElement ber, int was_writing )); LBER_F( BerElement ) ber_init LDAP_P(( struct berval bv )); LBER_F( int ) ber_flatten LDAP_P(( BerElement ber, struct berval *bvPtr )); LBER_F( int ) ber_flatten2 LDAP_P(( BerElement ber, struct berval bv, int alloc )); LBER_F( int ) ber_remaining LDAP_P(( BerElement ber )); /* * LBER ber accessor functions / LBER_F( int ) ber_get_option LDAP_P(( void item, int option, void outvalue)); LBER_F( int ) ber_set_option LDAP_P(( void item, int option, LDAP_CONST void invalue)); / * LBER sockbuf.c / LBER_F( Sockbuf ) ber_sockbuf_alloc LDAP_P(( void )); LBER_F( void ) ber_sockbuf_free LDAP_P(( Sockbuf sb )); LBER_F( int ) ber_sockbuf_add_io LDAP_P(( Sockbuf sb, Sockbuf_IO sbio, int layer, void arg )); LBER_F( int ) ber_sockbuf_remove_io LDAP_P(( Sockbuf sb, Sockbuf_IO sbio, int layer )); LBER_F( int ) ber_sockbuf_ctrl LDAP_P(( Sockbuf sb, int opt, void arg )); LBER_V( Sockbuf_IO ) ber_sockbuf_io_tcp; LBER_V( Sockbuf_IO ) ber_sockbuf_io_readahead; LBER_V( Sockbuf_IO ) ber_sockbuf_io_fd; LBER_V( Sockbuf_IO ) ber_sockbuf_io_debug; LBER_V( Sockbuf_IO ) ber_sockbuf_io_udp; /* * LBER memory.c / LBER_F( void ) ber_memalloc LDAP_P(( ber_len_t s )); LBER_F( void * ) ber_memrealloc LDAP_P(( void* p, ber_len_t s )); LBER_F( void * ) ber_memcalloc LDAP_P(( ber_len_t n, ber_len_t s )); LBER_F( void ) ber_memfree LDAP_P(( void* p )); LBER_F( void ) ber_memvfree LDAP_P(( void** vector )); LBER_F( void ) ber_bvfree LDAP_P(( struct berval bv )); LBER_F( void ) ber_bvecfree LDAP_P(( struct berval bv )); LBER_F( int ) ber_bvecadd LDAP_P(( struct berval *bvec, struct berval bv )); LBER_F( struct berval * ) ber_dupbv LDAP_P(( struct berval dst, struct berval src )); LBER_F( struct berval * ) ber_bvdup LDAP_P(( struct berval src )); LBER_F( struct berval ) ber_mem2bv LDAP_P(( LDAP_CONST char , ber_len_t len, int duplicate, struct berval bv)); LBER_F( struct berval * ) ber_str2bv LDAP_P(( LDAP_CONST char , ber_len_t len, int duplicate, struct berval bv)); #define ber_bvstr(a) ((ber_str2bv)((a), 0, 0, NULL)) #define ber_bvstrdup(a) ((ber_str2bv)((a), 0, 1, NULL)) LBER_F( char * ) ber_strdup LDAP_P(( LDAP_CONST char * )); LBER_F( ber_len_t ) ber_strnlen LDAP_P(( LDAP_CONST char s, ber_len_t len )); LBER_F( char ) ber_strndup LDAP_P(( LDAP_CONST char s, ber_len_t l )); LBER_F( struct berval ) ber_bvreplace LDAP_P(( struct berval dst, LDAP_CONST struct berval src )); LBER_F( void ) ber_bvarray_free LDAP_P(( BerVarray p )); LBER_F( int ) ber_bvarray_add LDAP_P(( BerVarray p, BerValue bv )); #define ber_bvcmp(v1,v2) \ ((v1)->bv_len < (v2)->bv_len \ ? -1 : ((v1)->bv_len > (v2)->bv_len \ ? 1 : memcmp((v1)->bv_val, (v2)->bv_val, (v1)->bv_len) )) /* * error.c / LBER_F( int ) ber_errno_addr LDAP_P((void)); #define ber_errno ((ber_errno_addr)()) #define LBER_ERROR_NONE 0 #define LBER_ERROR_PARAM 0x1 #define LBER_ERROR_MEMORY 0x2 LDAP_END_DECL #endif / _LBER_H */	15.12 KB	2024-05-21 17:19
📄 lber_types.h /* include/lber_types.h. Generated from lber_types.hin by configure. / / $OpenLDAP$ / / This work is part of OpenLDAP Software <http://www.openldap.org/>. * * Copyright 1998-2024 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted only as authorized by the OpenLDAP * Public License. * * A copy of this license is available in file LICENSE in the * top-level directory of the distribution or, alternatively, at * <http://www.OpenLDAP.org/license.html>. / / * LBER types / #ifndef _LBER_TYPES_H #define _LBER_TYPES_H #include <ldap_cdefs.h> LDAP_BEGIN_DECL / LBER boolean, enum, integers (32 bits or larger) / #define LBER_INT_T int / LBER tags (32 bits or larger) / #define LBER_TAG_T long / LBER socket descriptor / #define LBER_SOCKET_T int / LBER lengths (32 bits or larger) / #define LBER_LEN_T long / ------------------------------------------------------------ / / booleans, enumerations, and integers / typedef LBER_INT_T ber_int_t; / signed and unsigned versions / typedef signed LBER_INT_T ber_sint_t; typedef unsigned LBER_INT_T ber_uint_t; / tags / typedef unsigned LBER_TAG_T ber_tag_t; / "socket" descriptors / typedef LBER_SOCKET_T ber_socket_t; / lengths / typedef unsigned LBER_LEN_T ber_len_t; / signed lengths / typedef signed LBER_LEN_T ber_slen_t; LDAP_END_DECL #endif / _LBER_TYPES_H */	1.43 KB	2025-03-13 12:28
📄 ldap.h /* $OpenLDAP$ / / This work is part of OpenLDAP Software <http://www.openldap.org/>. * * Copyright 1998-2024 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted only as authorized by the OpenLDAP * Public License. * * A copy of this license is available in file LICENSE in the * top-level directory of the distribution or, alternatively, at * <http://www.OpenLDAP.org/license.html>. / / Portions Copyright (c) 1990 Regents of the University of Michigan. * All rights reserved. * * Redistribution and use in source and binary forms are permitted * provided that this notice is preserved and that due credit is given * to the University of Michigan at Ann Arbor. The name of the University * may not be used to endorse or promote products derived from this * software without specific prior written permission. This software * is provided ``as is'' without express or implied warranty. / #ifndef _LDAP_H #define _LDAP_H / pull in lber / #include <lber.h> / include version and API feature defines / #include <ldap_features.h> LDAP_BEGIN_DECL #define LDAP_VERSION1 1 #define LDAP_VERSION2 2 #define LDAP_VERSION3 3 #define LDAP_VERSION_MIN LDAP_VERSION2 #define LDAP_VERSION LDAP_VERSION2 #define LDAP_VERSION_MAX LDAP_VERSION3 / * We use 3000+n here because it is above 1823 (for RFC 1823), * above 2000+rev of IETF LDAPEXT draft (now quite dated), * yet below allocations for new RFCs (just in case there is * someday an RFC produced). / #define LDAP_API_VERSION 3001 #define LDAP_VENDOR_NAME "OpenLDAP" / OpenLDAP API Features / #define LDAP_API_FEATURE_X_OPENLDAP LDAP_VENDOR_VERSION #if defined( LDAP_API_FEATURE_X_OPENLDAP_REENTRANT ) # define LDAP_API_FEATURE_THREAD_SAFE 1 #endif #if defined( LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE ) # define LDAP_API_FEATURE_SESSION_THREAD_SAFE 1 # define LDAP_API_FEATURE_OPERATION_THREAD_SAFE 1 #endif #define LDAP_PORT 389 / ldap:/// default LDAP port / #define LDAPS_PORT 636 / ldaps:/// default LDAP over TLS port / #define LDAP_ROOT_DSE "" #define LDAP_NO_ATTRS "1.1" #define LDAP_ALL_USER_ATTRIBUTES "" #define LDAP_ALL_OPERATIONAL_ATTRIBUTES "+" /* RFC 3673 / / RFC 4511: maxInt INTEGER ::= 2147483647 -- (2^^31 - 1) -- / #define LDAP_MAXINT (2147483647) / * LDAP_OPTions * 0x0000 - 0x0fff reserved for api options * 0x1000 - 0x3fff reserved for api extended options * 0x4000 - 0x7fff reserved for private and experimental options / #define LDAP_OPT_API_INFO 0x0000 #define LDAP_OPT_DESC 0x0001 / historic / #define LDAP_OPT_DEREF 0x0002 #define LDAP_OPT_SIZELIMIT 0x0003 #define LDAP_OPT_TIMELIMIT 0x0004 / 0x05 - 0x07 not defined / #define LDAP_OPT_REFERRALS 0x0008 #define LDAP_OPT_RESTART 0x0009 / 0x0a - 0x10 not defined / #define LDAP_OPT_PROTOCOL_VERSION 0x0011 #define LDAP_OPT_SERVER_CONTROLS 0x0012 #define LDAP_OPT_CLIENT_CONTROLS 0x0013 / 0x14 not defined / #define LDAP_OPT_API_FEATURE_INFO 0x0015 / 0x16 - 0x2f not defined / #define LDAP_OPT_HOST_NAME 0x0030 #define LDAP_OPT_RESULT_CODE 0x0031 #define LDAP_OPT_ERROR_NUMBER LDAP_OPT_RESULT_CODE #define LDAP_OPT_DIAGNOSTIC_MESSAGE 0x0032 #define LDAP_OPT_ERROR_STRING LDAP_OPT_DIAGNOSTIC_MESSAGE #define LDAP_OPT_MATCHED_DN 0x0033 / 0x0034 - 0x3fff not defined / / 0x0091 used by Microsoft for LDAP_OPT_AUTO_RECONNECT / #define LDAP_OPT_SSPI_FLAGS 0x0092 / 0x0093 used by Microsoft for LDAP_OPT_SSL_INFO / / 0x0094 used by Microsoft for LDAP_OPT_REF_DEREF_CONN_PER_MSG / #define LDAP_OPT_SIGN 0x0095 #define LDAP_OPT_ENCRYPT 0x0096 #define LDAP_OPT_SASL_METHOD 0x0097 / 0x0098 used by Microsoft for LDAP_OPT_AREC_EXCLUSIVE / #define LDAP_OPT_SECURITY_CONTEXT 0x0099 / 0x009A used by Microsoft for LDAP_OPT_ROOTDSE_CACHE / / 0x009B - 0x3fff not defined / / API Extensions / #define LDAP_OPT_API_EXTENSION_BASE 0x4000 / API extensions / / private and experimental options / / OpenLDAP specific options / #define LDAP_OPT_DEBUG_LEVEL 0x5001 / debug level / #define LDAP_OPT_TIMEOUT 0x5002 / default timeout / #define LDAP_OPT_REFHOPLIMIT 0x5003 / ref hop limit / #define LDAP_OPT_NETWORK_TIMEOUT 0x5005 / socket level timeout / #define LDAP_OPT_URI 0x5006 #define LDAP_OPT_REFERRAL_URLS 0x5007 / Referral URLs / #define LDAP_OPT_SOCKBUF 0x5008 / sockbuf / #define LDAP_OPT_DEFBASE 0x5009 / searchbase / #define LDAP_OPT_CONNECT_ASYNC 0x5010 / create connections asynchronously / #define LDAP_OPT_CONNECT_CB 0x5011 / connection callbacks / #define LDAP_OPT_SESSION_REFCNT 0x5012 / session reference count / #define LDAP_OPT_KEEPCONN 0x5013 / keep the connection on read error or NoD / #define LDAP_OPT_SOCKET_BIND_ADDRESSES 0x5014 / user configured bind IPs / #define LDAP_OPT_TCP_USER_TIMEOUT 0x5015 / set TCP_USER_TIMEOUT if the OS supports it, ignored otherwise / / OpenLDAP TLS options / #define LDAP_OPT_X_TLS 0x6000 #define LDAP_OPT_X_TLS_CTX 0x6001 / OpenSSL CTX* / #define LDAP_OPT_X_TLS_CACERTFILE 0x6002 #define LDAP_OPT_X_TLS_CACERTDIR 0x6003 #define LDAP_OPT_X_TLS_CERTFILE 0x6004 #define LDAP_OPT_X_TLS_KEYFILE 0x6005 #define LDAP_OPT_X_TLS_REQUIRE_CERT 0x6006 #define LDAP_OPT_X_TLS_PROTOCOL_MIN 0x6007 #define LDAP_OPT_X_TLS_CIPHER_SUITE 0x6008 #define LDAP_OPT_X_TLS_RANDOM_FILE 0x6009 #define LDAP_OPT_X_TLS_SSL_CTX 0x600a / OpenSSL SSL* / #define LDAP_OPT_X_TLS_CRLCHECK 0x600b #define LDAP_OPT_X_TLS_CONNECT_CB 0x600c #define LDAP_OPT_X_TLS_CONNECT_ARG 0x600d #define LDAP_OPT_X_TLS_DHFILE 0x600e #define LDAP_OPT_X_TLS_NEWCTX 0x600f #define LDAP_OPT_X_TLS_CRLFILE 0x6010 / GNUtls only / #define LDAP_OPT_X_TLS_PACKAGE 0x6011 #define LDAP_OPT_X_TLS_ECNAME 0x6012 #define LDAP_OPT_X_TLS_VERSION 0x6013 / read-only / #define LDAP_OPT_X_TLS_CIPHER 0x6014 / read-only / #define LDAP_OPT_X_TLS_PEERCERT 0x6015 / read-only / #define LDAP_OPT_X_TLS_CACERT 0x6016 #define LDAP_OPT_X_TLS_CERT 0x6017 #define LDAP_OPT_X_TLS_KEY 0x6018 #define LDAP_OPT_X_TLS_PEERKEY_HASH 0x6019 #define LDAP_OPT_X_TLS_REQUIRE_SAN 0x601a #define LDAP_OPT_X_TLS_PROTOCOL_MAX 0x601b #define LDAP_OPT_X_TLS_NEVER 0 #define LDAP_OPT_X_TLS_HARD 1 #define LDAP_OPT_X_TLS_DEMAND 2 #define LDAP_OPT_X_TLS_ALLOW 3 #define LDAP_OPT_X_TLS_TRY 4 #define LDAP_OPT_X_TLS_CRL_NONE 0 #define LDAP_OPT_X_TLS_CRL_PEER 1 #define LDAP_OPT_X_TLS_CRL_ALL 2 / for LDAP_OPT_X_TLS_PROTOCOL_MIN/MAX / #define LDAP_OPT_X_TLS_PROTOCOL(maj,min) (((maj) << 8) + (min)) #define LDAP_OPT_X_TLS_PROTOCOL_SSL2 (2 << 8) #define LDAP_OPT_X_TLS_PROTOCOL_SSL3 (3 << 8) #define LDAP_OPT_X_TLS_PROTOCOL_TLS1_0 ((3 << 8) + 1) #define LDAP_OPT_X_TLS_PROTOCOL_TLS1_1 ((3 << 8) + 2) #define LDAP_OPT_X_TLS_PROTOCOL_TLS1_2 ((3 << 8) + 3) #define LDAP_OPT_X_TLS_PROTOCOL_TLS1_3 ((3 << 8) + 4) #define LDAP_OPT_X_SASL_CBINDING_NONE 0 #define LDAP_OPT_X_SASL_CBINDING_TLS_UNIQUE 1 #define LDAP_OPT_X_SASL_CBINDING_TLS_ENDPOINT 2 / OpenLDAP SASL options / #define LDAP_OPT_X_SASL_MECH 0x6100 #define LDAP_OPT_X_SASL_REALM 0x6101 #define LDAP_OPT_X_SASL_AUTHCID 0x6102 #define LDAP_OPT_X_SASL_AUTHZID 0x6103 #define LDAP_OPT_X_SASL_SSF 0x6104 / read-only / #define LDAP_OPT_X_SASL_SSF_EXTERNAL 0x6105 / write-only / #define LDAP_OPT_X_SASL_SECPROPS 0x6106 / write-only / #define LDAP_OPT_X_SASL_SSF_MIN 0x6107 #define LDAP_OPT_X_SASL_SSF_MAX 0x6108 #define LDAP_OPT_X_SASL_MAXBUFSIZE 0x6109 #define LDAP_OPT_X_SASL_MECHLIST 0x610a / read-only / #define LDAP_OPT_X_SASL_NOCANON 0x610b #define LDAP_OPT_X_SASL_USERNAME 0x610c / read-only / #define LDAP_OPT_X_SASL_GSS_CREDS 0x610d #define LDAP_OPT_X_SASL_CBINDING 0x610e / * OpenLDAP per connection tcp-keepalive settings * (Linux only, ignored where unsupported) / #define LDAP_OPT_X_KEEPALIVE_IDLE 0x6300 #define LDAP_OPT_X_KEEPALIVE_PROBES 0x6301 #define LDAP_OPT_X_KEEPALIVE_INTERVAL 0x6302 / Private API Extensions -- reserved for application use / #define LDAP_OPT_PRIVATE_EXTENSION_BASE 0x7000 / Private API inclusive / / * ldap_get_option() and ldap_set_option() return values. * As later versions may return other values indicating * failure, current applications should only compare returned * value against LDAP_OPT_SUCCESS. / #define LDAP_OPT_SUCCESS 0 #define LDAP_OPT_ERROR (-1) / option on/off values / #define LDAP_OPT_ON ((void ) &ber_pvt_opt_on) #define LDAP_OPT_OFF ((void ) 0) typedef struct ldapapiinfo { int ldapai_info_version; / version of LDAPAPIInfo / #define LDAP_API_INFO_VERSION (1) int ldapai_api_version; / revision of API supported / int ldapai_protocol_version; / highest LDAP version supported / char ldapai_extensions; / names of API extensions / char ldapai_vendor_name; /* name of supplier / int ldapai_vendor_version; / supplier-specific version * 100 / } LDAPAPIInfo; typedef struct ldap_apifeature_info { int ldapaif_info_version; / version of LDAPAPIFeatureInfo / #define LDAP_FEATURE_INFO_VERSION (1) / apifeature_info struct version / char ldapaif_name; /* LDAP_API_FEATURE_* (less prefix) / int ldapaif_version; / value of LDAP_API_FEATURE_... / } LDAPAPIFeatureInfo; / * LDAP Control structure / typedef struct ldapcontrol { char ldctl_oid; /* numericoid of control / struct berval ldctl_value; / encoded value of control / char ldctl_iscritical; / criticality / } LDAPControl; / LDAP Controls / / standard track controls / #define LDAP_CONTROL_MANAGEDSAIT "2.16.840.1.113730.3.4.2" / RFC 3296 / #define LDAP_CONTROL_PROXY_AUTHZ "2.16.840.1.113730.3.4.18" / RFC 4370 / #define LDAP_CONTROL_SUBENTRIES "1.3.6.1.4.1.4203.1.10.1" / RFC 3672 / #define LDAP_CONTROL_VALUESRETURNFILTER "1.2.826.0.1.3344810.2.3"/ RFC 3876 / #define LDAP_CONTROL_ASSERT "1.3.6.1.1.12" / RFC 4528 / #define LDAP_CONTROL_PRE_READ "1.3.6.1.1.13.1" / RFC 4527 / #define LDAP_CONTROL_POST_READ "1.3.6.1.1.13.2" / RFC 4527 / #define LDAP_CONTROL_SORTREQUEST "1.2.840.113556.1.4.473" / RFC 2891 / #define LDAP_CONTROL_SORTRESPONSE "1.2.840.113556.1.4.474" / RFC 2891 / / non-standard track controls / #define LDAP_CONTROL_PAGEDRESULTS "1.2.840.113556.1.4.319" / RFC 2696 / #define LDAP_CONTROL_AUTHZID_REQUEST "2.16.840.1.113730.3.4.16" / RFC 3829 / #define LDAP_CONTROL_AUTHZID_RESPONSE "2.16.840.1.113730.3.4.15" / RFC 3829 / / LDAP Content Synchronization Operation -- RFC 4533 / #define LDAP_SYNC_OID "1.3.6.1.4.1.4203.1.9.1" #define LDAP_CONTROL_SYNC LDAP_SYNC_OID ".1" #define LDAP_CONTROL_SYNC_STATE LDAP_SYNC_OID ".2" #define LDAP_CONTROL_SYNC_DONE LDAP_SYNC_OID ".3" #define LDAP_SYNC_INFO LDAP_SYNC_OID ".4" #define LDAP_SYNC_NONE 0x00 #define LDAP_SYNC_REFRESH_ONLY 0x01 #define LDAP_SYNC_RESERVED 0x02 #define LDAP_SYNC_REFRESH_AND_PERSIST 0x03 #define LDAP_SYNC_REFRESH_PRESENTS 0 #define LDAP_SYNC_REFRESH_DELETES 1 #define LDAP_TAG_SYNC_NEW_COOKIE ((ber_tag_t) 0x80U) #define LDAP_TAG_SYNC_REFRESH_DELETE ((ber_tag_t) 0xa1U) #define LDAP_TAG_SYNC_REFRESH_PRESENT ((ber_tag_t) 0xa2U) #define LDAP_TAG_SYNC_ID_SET ((ber_tag_t) 0xa3U) #define LDAP_TAG_SYNC_COOKIE ((ber_tag_t) 0x04U) #define LDAP_TAG_REFRESHDELETES ((ber_tag_t) 0x01U) #define LDAP_TAG_REFRESHDONE ((ber_tag_t) 0x01U) #define LDAP_TAG_RELOAD_HINT ((ber_tag_t) 0x01U) #define LDAP_SYNC_PRESENT 0 #define LDAP_SYNC_ADD 1 #define LDAP_SYNC_MODIFY 2 #define LDAP_SYNC_DELETE 3 #define LDAP_SYNC_NEW_COOKIE 4 / LDAP Don't Use Copy Control (RFC 6171) / #define LDAP_CONTROL_DONTUSECOPY "1.3.6.1.1.22" / Password policy Controls // work in progress / / ITS#3458: released; disabled by default / #define LDAP_CONTROL_PASSWORDPOLICYREQUEST "1.3.6.1.4.1.42.2.27.8.5.1" #define LDAP_CONTROL_PASSWORDPOLICYRESPONSE "1.3.6.1.4.1.42.2.27.8.5.1" / various works in progress / #define LDAP_CONTROL_NOOP "1.3.6.1.4.1.4203.666.5.2" #define LDAP_CONTROL_NO_SUBORDINATES "1.3.6.1.4.1.4203.666.5.11" #define LDAP_CONTROL_RELAX "1.3.6.1.4.1.4203.666.5.12" #define LDAP_CONTROL_MANAGEDIT LDAP_CONTROL_RELAX #define LDAP_CONTROL_SLURP "1.3.6.1.4.1.4203.666.5.13" #define LDAP_CONTROL_VALSORT "1.3.6.1.4.1.4203.666.5.14" #define LDAP_CONTROL_X_DEREF "1.3.6.1.4.1.4203.666.5.16" #define LDAP_CONTROL_X_WHATFAILED "1.3.6.1.4.1.4203.666.5.17" / LDAP Chaining Behavior Control // work in progress / / <draft-sermersheim-ldap-chaining>; * see also LDAP_NO_REFERRALS_FOUND, LDAP_CANNOT_CHAIN / #define LDAP_CONTROL_X_CHAINING_BEHAVIOR "1.3.6.1.4.1.4203.666.11.3" #define LDAP_CHAINING_PREFERRED 0 #define LDAP_CHAINING_REQUIRED 1 #define LDAP_REFERRALS_PREFERRED 2 #define LDAP_REFERRALS_REQUIRED 3 / MS Active Directory controls (for compatibility) / #define LDAP_CONTROL_X_LAZY_COMMIT "1.2.840.113556.1.4.619" #define LDAP_CONTROL_X_INCREMENTAL_VALUES "1.2.840.113556.1.4.802" #define LDAP_CONTROL_X_DOMAIN_SCOPE "1.2.840.113556.1.4.1339" #define LDAP_CONTROL_X_PERMISSIVE_MODIFY "1.2.840.113556.1.4.1413" #define LDAP_CONTROL_X_SEARCH_OPTIONS "1.2.840.113556.1.4.1340" #define LDAP_SEARCH_FLAG_DOMAIN_SCOPE 1 / do not generate referrals / #define LDAP_SEARCH_FLAG_PHANTOM_ROOT 2 / search all subordinate NCs / #define LDAP_CONTROL_X_TREE_DELETE "1.2.840.113556.1.4.805" / MS Active Directory controls - not implemented in slapd(8) / #define LDAP_CONTROL_X_SERVER_NOTIFICATION "1.2.840.113556.1.4.528" #define LDAP_CONTROL_X_EXTENDED_DN "1.2.840.113556.1.4.529" #define LDAP_CONTROL_X_SHOW_DELETED "1.2.840.113556.1.4.417" #define LDAP_CONTROL_X_DIRSYNC "1.2.840.113556.1.4.841" #define LDAP_CONTROL_X_DIRSYNC_OBJECT_SECURITY 0x00000001 #define LDAP_CONTROL_X_DIRSYNC_ANCESTORS_FIRST 0x00000800 #define LDAP_CONTROL_X_DIRSYNC_PUBLIC_DATA_ONLY 0x00002000 #define LDAP_CONTROL_X_DIRSYNC_INCREMENTAL_VALUES 0x80000000 / <draft-wahl-ldap-session> / #define LDAP_CONTROL_X_SESSION_TRACKING "1.3.6.1.4.1.21008.108.63.1" #define LDAP_CONTROL_X_SESSION_TRACKING_RADIUS_ACCT_SESSION_ID \ LDAP_CONTROL_X_SESSION_TRACKING ".1" #define LDAP_CONTROL_X_SESSION_TRACKING_RADIUS_ACCT_MULTI_SESSION_ID \ LDAP_CONTROL_X_SESSION_TRACKING ".2" #define LDAP_CONTROL_X_SESSION_TRACKING_USERNAME \ LDAP_CONTROL_X_SESSION_TRACKING ".3" / various expired works / / LDAP Duplicated Entry Control Extension // not implemented in slapd(8) / #define LDAP_CONTROL_DUPENT_REQUEST "2.16.840.1.113719.1.27.101.1" #define LDAP_CONTROL_DUPENT_RESPONSE "2.16.840.1.113719.1.27.101.2" #define LDAP_CONTROL_DUPENT_ENTRY "2.16.840.1.113719.1.27.101.3" #define LDAP_CONTROL_DUPENT LDAP_CONTROL_DUPENT_REQUEST / LDAP Persistent Search Control // not implemented in slapd(8) / #define LDAP_CONTROL_PERSIST_REQUEST "2.16.840.1.113730.3.4.3" #define LDAP_CONTROL_PERSIST_ENTRY_CHANGE_NOTICE "2.16.840.1.113730.3.4.7" #define LDAP_CONTROL_PERSIST_ENTRY_CHANGE_ADD 0x1 #define LDAP_CONTROL_PERSIST_ENTRY_CHANGE_DELETE 0x2 #define LDAP_CONTROL_PERSIST_ENTRY_CHANGE_MODIFY 0x4 #define LDAP_CONTROL_PERSIST_ENTRY_CHANGE_RENAME 0x8 / LDAP VLV / #define LDAP_CONTROL_VLVREQUEST "2.16.840.1.113730.3.4.9" #define LDAP_CONTROL_VLVRESPONSE "2.16.840.1.113730.3.4.10" / Sun's analogue to ppolicy / #define LDAP_CONTROL_X_ACCOUNT_USABILITY "1.3.6.1.4.1.42.2.27.9.5.8" #define LDAP_TAG_X_ACCOUNT_USABILITY_AVAILABLE ((ber_tag_t) 0x80U) / primitive + 0 / #define LDAP_TAG_X_ACCOUNT_USABILITY_NOT_AVAILABLE ((ber_tag_t) 0xA1U) / constructed + 1 / #define LDAP_TAG_X_ACCOUNT_USABILITY_INACTIVE ((ber_tag_t) 0x80U) / primitive + 0 / #define LDAP_TAG_X_ACCOUNT_USABILITY_RESET ((ber_tag_t) 0x81U) / primitive + 1 / #define LDAP_TAG_X_ACCOUNT_USABILITY_EXPIRED ((ber_tag_t) 0x82U) / primitive + 2 / #define LDAP_TAG_X_ACCOUNT_USABILITY_REMAINING_GRACE ((ber_tag_t) 0x83U) / primitive + 3 / #define LDAP_TAG_X_ACCOUNT_USABILITY_UNTIL_UNLOCK ((ber_tag_t) 0x84U) / primitive + 4 / / Netscape Password policy response controls / / <draft-vchu-ldap-pwd-policy> / #define LDAP_CONTROL_X_PASSWORD_EXPIRED "2.16.840.1.113730.3.4.4" #define LDAP_CONTROL_X_PASSWORD_EXPIRING "2.16.840.1.113730.3.4.5" / LDAP Unsolicited Notifications / #define LDAP_NOTICE_OF_DISCONNECTION "1.3.6.1.4.1.1466.20036" / RFC 4511 / #define LDAP_NOTICE_DISCONNECT LDAP_NOTICE_OF_DISCONNECTION / LDAP Extended Operations / #define LDAP_EXOP_START_TLS "1.3.6.1.4.1.1466.20037" / RFC 4511 / #define LDAP_EXOP_MODIFY_PASSWD "1.3.6.1.4.1.4203.1.11.1" / RFC 3062 / #define LDAP_TAG_EXOP_MODIFY_PASSWD_ID ((ber_tag_t) 0x80U) #define LDAP_TAG_EXOP_MODIFY_PASSWD_OLD ((ber_tag_t) 0x81U) #define LDAP_TAG_EXOP_MODIFY_PASSWD_NEW ((ber_tag_t) 0x82U) #define LDAP_TAG_EXOP_MODIFY_PASSWD_GEN ((ber_tag_t) 0x80U) #define LDAP_EXOP_CANCEL "1.3.6.1.1.8" / RFC 3909 / #define LDAP_EXOP_X_CANCEL LDAP_EXOP_CANCEL #define LDAP_EXOP_REFRESH "1.3.6.1.4.1.1466.101.119.1" / RFC 2589 / #define LDAP_TAG_EXOP_REFRESH_REQ_DN ((ber_tag_t) 0x80U) #define LDAP_TAG_EXOP_REFRESH_REQ_TTL ((ber_tag_t) 0x81U) #define LDAP_TAG_EXOP_REFRESH_RES_TTL ((ber_tag_t) 0x81U) #define LDAP_EXOP_VERIFY_CREDENTIALS "1.3.6.1.4.1.4203.666.6.5" #define LDAP_EXOP_X_VERIFY_CREDENTIALS LDAP_EXOP_VERIFY_CREDENTIALS #define LDAP_TAG_EXOP_VERIFY_CREDENTIALS_COOKIE ((ber_tag_t) 0x80U) #define LDAP_TAG_EXOP_VERIFY_CREDENTIALS_SCREDS ((ber_tag_t) 0x81U) #define LDAP_TAG_EXOP_VERIFY_CREDENTIALS_CONTROLS ((ber_tag_t) 0xa2U) / context specific + constructed + 2 / #define LDAP_EXOP_WHO_AM_I "1.3.6.1.4.1.4203.1.11.3" / RFC 4532 / #define LDAP_EXOP_X_WHO_AM_I LDAP_EXOP_WHO_AM_I / various works in progress / #define LDAP_EXOP_TURN "1.3.6.1.1.19" / RFC 4531 / #define LDAP_EXOP_X_TURN LDAP_EXOP_TURN / LDAP Distributed Procedures <draft-sermersheim-ldap-distproc> / / a work in progress / #define LDAP_X_DISTPROC_BASE "1.3.6.1.4.1.4203.666.11.6" #define LDAP_EXOP_X_CHAINEDREQUEST LDAP_X_DISTPROC_BASE ".1" #define LDAP_FEATURE_X_CANCHAINOPS LDAP_X_DISTPROC_BASE ".2" #define LDAP_CONTROL_X_RETURNCONTREF LDAP_X_DISTPROC_BASE ".3" #define LDAP_URLEXT_X_LOCALREFOID LDAP_X_DISTPROC_BASE ".4" #define LDAP_URLEXT_X_REFTYPEOID LDAP_X_DISTPROC_BASE ".5" #define LDAP_URLEXT_X_SEARCHEDSUBTREEOID \ LDAP_X_DISTPROC_BASE ".6" #define LDAP_URLEXT_X_FAILEDNAMEOID LDAP_X_DISTPROC_BASE ".7" #define LDAP_URLEXT_X_LOCALREF "x-localReference" #define LDAP_URLEXT_X_REFTYPE "x-referenceType" #define LDAP_URLEXT_X_SEARCHEDSUBTREE "x-searchedSubtree" #define LDAP_URLEXT_X_FAILEDNAME "x-failedName" #define LDAP_TXN "1.3.6.1.1.21" / RFC 5805 / #define LDAP_EXOP_TXN_START LDAP_TXN ".1" #define LDAP_CONTROL_TXN_SPEC LDAP_TXN ".2" #define LDAP_EXOP_TXN_END LDAP_TXN ".3" #define LDAP_EXOP_TXN_ABORTED_NOTICE LDAP_TXN ".4" / LDAP Features / #define LDAP_FEATURE_ALL_OP_ATTRS "1.3.6.1.4.1.4203.1.5.1" / RFC 3673 / #define LDAP_FEATURE_OBJECTCLASS_ATTRS \ "1.3.6.1.4.1.4203.1.5.2" / @objectClass - new number to be assigned / #define LDAP_FEATURE_ABSOLUTE_FILTERS "1.3.6.1.4.1.4203.1.5.3" / (&) (\|) / #define LDAP_FEATURE_LANGUAGE_TAG_OPTIONS "1.3.6.1.4.1.4203.1.5.4" #define LDAP_FEATURE_LANGUAGE_RANGE_OPTIONS "1.3.6.1.4.1.4203.1.5.5" #define LDAP_FEATURE_MODIFY_INCREMENT "1.3.6.1.1.14" / LDAP Experimental (works in progress) Features / #define LDAP_FEATURE_SUBORDINATE_SCOPE \ "1.3.6.1.4.1.4203.666.8.1" / "children" / #define LDAP_FEATURE_CHILDREN_SCOPE LDAP_FEATURE_SUBORDINATE_SCOPE / * specific LDAP instantiations of BER types we know about / / Overview of LBER tag construction * * Bits * ______ * 8 7 \| CLASS * 0 0 = UNIVERSAL * 0 1 = APPLICATION * 1 0 = CONTEXT-SPECIFIC * 1 1 = PRIVATE * _____ * \| 6 \| DATA-TYPE * 0 = PRIMITIVE * 1 = CONSTRUCTED * ___________ * \| 5 ... 1 \| TAG-NUMBER / / general stuff / #define LDAP_TAG_MESSAGE ((ber_tag_t) 0x30U) / constructed + 16 / #define LDAP_TAG_MSGID ((ber_tag_t) 0x02U) / integer / #define LDAP_TAG_LDAPDN ((ber_tag_t) 0x04U) / octet string / #define LDAP_TAG_LDAPCRED ((ber_tag_t) 0x04U) / octet string / #define LDAP_TAG_CONTROLS ((ber_tag_t) 0xa0U) / context specific + constructed + 0 / #define LDAP_TAG_REFERRAL ((ber_tag_t) 0xa3U) / context specific + constructed + 3 / #define LDAP_TAG_NEWSUPERIOR ((ber_tag_t) 0x80U) / context-specific + primitive + 0 / #define LDAP_TAG_EXOP_REQ_OID ((ber_tag_t) 0x80U) / context specific + primitive / #define LDAP_TAG_EXOP_REQ_VALUE ((ber_tag_t) 0x81U) / context specific + primitive / #define LDAP_TAG_EXOP_RES_OID ((ber_tag_t) 0x8aU) / context specific + primitive / #define LDAP_TAG_EXOP_RES_VALUE ((ber_tag_t) 0x8bU) / context specific + primitive / #define LDAP_TAG_IM_RES_OID ((ber_tag_t) 0x80U) / context specific + primitive / #define LDAP_TAG_IM_RES_VALUE ((ber_tag_t) 0x81U) / context specific + primitive / #define LDAP_TAG_SASL_RES_CREDS ((ber_tag_t) 0x87U) / context specific + primitive / / LDAP Request Messages / #define LDAP_REQ_BIND ((ber_tag_t) 0x60U) / application + constructed / #define LDAP_REQ_UNBIND ((ber_tag_t) 0x42U) / application + primitive / #define LDAP_REQ_SEARCH ((ber_tag_t) 0x63U) / application + constructed / #define LDAP_REQ_MODIFY ((ber_tag_t) 0x66U) / application + constructed / #define LDAP_REQ_ADD ((ber_tag_t) 0x68U) / application + constructed / #define LDAP_REQ_DELETE ((ber_tag_t) 0x4aU) / application + primitive / #define LDAP_REQ_MODDN ((ber_tag_t) 0x6cU) / application + constructed / #define LDAP_REQ_MODRDN LDAP_REQ_MODDN #define LDAP_REQ_RENAME LDAP_REQ_MODDN #define LDAP_REQ_COMPARE ((ber_tag_t) 0x6eU) / application + constructed / #define LDAP_REQ_ABANDON ((ber_tag_t) 0x50U) / application + primitive / #define LDAP_REQ_EXTENDED ((ber_tag_t) 0x77U) / application + constructed / / LDAP Response Messages / #define LDAP_RES_BIND ((ber_tag_t) 0x61U) / application + constructed / #define LDAP_RES_SEARCH_ENTRY ((ber_tag_t) 0x64U) / application + constructed / #define LDAP_RES_SEARCH_REFERENCE ((ber_tag_t) 0x73U) / V3: application + constructed / #define LDAP_RES_SEARCH_RESULT ((ber_tag_t) 0x65U) / application + constructed / #define LDAP_RES_MODIFY ((ber_tag_t) 0x67U) / application + constructed / #define LDAP_RES_ADD ((ber_tag_t) 0x69U) / application + constructed / #define LDAP_RES_DELETE ((ber_tag_t) 0x6bU) / application + constructed / #define LDAP_RES_MODDN ((ber_tag_t) 0x6dU) / application + constructed / #define LDAP_RES_MODRDN LDAP_RES_MODDN / application + constructed / #define LDAP_RES_RENAME LDAP_RES_MODDN / application + constructed / #define LDAP_RES_COMPARE ((ber_tag_t) 0x6fU) / application + constructed / #define LDAP_RES_EXTENDED ((ber_tag_t) 0x78U) / V3: application + constructed / #define LDAP_RES_INTERMEDIATE ((ber_tag_t) 0x79U) / V3+: application + constructed / #define LDAP_RES_ANY (-1) #define LDAP_RES_UNSOLICITED (0) / sasl methods / #define LDAP_SASL_SIMPLE ((char)0) #define LDAP_SASL_NULL ("") /* authentication methods available / #define LDAP_AUTH_NONE ((ber_tag_t) 0x00U) / no authentication / #define LDAP_AUTH_SIMPLE ((ber_tag_t) 0x80U) / context specific + primitive / #define LDAP_AUTH_SASL ((ber_tag_t) 0xa3U) / context specific + constructed / #define LDAP_AUTH_KRBV4 ((ber_tag_t) 0xffU) / means do both of the following / #define LDAP_AUTH_KRBV41 ((ber_tag_t) 0x81U) / context specific + primitive / #define LDAP_AUTH_KRBV42 ((ber_tag_t) 0x82U) / context specific + primitive / / used by the Windows API but not used on the wire / #define LDAP_AUTH_NEGOTIATE ((ber_tag_t) 0x04FFU) / filter types / #define LDAP_FILTER_AND ((ber_tag_t) 0xa0U) / context specific + constructed / #define LDAP_FILTER_OR ((ber_tag_t) 0xa1U) / context specific + constructed / #define LDAP_FILTER_NOT ((ber_tag_t) 0xa2U) / context specific + constructed / #define LDAP_FILTER_EQUALITY ((ber_tag_t) 0xa3U) / context specific + constructed / #define LDAP_FILTER_SUBSTRINGS ((ber_tag_t) 0xa4U) / context specific + constructed / #define LDAP_FILTER_GE ((ber_tag_t) 0xa5U) / context specific + constructed / #define LDAP_FILTER_LE ((ber_tag_t) 0xa6U) / context specific + constructed / #define LDAP_FILTER_PRESENT ((ber_tag_t) 0x87U) / context specific + primitive / #define LDAP_FILTER_APPROX ((ber_tag_t) 0xa8U) / context specific + constructed / #define LDAP_FILTER_EXT ((ber_tag_t) 0xa9U) / context specific + constructed / / extended filter component types / #define LDAP_FILTER_EXT_OID ((ber_tag_t) 0x81U) / context specific / #define LDAP_FILTER_EXT_TYPE ((ber_tag_t) 0x82U) / context specific / #define LDAP_FILTER_EXT_VALUE ((ber_tag_t) 0x83U) / context specific / #define LDAP_FILTER_EXT_DNATTRS ((ber_tag_t) 0x84U) / context specific / / substring filter component types / #define LDAP_SUBSTRING_INITIAL ((ber_tag_t) 0x80U) / context specific / #define LDAP_SUBSTRING_ANY ((ber_tag_t) 0x81U) / context specific / #define LDAP_SUBSTRING_FINAL ((ber_tag_t) 0x82U) / context specific / / search scopes / #define LDAP_SCOPE_BASE ((ber_int_t) 0x0000) #define LDAP_SCOPE_BASEOBJECT LDAP_SCOPE_BASE #define LDAP_SCOPE_ONELEVEL ((ber_int_t) 0x0001) #define LDAP_SCOPE_ONE LDAP_SCOPE_ONELEVEL #define LDAP_SCOPE_SUBTREE ((ber_int_t) 0x0002) #define LDAP_SCOPE_SUB LDAP_SCOPE_SUBTREE #define LDAP_SCOPE_SUBORDINATE ((ber_int_t) 0x0003) / OpenLDAP extension / #define LDAP_SCOPE_CHILDREN LDAP_SCOPE_SUBORDINATE #define LDAP_SCOPE_DEFAULT ((ber_int_t) -1) / OpenLDAP extension / / substring filter component types / #define LDAP_SUBSTRING_INITIAL ((ber_tag_t) 0x80U) / context specific / #define LDAP_SUBSTRING_ANY ((ber_tag_t) 0x81U) / context specific / #define LDAP_SUBSTRING_FINAL ((ber_tag_t) 0x82U) / context specific / / * LDAP Result Codes / #define LDAP_SUCCESS 0x00 #define LDAP_RANGE(n,x,y) (((x) <= (n)) && ((n) <= (y))) #define LDAP_OPERATIONS_ERROR 0x01 #define LDAP_PROTOCOL_ERROR 0x02 #define LDAP_TIMELIMIT_EXCEEDED 0x03 #define LDAP_SIZELIMIT_EXCEEDED 0x04 #define LDAP_COMPARE_FALSE 0x05 #define LDAP_COMPARE_TRUE 0x06 #define LDAP_AUTH_METHOD_NOT_SUPPORTED 0x07 #define LDAP_STRONG_AUTH_NOT_SUPPORTED LDAP_AUTH_METHOD_NOT_SUPPORTED #define LDAP_STRONG_AUTH_REQUIRED 0x08 #define LDAP_STRONGER_AUTH_REQUIRED LDAP_STRONG_AUTH_REQUIRED #define LDAP_PARTIAL_RESULTS 0x09 / LDAPv2+ (not LDAPv3) / #define LDAP_REFERRAL 0x0a / LDAPv3 / #define LDAP_ADMINLIMIT_EXCEEDED 0x0b / LDAPv3 / #define LDAP_UNAVAILABLE_CRITICAL_EXTENSION 0x0c / LDAPv3 / #define LDAP_CONFIDENTIALITY_REQUIRED 0x0d / LDAPv3 / #define LDAP_SASL_BIND_IN_PROGRESS 0x0e / LDAPv3 / #define LDAP_ATTR_ERROR(n) LDAP_RANGE((n),0x10,0x15) / 16-21 / #define LDAP_NO_SUCH_ATTRIBUTE 0x10 #define LDAP_UNDEFINED_TYPE 0x11 #define LDAP_INAPPROPRIATE_MATCHING 0x12 #define LDAP_CONSTRAINT_VIOLATION 0x13 #define LDAP_TYPE_OR_VALUE_EXISTS 0x14 #define LDAP_INVALID_SYNTAX 0x15 #define LDAP_NAME_ERROR(n) LDAP_RANGE((n),0x20,0x24) / 32-34,36 / #define LDAP_NO_SUCH_OBJECT 0x20 #define LDAP_ALIAS_PROBLEM 0x21 #define LDAP_INVALID_DN_SYNTAX 0x22 #define LDAP_IS_LEAF 0x23 / not LDAPv3 / #define LDAP_ALIAS_DEREF_PROBLEM 0x24 #define LDAP_SECURITY_ERROR(n) LDAP_RANGE((n),0x2F,0x32) / 47-50 / #define LDAP_X_PROXY_AUTHZ_FAILURE 0x2F / LDAPv3 proxy authorization / #define LDAP_INAPPROPRIATE_AUTH 0x30 #define LDAP_INVALID_CREDENTIALS 0x31 #define LDAP_INSUFFICIENT_ACCESS 0x32 #define LDAP_SERVICE_ERROR(n) LDAP_RANGE((n),0x33,0x36) / 51-54 / #define LDAP_BUSY 0x33 #define LDAP_UNAVAILABLE 0x34 #define LDAP_UNWILLING_TO_PERFORM 0x35 #define LDAP_LOOP_DETECT 0x36 #define LDAP_UPDATE_ERROR(n) LDAP_RANGE((n),0x40,0x47) / 64-69,71 / #define LDAP_NAMING_VIOLATION 0x40 #define LDAP_OBJECT_CLASS_VIOLATION 0x41 #define LDAP_NOT_ALLOWED_ON_NONLEAF 0x42 #define LDAP_NOT_ALLOWED_ON_RDN 0x43 #define LDAP_ALREADY_EXISTS 0x44 #define LDAP_NO_OBJECT_CLASS_MODS 0x45 #define LDAP_RESULTS_TOO_LARGE 0x46 / CLDAP / #define LDAP_AFFECTS_MULTIPLE_DSAS 0x47 #define LDAP_VLV_ERROR 0x4C #define LDAP_OTHER 0x50 / LCUP operation codes (113-117) - not implemented / #define LDAP_CUP_RESOURCES_EXHAUSTED 0x71 #define LDAP_CUP_SECURITY_VIOLATION 0x72 #define LDAP_CUP_INVALID_DATA 0x73 #define LDAP_CUP_UNSUPPORTED_SCHEME 0x74 #define LDAP_CUP_RELOAD_REQUIRED 0x75 / Cancel operation codes (118-121) / #define LDAP_CANCELLED 0x76 #define LDAP_NO_SUCH_OPERATION 0x77 #define LDAP_TOO_LATE 0x78 #define LDAP_CANNOT_CANCEL 0x79 / Assertion control (122) / #define LDAP_ASSERTION_FAILED 0x7A / Proxied Authorization Denied (123) / #define LDAP_PROXIED_AUTHORIZATION_DENIED 0x7B / Experimental result codes / #define LDAP_E_ERROR(n) LDAP_RANGE((n),0x1000,0x3FFF) / LDAP Sync (4096) / #define LDAP_SYNC_REFRESH_REQUIRED 0x1000 / Private Use result codes / #define LDAP_X_ERROR(n) LDAP_RANGE((n),0x4000,0xFFFF) #define LDAP_X_SYNC_REFRESH_REQUIRED 0x4100 / defunct / #define LDAP_X_ASSERTION_FAILED 0x410f / defunct / / for the LDAP No-Op control / #define LDAP_X_NO_OPERATION 0x410e / for the Chaining Behavior control (consecutive result codes requested; * see <draft-sermersheim-ldap-chaining> ) / #ifdef LDAP_CONTROL_X_CHAINING_BEHAVIOR #define LDAP_X_NO_REFERRALS_FOUND 0x4110 #define LDAP_X_CANNOT_CHAIN 0x4111 #endif / for Distributed Procedures (see <draft-sermersheim-ldap-distproc>) / #ifdef LDAP_X_DISTPROC_BASE #define LDAP_X_INVALIDREFERENCE 0x4112 #endif #define LDAP_TXN_SPECIFY_OKAY 0x4120 #define LDAP_TXN_ID_INVALID 0x4121 / API Error Codes * * Based on draft-ietf-ldap-c-api-xx * but with new negative code values / #define LDAP_API_ERROR(n) ((n)<0) #define LDAP_API_RESULT(n) ((n)<=0) #define LDAP_SERVER_DOWN (-1) #define LDAP_LOCAL_ERROR (-2) #define LDAP_ENCODING_ERROR (-3) #define LDAP_DECODING_ERROR (-4) #define LDAP_TIMEOUT (-5) #define LDAP_AUTH_UNKNOWN (-6) #define LDAP_FILTER_ERROR (-7) #define LDAP_USER_CANCELLED (-8) #define LDAP_PARAM_ERROR (-9) #define LDAP_NO_MEMORY (-10) #define LDAP_CONNECT_ERROR (-11) #define LDAP_NOT_SUPPORTED (-12) #define LDAP_CONTROL_NOT_FOUND (-13) #define LDAP_NO_RESULTS_RETURNED (-14) #define LDAP_MORE_RESULTS_TO_RETURN (-15) / Obsolete / #define LDAP_CLIENT_LOOP (-16) #define LDAP_REFERRAL_LIMIT_EXCEEDED (-17) #define LDAP_X_CONNECTING (-18) / * This structure represents both ldap messages and ldap responses. * These are really the same, except in the case of search responses, * where a response has multiple messages. / typedef struct ldapmsg LDAPMessage; / for modifications / typedef struct ldapmod { int mod_op; #define LDAP_MOD_OP (0x0007) #define LDAP_MOD_ADD (0x0000) #define LDAP_MOD_DELETE (0x0001) #define LDAP_MOD_REPLACE (0x0002) #define LDAP_MOD_INCREMENT (0x0003) / OpenLDAP extension / #define LDAP_MOD_BVALUES (0x0080) / IMPORTANT: do not use code 0x1000 (or above), * it is used internally by the backends! * (see ldap/servers/slapd/slap.h) / char mod_type; union mod_vals_u { char modv_strvals; struct berval modv_bvals; } mod_vals; #define mod_values mod_vals.modv_strvals #define mod_bvalues mod_vals.modv_bvals } LDAPMod; /* * structure representing an ldap session which can * encompass connections to multiple servers (in the * face of referrals). / typedef struct ldap LDAP; #define LDAP_DEREF_NEVER 0x00 #define LDAP_DEREF_SEARCHING 0x01 #define LDAP_DEREF_FINDING 0x02 #define LDAP_DEREF_ALWAYS 0x03 #define LDAP_NO_LIMIT 0 / how many messages to retrieve results for / #define LDAP_MSG_ONE 0x00 #define LDAP_MSG_ALL 0x01 #define LDAP_MSG_RECEIVED 0x02 / * types for ldap URL handling / typedef struct ldap_url_desc { struct ldap_url_desc lud_next; char lud_scheme; char lud_host; int lud_port; char lud_dn; char lud_attrs; int lud_scope; char lud_filter; char *lud_exts; int lud_crit_exts; } LDAPURLDesc; #define LDAP_URL_SUCCESS 0x00 / Success / #define LDAP_URL_ERR_MEM 0x01 / can't allocate memory space / #define LDAP_URL_ERR_PARAM 0x02 / parameter is bad / #define LDAP_URL_ERR_BADSCHEME 0x03 / URL doesn't begin with "ldap[si]://" / #define LDAP_URL_ERR_BADENCLOSURE 0x04 / URL is missing trailing ">" / #define LDAP_URL_ERR_BADURL 0x05 / URL is bad / #define LDAP_URL_ERR_BADHOST 0x06 / host port is bad / #define LDAP_URL_ERR_BADATTRS 0x07 / bad (or missing) attributes / #define LDAP_URL_ERR_BADSCOPE 0x08 / scope string is invalid (or missing) / #define LDAP_URL_ERR_BADFILTER 0x09 / bad or missing filter / #define LDAP_URL_ERR_BADEXTS 0x0a / bad or missing extensions / / * LDAP sync (RFC4533) API / typedef struct ldap_sync_t ldap_sync_t; typedef enum { / these are private - the client should never see them / LDAP_SYNC_CAPI_NONE = -1, LDAP_SYNC_CAPI_PHASE_FLAG = 0x10U, LDAP_SYNC_CAPI_IDSET_FLAG = 0x20U, LDAP_SYNC_CAPI_DONE_FLAG = 0x40U, / these are passed to ls_search_entry() / LDAP_SYNC_CAPI_PRESENT = LDAP_SYNC_PRESENT, LDAP_SYNC_CAPI_ADD = LDAP_SYNC_ADD, LDAP_SYNC_CAPI_MODIFY = LDAP_SYNC_MODIFY, LDAP_SYNC_CAPI_DELETE = LDAP_SYNC_DELETE, / these are passed to ls_intermediate() / LDAP_SYNC_CAPI_PRESENTS = ( LDAP_SYNC_CAPI_PHASE_FLAG \| LDAP_SYNC_CAPI_PRESENT ), LDAP_SYNC_CAPI_DELETES = ( LDAP_SYNC_CAPI_PHASE_FLAG \| LDAP_SYNC_CAPI_DELETE ), LDAP_SYNC_CAPI_PRESENTS_IDSET = ( LDAP_SYNC_CAPI_PRESENTS \| LDAP_SYNC_CAPI_IDSET_FLAG ), LDAP_SYNC_CAPI_DELETES_IDSET = ( LDAP_SYNC_CAPI_DELETES \| LDAP_SYNC_CAPI_IDSET_FLAG ), LDAP_SYNC_CAPI_DONE = ( LDAP_SYNC_CAPI_DONE_FLAG \| LDAP_SYNC_CAPI_PRESENTS ) } ldap_sync_refresh_t; / * Called when an entry is returned by ldap_result(). * If phase is LDAP_SYNC_CAPI_ADD or LDAP_SYNC_CAPI_MODIFY, * the entry has been either added or modified, and thus * the complete view of the entry should be in the LDAPMessage. * If phase is LDAP_SYNC_CAPI_PRESENT or LDAP_SYNC_CAPI_DELETE, * only the DN should be in the LDAPMessage. / typedef int (ldap_sync_search_entry_f) LDAP_P(( ldap_sync_t ls, LDAPMessage msg, struct berval entryUUID, ldap_sync_refresh_t phase )); / * Called when a reference is returned; the client should know * what to do with it. / typedef int (ldap_sync_search_reference_f) LDAP_P(( ldap_sync_t ls, LDAPMessage msg )); /* * Called when specific intermediate/final messages are returned. * If phase is LDAP_SYNC_CAPI_PRESENTS or LDAP_SYNC_CAPI_DELETES, * a "presents" or "deletes" phase begins. * If phase is LDAP_SYNC_CAPI_DONE, a special "presents" phase * with refreshDone set to "TRUE" has been returned, to indicate * that the refresh phase of a refreshAndPersist is complete. * In the above cases, syncUUIDs is NULL. * * If phase is LDAP_SYNC_CAPI_PRESENTS_IDSET or * LDAP_SYNC_CAPI_DELETES_IDSET, syncUUIDs is an array of UUIDs * that are either present or have been deleted. / typedef int (ldap_sync_intermediate_f) LDAP_P(( ldap_sync_t ls, LDAPMessage msg, BerVarray syncUUIDs, ldap_sync_refresh_t phase )); /* * Called when a searchResultDone is returned. In refreshAndPersist, * this can only occur if the search for any reason is being terminated * by the server. / typedef int (ldap_sync_search_result_f) LDAP_P(( ldap_sync_t ls, LDAPMessage msg, int refreshDeletes )); /* * This structure contains all information about the persistent search; * the caller is responsible for connecting, setting version, binding, tls... / struct ldap_sync_t { / conf search params / char ls_base; int ls_scope; char ls_filter; char ls_attrs; int ls_timelimit; int ls_sizelimit; / poll timeout / int ls_timeout; / helpers - add as appropriate / ldap_sync_search_entry_f ls_search_entry; ldap_sync_search_reference_f ls_search_reference; ldap_sync_intermediate_f ls_intermediate; ldap_sync_search_result_f ls_search_result; / set by the caller as appropriate / void ls_private; /* conn stuff / LDAP ls_ld; /* --- the parameters below are private - do not modify --- / / FIXME: make the structure opaque, and provide an interface * to modify the public values? / / result stuff / int ls_msgid; / sync stuff / / needed by refreshOnly / int ls_reloadHint; / opaque - need to pass between sessions, updated by the API / struct berval ls_cookie; / state variable - do not modify / ldap_sync_refresh_t ls_refreshPhase; }; / * End of LDAP sync (RFC4533) API / / * Connection callbacks... / struct ldap_conncb; struct sockaddr; / Called after a connection is established / typedef int (ldap_conn_add_f) LDAP_P(( LDAP ld, Sockbuf sb, LDAPURLDesc srv, struct sockaddr addr, struct ldap_conncb ctx )); /* Called before a connection is closed / typedef void (ldap_conn_del_f) LDAP_P(( LDAP ld, Sockbuf sb, struct ldap_conncb ctx )); /* Callbacks are pushed on a stack. Last one pushed is first one executed. The * delete callback is called with a NULL Sockbuf just before freeing the LDAP handle. / typedef struct ldap_conncb { ldap_conn_add_f lc_add; ldap_conn_del_f lc_del; void lc_arg; } ldap_conncb; /* * The API draft spec says we should declare (or cause to be declared) * 'struct timeval'. We don't. See IETF LDAPext discussions. / struct timeval; / * in options.c: / LDAP_F( int ) ldap_get_option LDAP_P(( LDAP ld, int option, void outvalue)); LDAP_F( int ) ldap_set_option LDAP_P(( LDAP ld, int option, LDAP_CONST void invalue)); / V3 REBIND Function Callback Prototype / typedef int (LDAP_REBIND_PROC) LDAP_P(( LDAP ld, LDAP_CONST char url, ber_tag_t request, ber_int_t msgid, void params )); LDAP_F( int ) ldap_set_rebind_proc LDAP_P(( LDAP ld, LDAP_REBIND_PROC rebind_proc, void params )); / V3 referral selection Function Callback Prototype / typedef int (LDAP_NEXTREF_PROC) LDAP_P(( LDAP ld, char **refsp, int cntp, void params )); LDAP_F( int ) ldap_set_nextref_proc LDAP_P(( LDAP ld, LDAP_NEXTREF_PROC nextref_proc, void params )); /* V3 URLLIST Function Callback Prototype / typedef int (LDAP_URLLIST_PROC) LDAP_P(( LDAP ld, LDAPURLDesc urllist, LDAPURLDesc url, void params )); LDAP_F( int ) ldap_set_urllist_proc LDAP_P(( LDAP ld, LDAP_URLLIST_PROC urllist_proc, void params )); /* * in controls.c: / #if LDAP_DEPRECATED LDAP_F( int ) ldap_create_control LDAP_P(( / deprecated, use ldap_control_create / LDAP_CONST char requestOID, BerElement ber, int iscritical, LDAPControl ctrlp )); LDAP_F( LDAPControl ) ldap_find_control LDAP_P(( /* deprecated, use ldap_control_find / LDAP_CONST char oid, LDAPControl *ctrls )); #endif LDAP_F( int ) ldap_control_create LDAP_P(( LDAP_CONST char requestOID, int iscritical, struct berval value, int dupval, LDAPControl ctrlp )); LDAP_F( LDAPControl ) ldap_control_find LDAP_P(( LDAP_CONST char oid, LDAPControl ctrls, LDAPControl *nextctrlp )); LDAP_F( void ) ldap_control_free LDAP_P(( LDAPControl ctrl )); LDAP_F( void ) ldap_controls_free LDAP_P(( LDAPControl ctrls )); LDAP_F( LDAPControl ) ldap_controls_dup LDAP_P(( LDAPControl LDAP_CONST controls )); LDAP_F( LDAPControl * ) ldap_control_dup LDAP_P(( LDAP_CONST LDAPControl c )); / * in dnssrv.c: / LDAP_F( int ) ldap_domain2dn LDAP_P(( LDAP_CONST char domain, char** dn )); LDAP_F( int ) ldap_dn2domain LDAP_P(( LDAP_CONST char* dn, char** domain )); LDAP_F( int ) ldap_domain2hostlist LDAP_P(( LDAP_CONST char domain, char* hostlist )); /* * in extended.c: / LDAP_F( int ) ldap_extended_operation LDAP_P(( LDAP ld, LDAP_CONST char reqoid, struct berval reqdata, LDAPControl serverctrls, LDAPControl clientctrls, int msgidp )); LDAP_F( int ) ldap_extended_operation_s LDAP_P(( LDAP ld, LDAP_CONST char reqoid, struct berval reqdata, LDAPControl serverctrls, LDAPControl clientctrls, char retoidp, struct berval retdatap )); LDAP_F( int ) ldap_parse_extended_result LDAP_P(( LDAP ld, LDAPMessage res, char retoidp, struct berval retdatap, int freeit )); LDAP_F( int ) ldap_parse_intermediate LDAP_P(( LDAP ld, LDAPMessage res, char retoidp, struct berval retdatap, LDAPControl **serverctrls, int freeit )); / * in abandon.c: / LDAP_F( int ) ldap_abandon_ext LDAP_P(( LDAP ld, int msgid, LDAPControl serverctrls, LDAPControl clientctrls )); #if LDAP_DEPRECATED LDAP_F( int ) ldap_abandon LDAP_P(( /* deprecated, use ldap_abandon_ext / LDAP ld, int msgid )); #endif /* * in add.c: / LDAP_F( int ) ldap_add_ext LDAP_P(( LDAP ld, LDAP_CONST char dn, LDAPMod attrs, LDAPControl serverctrls, LDAPControl clientctrls, int msgidp )); LDAP_F( int ) ldap_add_ext_s LDAP_P(( LDAP ld, LDAP_CONST char dn, LDAPMod attrs, LDAPControl serverctrls, LDAPControl *clientctrls )); #if LDAP_DEPRECATED LDAP_F( int ) ldap_add LDAP_P(( / deprecated, use ldap_add_ext / LDAP ld, LDAP_CONST char dn, LDAPMod attrs )); LDAP_F( int ) ldap_add_s LDAP_P(( / deprecated, use ldap_add_ext_s / LDAP ld, LDAP_CONST char dn, LDAPMod attrs )); #endif / * in sasl.c: / LDAP_F( int ) ldap_sasl_bind LDAP_P(( LDAP ld, LDAP_CONST char dn, LDAP_CONST char mechanism, struct berval cred, LDAPControl serverctrls, LDAPControl clientctrls, int msgidp )); /* Interaction flags (should be passed about in a control) * Automatic (default): use defaults, prompt otherwise * Interactive: prompt always * Quiet: never prompt / #define LDAP_SASL_AUTOMATIC 0U #define LDAP_SASL_INTERACTIVE 1U #define LDAP_SASL_QUIET 2U / * V3 SASL Interaction Function Callback Prototype * when using Cyrus SASL, interact is pointer to sasl_interact_t * should likely passed in a control (and provided controls) / typedef int (LDAP_SASL_INTERACT_PROC) LDAP_P(( LDAP ld, unsigned flags, void* defaults, void interact )); LDAP_F( int ) ldap_sasl_interactive_bind LDAP_P(( LDAP ld, LDAP_CONST char dn, / usually NULL / LDAP_CONST char saslMechanism, LDAPControl serverControls, LDAPControl clientControls, /* should be client controls / unsigned flags, LDAP_SASL_INTERACT_PROC proc, void defaults, / as obtained from ldap_result() / LDAPMessage result, /* returned during bind processing / const char rmech, int msgid )); LDAP_F( int ) ldap_sasl_interactive_bind_s LDAP_P(( LDAP ld, LDAP_CONST char dn, /* usually NULL / LDAP_CONST char saslMechanism, LDAPControl serverControls, LDAPControl clientControls, /* should be client controls / unsigned flags, LDAP_SASL_INTERACT_PROC proc, void defaults )); LDAP_F( int ) ldap_sasl_bind_s LDAP_P(( LDAP ld, LDAP_CONST char dn, LDAP_CONST char mechanism, struct berval cred, LDAPControl serverctrls, LDAPControl clientctrls, struct berval servercredp )); LDAP_F( int ) ldap_parse_sasl_bind_result LDAP_P(( LDAP ld, LDAPMessage res, struct berval servercredp, int freeit )); #if LDAP_DEPRECATED / * in bind.c: * (deprecated) / LDAP_F( int ) ldap_bind LDAP_P(( / deprecated, use ldap_sasl_bind / LDAP ld, LDAP_CONST char who, LDAP_CONST char passwd, int authmethod )); LDAP_F( int ) ldap_bind_s LDAP_P(( /* deprecated, use ldap_sasl_bind_s / LDAP ld, LDAP_CONST char who, LDAP_CONST char cred, int authmethod )); /* * in sbind.c: / LDAP_F( int ) ldap_simple_bind LDAP_P(( / deprecated, use ldap_sasl_bind / LDAP ld, LDAP_CONST char who, LDAP_CONST char passwd )); LDAP_F( int ) ldap_simple_bind_s LDAP_P(( /* deprecated, use ldap_sasl_bind_s / LDAP ld, LDAP_CONST char who, LDAP_CONST char passwd )); #endif /* * in compare.c: / LDAP_F( int ) ldap_compare_ext LDAP_P(( LDAP ld, LDAP_CONST char dn, LDAP_CONST char attr, struct berval bvalue, LDAPControl serverctrls, LDAPControl clientctrls, int msgidp )); LDAP_F( int ) ldap_compare_ext_s LDAP_P(( LDAP ld, LDAP_CONST char dn, LDAP_CONST char attr, struct berval bvalue, LDAPControl serverctrls, LDAPControl clientctrls )); #if LDAP_DEPRECATED LDAP_F( int ) ldap_compare LDAP_P(( /* deprecated, use ldap_compare_ext / LDAP ld, LDAP_CONST char dn, LDAP_CONST char attr, LDAP_CONST char value )); LDAP_F( int ) ldap_compare_s LDAP_P(( / deprecated, use ldap_compare_ext_s / LDAP ld, LDAP_CONST char dn, LDAP_CONST char attr, LDAP_CONST char value )); #endif / * in delete.c: / LDAP_F( int ) ldap_delete_ext LDAP_P(( LDAP ld, LDAP_CONST char dn, LDAPControl serverctrls, LDAPControl clientctrls, int msgidp )); LDAP_F( int ) ldap_delete_ext_s LDAP_P(( LDAP ld, LDAP_CONST char dn, LDAPControl serverctrls, LDAPControl clientctrls )); #if LDAP_DEPRECATED LDAP_F( int ) ldap_delete LDAP_P(( /* deprecated, use ldap_delete_ext / LDAP ld, LDAP_CONST char dn )); LDAP_F( int ) ldap_delete_s LDAP_P(( / deprecated, use ldap_delete_ext_s / LDAP ld, LDAP_CONST char dn )); #endif / * in error.c: / LDAP_F( int ) ldap_parse_result LDAP_P(( LDAP ld, LDAPMessage res, int errcodep, char matcheddnp, char diagmsgp, char *referralsp, LDAPControl serverctrls, int freeit )); LDAP_F( char ) ldap_err2string LDAP_P(( int err )); #if LDAP_DEPRECATED LDAP_F( int ) ldap_result2error LDAP_P(( /* deprecated, use ldap_parse_result / LDAP ld, LDAPMessage r, int freeit )); LDAP_F( void ) ldap_perror LDAP_P(( / deprecated, use ldap_err2string / LDAP ld, LDAP_CONST char s )); #endif / * in modify.c: / LDAP_F( int ) ldap_modify_ext LDAP_P(( LDAP ld, LDAP_CONST char dn, LDAPMod mods, LDAPControl serverctrls, LDAPControl clientctrls, int msgidp )); LDAP_F( int ) ldap_modify_ext_s LDAP_P(( LDAP ld, LDAP_CONST char dn, LDAPMod mods, LDAPControl serverctrls, LDAPControl *clientctrls )); #if LDAP_DEPRECATED LDAP_F( int ) ldap_modify LDAP_P(( / deprecated, use ldap_modify_ext / LDAP ld, LDAP_CONST char dn, LDAPMod mods )); LDAP_F( int ) ldap_modify_s LDAP_P(( / deprecated, use ldap_modify_ext_s / LDAP ld, LDAP_CONST char dn, LDAPMod mods )); #endif / * in modrdn.c: / LDAP_F( int ) ldap_rename LDAP_P(( LDAP ld, LDAP_CONST char dn, LDAP_CONST char newrdn, LDAP_CONST char newSuperior, int deleteoldrdn, LDAPControl sctrls, LDAPControl cctrls, int msgidp )); LDAP_F( int ) ldap_rename_s LDAP_P(( LDAP ld, LDAP_CONST char dn, LDAP_CONST char newrdn, LDAP_CONST char newSuperior, int deleteoldrdn, LDAPControl sctrls, LDAPControl cctrls )); #if LDAP_DEPRECATED LDAP_F( int ) ldap_rename2 LDAP_P(( /* deprecated, use ldap_rename / LDAP ld, LDAP_CONST char dn, LDAP_CONST char newrdn, LDAP_CONST char newSuperior, int deleteoldrdn )); LDAP_F( int ) ldap_rename2_s LDAP_P(( / deprecated, use ldap_rename_s / LDAP ld, LDAP_CONST char dn, LDAP_CONST char newrdn, LDAP_CONST char newSuperior, int deleteoldrdn )); LDAP_F( int ) ldap_modrdn LDAP_P(( / deprecated, use ldap_rename / LDAP ld, LDAP_CONST char dn, LDAP_CONST char newrdn )); LDAP_F( int ) ldap_modrdn_s LDAP_P(( /* deprecated, use ldap_rename_s / LDAP ld, LDAP_CONST char dn, LDAP_CONST char newrdn )); LDAP_F( int ) ldap_modrdn2 LDAP_P(( /* deprecated, use ldap_rename / LDAP ld, LDAP_CONST char dn, LDAP_CONST char newrdn, int deleteoldrdn )); LDAP_F( int ) ldap_modrdn2_s LDAP_P(( /* deprecated, use ldap_rename_s / LDAP ld, LDAP_CONST char dn, LDAP_CONST char newrdn, int deleteoldrdn)); #endif /* * in open.c: / #if LDAP_DEPRECATED LDAP_F( LDAP ) ldap_init LDAP_P(( /* deprecated, use ldap_create or ldap_initialize / LDAP_CONST char host, int port )); LDAP_F( LDAP * ) ldap_open LDAP_P(( /* deprecated, use ldap_create or ldap_initialize / LDAP_CONST char host, int port )); #endif LDAP_F( int ) ldap_create LDAP_P(( LDAP ldp )); LDAP_F( int ) ldap_initialize LDAP_P(( LDAP ldp, LDAP_CONST char url )); LDAP_F( LDAP ) ldap_dup LDAP_P(( LDAP old )); LDAP_F( int ) ldap_connect( LDAP ld ); /* * in tls.c / LDAP_F( int ) ldap_tls_inplace LDAP_P(( LDAP ld )); LDAP_F( int ) ldap_start_tls LDAP_P(( LDAP ld, LDAPControl serverctrls, LDAPControl clientctrls, int msgidp )); LDAP_F( int ) ldap_install_tls LDAP_P(( LDAP ld )); LDAP_F( int ) ldap_start_tls_s LDAP_P(( LDAP ld, LDAPControl serverctrls, LDAPControl clientctrls )); /* * in messages.c: / LDAP_F( LDAPMessage ) ldap_first_message LDAP_P(( LDAP ld, LDAPMessage chain )); LDAP_F( LDAPMessage * ) ldap_next_message LDAP_P(( LDAP ld, LDAPMessage msg )); LDAP_F( int ) ldap_count_messages LDAP_P(( LDAP ld, LDAPMessage chain )); /* * in references.c: / LDAP_F( LDAPMessage ) ldap_first_reference LDAP_P(( LDAP ld, LDAPMessage chain )); LDAP_F( LDAPMessage * ) ldap_next_reference LDAP_P(( LDAP ld, LDAPMessage ref )); LDAP_F( int ) ldap_count_references LDAP_P(( LDAP ld, LDAPMessage chain )); LDAP_F( int ) ldap_parse_reference LDAP_P(( LDAP ld, LDAPMessage ref, char *referralsp, LDAPControl serverctrls, int freeit)); / * in getentry.c: / LDAP_F( LDAPMessage ) ldap_first_entry LDAP_P(( LDAP ld, LDAPMessage chain )); LDAP_F( LDAPMessage * ) ldap_next_entry LDAP_P(( LDAP ld, LDAPMessage entry )); LDAP_F( int ) ldap_count_entries LDAP_P(( LDAP ld, LDAPMessage chain )); LDAP_F( int ) ldap_get_entry_controls LDAP_P(( LDAP ld, LDAPMessage entry, LDAPControl **serverctrls)); / * in addentry.c / LDAP_F( LDAPMessage ) ldap_delete_result_entry LDAP_P(( LDAPMessage *list, LDAPMessage e )); LDAP_F( void ) ldap_add_result_entry LDAP_P(( LDAPMessage *list, LDAPMessage e )); /* * in getdn.c / LDAP_F( char ) ldap_get_dn LDAP_P(( LDAP ld, LDAPMessage entry )); typedef struct ldap_ava { struct berval la_attr; struct berval la_value; unsigned la_flags; #define LDAP_AVA_NULL 0x0000U #define LDAP_AVA_STRING 0x0001U #define LDAP_AVA_BINARY 0x0002U #define LDAP_AVA_NONPRINTABLE 0x0004U #define LDAP_AVA_FREE_ATTR 0x0010U #define LDAP_AVA_FREE_VALUE 0x0020U void la_private; } LDAPAVA; typedef LDAPAVA* LDAPRDN; typedef LDAPRDN* LDAPDN; /* DN formats / #define LDAP_DN_FORMAT_LDAP 0x0000U #define LDAP_DN_FORMAT_LDAPV3 0x0010U #define LDAP_DN_FORMAT_LDAPV2 0x0020U #define LDAP_DN_FORMAT_DCE 0x0030U #define LDAP_DN_FORMAT_UFN 0x0040U / dn2str only / #define LDAP_DN_FORMAT_AD_CANONICAL 0x0050U / dn2str only / #define LDAP_DN_FORMAT_LBER 0x00F0U / for testing only / #define LDAP_DN_FORMAT_MASK 0x00F0U / DN flags / #define LDAP_DN_PRETTY 0x0100U #define LDAP_DN_SKIP 0x0200U #define LDAP_DN_P_NOLEADTRAILSPACES 0x1000U #define LDAP_DN_P_NOSPACEAFTERRDN 0x2000U #define LDAP_DN_PEDANTIC 0xF000U LDAP_F( void ) ldap_rdnfree LDAP_P(( LDAPRDN rdn )); LDAP_F( void ) ldap_dnfree LDAP_P(( LDAPDN dn )); LDAP_F( int ) ldap_bv2dn LDAP_P(( struct berval bv, LDAPDN dn, unsigned flags )); LDAP_F( int ) ldap_str2dn LDAP_P(( LDAP_CONST char str, LDAPDN dn, unsigned flags )); LDAP_F( int ) ldap_dn2bv LDAP_P(( LDAPDN dn, struct berval bv, unsigned flags )); LDAP_F( int ) ldap_dn2str LDAP_P(( LDAPDN dn, char *str, unsigned flags )); LDAP_F( int ) ldap_bv2rdn LDAP_P(( struct berval bv, LDAPRDN rdn, char next, unsigned flags )); LDAP_F( int ) ldap_str2rdn LDAP_P(( LDAP_CONST char str, LDAPRDN rdn, char next, unsigned flags )); LDAP_F( int ) ldap_rdn2bv LDAP_P(( LDAPRDN rdn, struct berval bv, unsigned flags )); LDAP_F( int ) ldap_rdn2str LDAP_P(( LDAPRDN rdn, char *str, unsigned flags )); LDAP_F( int ) ldap_dn_normalize LDAP_P(( LDAP_CONST char in, unsigned iflags, char *out, unsigned oflags )); LDAP_F( char ) ldap_dn2ufn LDAP_P(( /* deprecated, use ldap_str2dn/dn2str / LDAP_CONST char dn )); LDAP_F( char ** ) ldap_explode_dn LDAP_P(( /* deprecated, ldap_str2dn / LDAP_CONST char dn, int notypes )); LDAP_F( char ** ) ldap_explode_rdn LDAP_P(( /* deprecated, ldap_str2rdn / LDAP_CONST char rdn, int notypes )); typedef int LDAPDN_rewrite_func LDAP_P(( LDAPDN dn, unsigned flags, void ctx )); LDAP_F( int ) ldap_X509dn2bv LDAP_P(( void x509_name, struct berval dn, LDAPDN_rewrite_func func, unsigned flags )); LDAP_F( char * ) ldap_dn2dcedn LDAP_P(( /* deprecated, ldap_str2dn/dn2str / LDAP_CONST char dn )); LDAP_F( char * ) ldap_dcedn2dn LDAP_P(( /* deprecated, ldap_str2dn/dn2str / LDAP_CONST char dce )); LDAP_F( char * ) ldap_dn2ad_canonical LDAP_P(( /* deprecated, ldap_str2dn/dn2str / LDAP_CONST char dn )); LDAP_F( int ) ldap_get_dn_ber LDAP_P(( LDAP ld, LDAPMessage e, BerElement *berout, struct berval dn )); LDAP_F( int ) ldap_get_attribute_ber LDAP_P(( LDAP ld, LDAPMessage e, BerElement ber, struct berval attr, struct berval *vals )); / * in getattr.c / LDAP_F( char ) ldap_first_attribute LDAP_P(( LDAP ld, LDAPMessage entry, BerElement *ber )); LDAP_F( char ) ldap_next_attribute LDAP_P(( LDAP ld, LDAPMessage entry, BerElement ber )); / * in getvalues.c / LDAP_F( struct berval * ) ldap_get_values_len LDAP_P(( LDAP ld, LDAPMessage entry, LDAP_CONST char target )); LDAP_F( int ) ldap_count_values_len LDAP_P(( struct berval vals )); LDAP_F( void ) ldap_value_free_len LDAP_P(( struct berval vals )); #if LDAP_DEPRECATED LDAP_F( char * ) ldap_get_values LDAP_P(( /* deprecated, use ldap_get_values_len / LDAP ld, LDAPMessage entry, LDAP_CONST char target )); LDAP_F( int ) ldap_count_values LDAP_P(( /* deprecated, use ldap_count_values_len / char vals )); LDAP_F( void ) ldap_value_free LDAP_P(( / deprecated, use ldap_value_free_len / char vals )); #endif / * in result.c: / LDAP_F( int ) ldap_result LDAP_P(( LDAP ld, int msgid, int all, struct timeval timeout, LDAPMessage result )); LDAP_F( int ) ldap_msgtype LDAP_P(( LDAPMessage lm )); LDAP_F( int ) ldap_msgid LDAP_P(( LDAPMessage lm )); LDAP_F( int ) ldap_msgfree LDAP_P(( LDAPMessage lm )); LDAP_F( int ) ldap_msgdelete LDAP_P(( LDAP ld, int msgid )); / * in search.c: / LDAP_F( int ) ldap_bv2escaped_filter_value LDAP_P(( struct berval in, struct berval out )); LDAP_F( int ) ldap_search_ext LDAP_P(( LDAP ld, LDAP_CONST char base, int scope, LDAP_CONST char filter, char attrs, int attrsonly, LDAPControl serverctrls, LDAPControl *clientctrls, struct timeval timeout, int sizelimit, int msgidp )); LDAP_F( int ) ldap_search_ext_s LDAP_P(( LDAP ld, LDAP_CONST char base, int scope, LDAP_CONST char filter, char attrs, int attrsonly, LDAPControl serverctrls, LDAPControl *clientctrls, struct timeval timeout, int sizelimit, LDAPMessage *res )); #if LDAP_DEPRECATED LDAP_F( int ) ldap_search LDAP_P(( / deprecated, use ldap_search_ext / LDAP ld, LDAP_CONST char base, int scope, LDAP_CONST char filter, char *attrs, int attrsonly )); LDAP_F( int ) ldap_search_s LDAP_P(( / deprecated, use ldap_search_ext_s / LDAP ld, LDAP_CONST char base, int scope, LDAP_CONST char filter, char attrs, int attrsonly, LDAPMessage res )); LDAP_F( int ) ldap_search_st LDAP_P(( /* deprecated, use ldap_search_ext_s / LDAP ld, LDAP_CONST char base, int scope, LDAP_CONST char filter, char *attrs, int attrsonly, struct timeval timeout, LDAPMessage *res )); #endif / * in unbind.c / LDAP_F( int ) ldap_unbind_ext LDAP_P(( LDAP ld, LDAPControl serverctrls, LDAPControl clientctrls)); LDAP_F( int ) ldap_unbind_ext_s LDAP_P(( LDAP ld, LDAPControl serverctrls, LDAPControl clientctrls)); LDAP_F( int ) ldap_destroy LDAP_P(( LDAP ld)); #if LDAP_DEPRECATED LDAP_F( int ) ldap_unbind LDAP_P(( /* deprecated, use ldap_unbind_ext / LDAP ld )); LDAP_F( int ) ldap_unbind_s LDAP_P(( /* deprecated, use ldap_unbind_ext_s / LDAP ld )); #endif /* * in filter.c / LDAP_F( int ) ldap_put_vrFilter LDAP_P(( BerElement ber, const char vrf )); / * in free.c / LDAP_F( void ) ldap_memalloc LDAP_P(( ber_len_t s )); LDAP_F( void * ) ldap_memrealloc LDAP_P(( void* p, ber_len_t s )); LDAP_F( void * ) ldap_memcalloc LDAP_P(( ber_len_t n, ber_len_t s )); LDAP_F( void ) ldap_memfree LDAP_P(( void* p )); LDAP_F( void ) ldap_memvfree LDAP_P(( void** v )); LDAP_F( char * ) ldap_strdup LDAP_P(( LDAP_CONST char * )); LDAP_F( void ) ldap_mods_free LDAP_P(( LDAPMod *mods, int freemods )); #if LDAP_DEPRECATED / * in sort.c (deprecated, use custom code instead) / typedef int (LDAP_SORT_AD_CMP_PROC) LDAP_P(( / deprecated / LDAP_CONST char left, LDAP_CONST char right )); typedef int (LDAP_SORT_AV_CMP_PROC) LDAP_P(( / deprecated / LDAP_CONST void left, LDAP_CONST void right )); LDAP_F( int ) / deprecated / ldap_sort_entries LDAP_P(( LDAP ld, LDAPMessage *chain, LDAP_CONST char attr, LDAP_SORT_AD_CMP_PROC cmp )); LDAP_F( int ) / deprecated / ldap_sort_values LDAP_P(( LDAP ld, char *vals, LDAP_SORT_AV_CMP_PROC cmp )); LDAP_F( int ) /* deprecated / ldap_sort_strcasecmp LDAP_P(( LDAP_CONST void a, LDAP_CONST void b )); #endif / * in url.c / LDAP_F( int ) ldap_is_ldap_url LDAP_P(( LDAP_CONST char url )); LDAP_F( int ) ldap_is_ldaps_url LDAP_P(( LDAP_CONST char url )); LDAP_F( int ) ldap_is_ldapi_url LDAP_P(( LDAP_CONST char url )); #ifdef LDAP_CONNECTIONLESS LDAP_F( int ) ldap_is_ldapc_url LDAP_P(( LDAP_CONST char url )); #endif LDAP_F( int ) ldap_url_parse LDAP_P(( LDAP_CONST char url, LDAPURLDesc *ludpp )); LDAP_F( char ) ldap_url_desc2str LDAP_P(( LDAPURLDesc ludp )); LDAP_F( void ) ldap_free_urldesc LDAP_P(( LDAPURLDesc ludp )); /* * LDAP Cancel Extended Operation <draft-zeilenga-ldap-cancel-xx.txt> * in cancel.c / #define LDAP_API_FEATURE_CANCEL 1000 LDAP_F( int ) ldap_cancel LDAP_P(( LDAP ld, int cancelid, LDAPControl sctrls, LDAPControl cctrls, int msgidp )); LDAP_F( int ) ldap_cancel_s LDAP_P(( LDAP ld, int cancelid, LDAPControl sctrl, LDAPControl cctrl )); /* * LDAP Turn Extended Operation <draft-zeilenga-ldap-turn-xx.txt> * in turn.c / #define LDAP_API_FEATURE_TURN 1000 LDAP_F( int ) ldap_turn LDAP_P(( LDAP ld, int mutual, LDAP_CONST char* identifier, LDAPControl sctrls, LDAPControl cctrls, int msgidp )); LDAP_F( int ) ldap_turn_s LDAP_P(( LDAP ld, int mutual, LDAP_CONST char* identifier, LDAPControl sctrl, LDAPControl cctrl )); /* * LDAP Paged Results * in pagectrl.c / #define LDAP_API_FEATURE_PAGED_RESULTS 2000 LDAP_F( int ) ldap_create_page_control_value LDAP_P(( LDAP ld, ber_int_t pagesize, struct berval cookie, struct berval value )); LDAP_F( int ) ldap_create_page_control LDAP_P(( LDAP ld, ber_int_t pagesize, struct berval cookie, int iscritical, LDAPControl *ctrlp )); #if LDAP_DEPRECATED LDAP_F( int ) ldap_parse_page_control LDAP_P(( / deprecated, use ldap_parse_pageresponse_control / LDAP ld, LDAPControl *ctrls, ber_int_t count, struct berval *cookie )); #endif LDAP_F( int ) ldap_parse_pageresponse_control LDAP_P(( LDAP ld, LDAPControl ctrl, ber_int_t count, struct berval cookie )); / * LDAP Server Side Sort * in sortctrl.c / #define LDAP_API_FEATURE_SERVER_SIDE_SORT 2000 / structure for a sort-key / typedef struct ldapsortkey { char attributeType; char orderingRule; int reverseOrder; } LDAPSortKey; LDAP_F( int ) ldap_create_sort_keylist LDAP_P(( LDAPSortKey *sortKeyList, char keyString )); LDAP_F( void ) ldap_free_sort_keylist LDAP_P(( LDAPSortKey *sortkeylist )); LDAP_F( int ) ldap_create_sort_control_value LDAP_P(( LDAP ld, LDAPSortKey *keyList, struct berval value )); LDAP_F( int ) ldap_create_sort_control LDAP_P(( LDAP ld, LDAPSortKey keyList, int iscritical, LDAPControl ctrlp )); LDAP_F( int ) ldap_parse_sortresponse_control LDAP_P(( LDAP ld, LDAPControl ctrl, ber_int_t result, char *attribute )); / * LDAP Virtual List View * in vlvctrl.c / #define LDAP_API_FEATURE_VIRTUAL_LIST_VIEW 2000 / structure for virtual list / typedef struct ldapvlvinfo { ber_int_t ldvlv_version; ber_int_t ldvlv_before_count; ber_int_t ldvlv_after_count; ber_int_t ldvlv_offset; ber_int_t ldvlv_count; struct berval ldvlv_attrvalue; struct berval * ldvlv_context; void * ldvlv_extradata; } LDAPVLVInfo; LDAP_F( int ) ldap_create_vlv_control_value LDAP_P(( LDAP ld, LDAPVLVInfo ldvlistp, struct berval value)); LDAP_F( int ) ldap_create_vlv_control LDAP_P(( LDAP ld, LDAPVLVInfo ldvlistp, LDAPControl ctrlp )); LDAP_F( int ) ldap_parse_vlvresponse_control LDAP_P(( LDAP ld, LDAPControl ctrls, ber_int_t target_posp, ber_int_t list_countp, struct berval contextp, int errcodep )); /* * LDAP Verify Credentials / #define LDAP_API_FEATURE_VERIFY_CREDENTIALS 1000 LDAP_F( int ) ldap_verify_credentials LDAP_P(( LDAP ld, struct berval cookie, LDAP_CONST char dn, LDAP_CONST char mechanism, struct berval cred, LDAPControl ctrls, LDAPControl serverctrls, LDAPControl *clientctrls, int msgidp )); LDAP_F( int ) ldap_verify_credentials_s LDAP_P(( LDAP ld, struct berval cookie, LDAP_CONST char dn, LDAP_CONST char mechanism, struct berval cred, LDAPControl vcictrls, LDAPControl serverctrls, LDAPControl clientctrls, int code, char diagmsgp, struct berval scookie, struct berval servercredp, LDAPControl vcoctrls)); LDAP_F( int ) ldap_parse_verify_credentials LDAP_P(( LDAP ld, LDAPMessage res, int code, char diagmsgp, struct berval cookie, struct berval servercredp, LDAPControl vcctrls)); / not yet implemented / / #define LDAP_API_FEATURE_VERIFY_CREDENTIALS_INTERACTIVE 1000 / #ifdef LDAP_API_FEATURE_VERIFY_CREDENTIALS_INTERACTIVE LDAP_F( int ) ldap_verify_credentials_interactive LDAP_P(( LDAP ld, LDAP_CONST char dn, / usually NULL / LDAP_CONST char saslMechanism, LDAPControl vcControls, LDAPControl serverControls, LDAPControl *clientControls, / should be client controls / unsigned flags, LDAP_SASL_INTERACT_PROC proc, void defaults, void context, /* as obtained from ldap_result() / LDAPMessage result, /* returned during bind processing / const char rmech, int msgid )); #endif /* * LDAP Who Am I? * in whoami.c / #define LDAP_API_FEATURE_WHOAMI 1000 LDAP_F( int ) ldap_parse_whoami LDAP_P(( LDAP ld, LDAPMessage res, struct berval authzid )); LDAP_F( int ) ldap_whoami LDAP_P(( LDAP ld, LDAPControl sctrls, LDAPControl cctrls, int msgidp )); LDAP_F( int ) ldap_whoami_s LDAP_P(( LDAP ld, struct berval authzid, LDAPControl sctrls, LDAPControl *cctrls )); / * LDAP Password Modify * in passwd.c / #define LDAP_API_FEATURE_PASSWD_MODIFY 1000 LDAP_F( int ) ldap_parse_passwd LDAP_P(( LDAP ld, LDAPMessage res, struct berval newpasswd )); LDAP_F( int ) ldap_passwd LDAP_P(( LDAP ld, struct berval user, struct berval oldpw, struct berval newpw, LDAPControl sctrls, LDAPControl cctrls, int msgidp )); LDAP_F( int ) ldap_passwd_s LDAP_P(( LDAP ld, struct berval user, struct berval oldpw, struct berval newpw, struct berval newpasswd, LDAPControl sctrls, LDAPControl cctrls )); #ifdef LDAP_CONTROL_PASSWORDPOLICYREQUEST /* * LDAP Password Policy controls * in ppolicy.c / #define LDAP_API_FEATURE_PASSWORD_POLICY 1000 typedef enum passpolicyerror_enum { PP_passwordExpired = 0, PP_accountLocked = 1, PP_changeAfterReset = 2, PP_passwordModNotAllowed = 3, PP_mustSupplyOldPassword = 4, PP_insufficientPasswordQuality = 5, PP_passwordTooShort = 6, PP_passwordTooYoung = 7, PP_passwordInHistory = 8, PP_passwordTooLong = 9, PP_noError = 65535 } LDAPPasswordPolicyError; LDAP_F( int ) ldap_create_passwordpolicy_control LDAP_P(( LDAP ld, LDAPControl *ctrlp )); LDAP_F( int ) ldap_parse_passwordpolicy_control LDAP_P(( LDAP ld, LDAPControl ctrl, ber_int_t expirep, ber_int_t gracep, LDAPPasswordPolicyError errorp )); LDAP_F( const char * ) ldap_passwordpolicy_err2txt LDAP_P(( LDAPPasswordPolicyError )); #endif /* LDAP_CONTROL_PASSWORDPOLICYREQUEST / LDAP_F( int ) ldap_parse_password_expiring_control LDAP_P(( LDAP ld, LDAPControl ctrl, long secondsp )); /* * LDAP Dynamic Directory Services Refresh -- RFC 2589 * in dds.c / #define LDAP_API_FEATURE_REFRESH 1000 LDAP_F( int ) ldap_parse_refresh LDAP_P(( LDAP ld, LDAPMessage res, ber_int_t newttl )); LDAP_F( int ) ldap_refresh LDAP_P(( LDAP ld, struct berval dn, ber_int_t ttl, LDAPControl sctrls, LDAPControl cctrls, int msgidp )); LDAP_F( int ) ldap_refresh_s LDAP_P(( LDAP ld, struct berval dn, ber_int_t ttl, ber_int_t newttl, LDAPControl sctrls, LDAPControl cctrls )); /* * LDAP Transactions / LDAP_F( int ) ldap_txn_start LDAP_P(( LDAP ld, LDAPControl sctrls, LDAPControl cctrls, int msgidp )); LDAP_F( int ) ldap_txn_start_s LDAP_P(( LDAP ld, LDAPControl sctrl, LDAPControl cctrl, struct berval *rettxnid )); LDAP_F( int ) ldap_txn_end LDAP_P(( LDAP ld, int commit, struct berval txnid, LDAPControl sctrls, LDAPControl cctrls, int msgidp )); LDAP_F( int ) ldap_txn_end_s LDAP_P(( LDAP ld, int commit, struct berval txnid, LDAPControl sctrl, LDAPControl cctrl, int retidp )); / * in ldap_sync.c / / * initialize the persistent search structure / LDAP_F( ldap_sync_t ) ldap_sync_initialize LDAP_P(( ldap_sync_t ls )); / * destroy the persistent search structure / LDAP_F( void ) ldap_sync_destroy LDAP_P(( ldap_sync_t ls, int freeit )); /* * initialize a refreshOnly sync / LDAP_F( int ) ldap_sync_init LDAP_P(( ldap_sync_t ls, int mode )); /* * initialize a refreshOnly sync / LDAP_F( int ) ldap_sync_init_refresh_only LDAP_P(( ldap_sync_t ls )); /* * initialize a refreshAndPersist sync / LDAP_F( int ) ldap_sync_init_refresh_and_persist LDAP_P(( ldap_sync_t ls )); /* * poll for new responses / LDAP_F( int ) ldap_sync_poll LDAP_P(( ldap_sync_t ls )); #ifdef LDAP_CONTROL_X_SESSION_TRACKING /* * in stctrl.c / LDAP_F( int ) ldap_create_session_tracking_value LDAP_P(( LDAP ld, char sessionSourceIp, char sessionSourceName, char formatOID, struct berval sessionTrackingIdentifier, struct berval value )); LDAP_F( int ) ldap_create_session_tracking_control LDAP_P(( LDAP ld, char sessionSourceIp, char sessionSourceName, char formatOID, struct berval sessionTrackingIdentifier, LDAPControl *ctrlp )); LDAP_F( int ) ldap_parse_session_tracking_control LDAP_P(( LDAP ld, LDAPControl ctrl, struct berval ip, struct berval name, struct berval oid, struct berval id )); #endif / LDAP_CONTROL_X_SESSION_TRACKING / / * in msctrl.c / #ifdef LDAP_CONTROL_X_DIRSYNC LDAP_F( int ) ldap_create_dirsync_value LDAP_P(( LDAP ld, int flags, int maxAttrCount, struct berval cookie, struct berval value )); LDAP_F( int ) ldap_create_dirsync_control LDAP_P(( LDAP ld, int flags, int maxAttrCount, struct berval cookie, LDAPControl *ctrlp )); LDAP_F( int ) ldap_parse_dirsync_control LDAP_P(( LDAP ld, LDAPControl ctrl, int continueFlag, struct berval cookie )); #endif / LDAP_CONTROL_X_DIRSYNC / #ifdef LDAP_CONTROL_X_EXTENDED_DN LDAP_F( int ) ldap_create_extended_dn_value LDAP_P(( LDAP ld, int flag, struct berval value )); LDAP_F( int ) ldap_create_extended_dn_control LDAP_P(( LDAP ld, int flag, LDAPControl *ctrlp )); #endif / LDAP_CONTROL_X_EXTENDED_DN / #ifdef LDAP_CONTROL_X_SHOW_DELETED LDAP_F( int ) ldap_create_show_deleted_control LDAP_P(( LDAP ld, LDAPControl *ctrlp )); #endif / LDAP_CONTROL_X_SHOW_DELETED / #ifdef LDAP_CONTROL_X_SERVER_NOTIFICATION LDAP_F( int ) ldap_create_server_notification_control LDAP_P(( LDAP ld, LDAPControl *ctrlp )); #endif / LDAP_CONTROL_X_SERVER_NOTIFICATION / / * in assertion.c / LDAP_F (int) ldap_create_assertion_control_value LDAP_P(( LDAP ld, char assertion, struct berval value )); LDAP_F( int ) ldap_create_assertion_control LDAP_P(( LDAP ld, char filter, int iscritical, LDAPControl *ctrlp )); / * in deref.c / typedef struct LDAPDerefSpec { char derefAttr; char *attributes; } LDAPDerefSpec; typedef struct LDAPDerefVal { char type; BerVarray vals; struct LDAPDerefVal next; } LDAPDerefVal; typedef struct LDAPDerefRes { char derefAttr; struct berval derefVal; LDAPDerefVal attrVals; struct LDAPDerefRes next; } LDAPDerefRes; LDAP_F( int ) ldap_create_deref_control_value LDAP_P(( LDAP ld, LDAPDerefSpec ds, struct berval value )); LDAP_F( int ) ldap_create_deref_control LDAP_P(( LDAP ld, LDAPDerefSpec ds, int iscritical, LDAPControl ctrlp )); LDAP_F( void ) ldap_derefresponse_free LDAP_P(( LDAPDerefRes dr )); LDAP_F( int ) ldap_parse_derefresponse_control LDAP_P(( LDAP ld, LDAPControl ctrl, LDAPDerefRes *drp )); LDAP_F( int ) ldap_parse_deref_control LDAP_P(( LDAP ld, LDAPControl ctrls, LDAPDerefRes drp )); /* * in psearch.c / LDAP_F( int ) ldap_create_persistentsearch_control_value LDAP_P(( LDAP ld, int changetypes, int changesonly, int return_echg_ctls, struct berval value )); LDAP_F( int ) ldap_create_persistentsearch_control LDAP_P(( LDAP ld, int changetypes, int changesonly, int return_echg_ctls, int isCritical, LDAPControl *ctrlp )); LDAP_F( int ) ldap_parse_entrychange_control LDAP_P(( LDAP ld, LDAPControl ctrl, int chgtypep, struct berval prevdnp, int chgnumpresentp, long chgnump )); / in account_usability.c / LDAP_F( int ) ldap_create_accountusability_control LDAP_P(( LDAP ld, LDAPControl *ctrlp )); typedef struct LDAPAccountUsabilityMoreInfo { ber_int_t inactive; ber_int_t reset; ber_int_t expired; ber_int_t remaining_grace; ber_int_t seconds_before_unlock; } LDAPAccountUsabilityMoreInfo; typedef union LDAPAccountUsability { ber_int_t seconds_remaining; LDAPAccountUsabilityMoreInfo more_info; } LDAPAccountUsability; LDAP_F( int ) ldap_parse_accountusability_control LDAP_P(( LDAP ld, LDAPControl ctrl, int availablep, LDAPAccountUsability usabilityp )); / * high level LDIF to LDAP structure support / #define LDIF_DEFAULT_ADD 0x01 / if changetype missing, assume LDAP_ADD / #define LDIF_ENTRIES_ONLY 0x02 / ignore changetypes other than add / #define LDIF_NO_CONTROLS 0x04 / ignore control specifications / #define LDIF_MODS_ONLY 0x08 / no changetypes, assume LDAP_MODIFY / #define LDIF_NO_DN 0x10 / dn is not present / typedef struct ldifrecord { ber_tag_t lr_op; / type of operation - LDAP_REQ_MODIFY, LDAP_REQ_ADD, etc. / struct berval lr_dn; / DN of operation / LDAPControl lr_ctrls; / controls specified for operation / / some ops such as LDAP_REQ_DELETE require only a DN / / other ops require different data - the ldif_ops union is used to specify the data for each type of operation / union ldif_ops_u { LDAPMod lr_mods; / list of mods for LDAP_REQ_MODIFY, LDAP_REQ_ADD / #define lrop_mods ldif_ops.lr_mods struct ldif_op_rename_s { struct berval lr_newrdn; / LDAP_REQ_MODDN, LDAP_REQ_MODRDN, LDAP_REQ_RENAME / #define lrop_newrdn ldif_ops.ldif_op_rename.lr_newrdn struct berval lr_newsuperior; / LDAP_REQ_MODDN, LDAP_REQ_MODRDN, LDAP_REQ_RENAME / #define lrop_newsup ldif_ops.ldif_op_rename.lr_newsuperior int lr_deleteoldrdn; / LDAP_REQ_MODDN, LDAP_REQ_MODRDN, LDAP_REQ_RENAME / #define lrop_delold ldif_ops.ldif_op_rename.lr_deleteoldrdn } ldif_op_rename; / rename/moddn/modrdn / / the following are for future support / struct ldif_op_ext_s { struct berval lr_extop_oid; / LDAP_REQ_EXTENDED / #define lrop_extop_oid ldif_ops.ldif_op_ext.lr_extop_oid struct berval lr_extop_data; / LDAP_REQ_EXTENDED / #define lrop_extop_data ldif_ops.ldif_op_ext.lr_extop_data } ldif_op_ext; / extended operation / struct ldif_op_cmp_s { struct berval lr_cmp_attr; / LDAP_REQ_COMPARE / #define lrop_cmp_attr ldif_ops.ldif_op_cmp.lr_cmp_attr struct berval lr_cmp_bvalue; / LDAP_REQ_COMPARE / #define lrop_cmp_bval ldif_ops.ldif_op_cmp.lr_cmp_bvalue } ldif_op_cmp; / compare operation / } ldif_ops; / PRIVATE STUFF - DO NOT TOUCH / / for efficiency, the implementation allocates memory / / in large blobs, and makes the above fields point to / / locations inside those blobs - one consequence is that / / you cannot simply free the above allocated fields, nor / / assign them to be owned by another memory context which / / might free them (unless providing your own mem ctx) / / we use the fields below to keep track of those blobs / / so we that we can free them later / void lr_ctx; /* the memory context or NULL / int lr_lines; LDAPMod lr_lm; unsigned char lr_mops; char lr_freeval; struct berval lr_vals; struct berval lr_btype; } LDIFRecord; /* free internal fields - does not free the LDIFRecord / LDAP_F( void ) ldap_ldif_record_done LDAP_P(( LDIFRecord lr )); LDAP_F( int ) ldap_parse_ldif_record LDAP_P(( struct berval rbuf, unsigned long linenum, LDIFRecord lr, const char errstr, unsigned int flags )); LDAP_END_DECL #endif / _LDAP_H */	72.36 KB	2024-05-21 17:19
📄 ldap_cdefs.h /* $OpenLDAP$ / / This work is part of OpenLDAP Software <http://www.openldap.org/>. * * Copyright 1998-2024 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted only as authorized by the OpenLDAP * Public License. * * A copy of this license is available in file LICENSE in the * top-level directory of the distribution or, alternatively, at * <http://www.OpenLDAP.org/license.html>. / / LDAP C Defines / #ifndef _LDAP_CDEFS_H #define _LDAP_CDEFS_H #if defined(__cplusplus) \|\| defined(c_plusplus) # define LDAP_BEGIN_DECL extern "C" { # define LDAP_END_DECL } #else # define LDAP_BEGIN_DECL / begin declarations / # define LDAP_END_DECL / end declarations / #endif #if !defined(LDAP_NO_PROTOTYPES) && ( defined(LDAP_NEEDS_PROTOTYPES) \|\| \ defined(__STDC__) \|\| defined(__cplusplus) \|\| defined(c_plusplus) ) / ANSI C or C++ / # define LDAP_P(protos) protos # define LDAP_CONCAT1(x,y) x ## y # define LDAP_CONCAT(x,y) LDAP_CONCAT1(x,y) # define LDAP_STRING(x) #x / stringify without expanding x / # define LDAP_XSTRING(x) LDAP_STRING(x) / expand x, then stringify / #ifndef LDAP_CONST # define LDAP_CONST const #endif #else / no prototypes / / traditional C / # define LDAP_P(protos) () # define LDAP_CONCAT(x,y) x//y # define LDAP_STRING(x) "x" #ifndef LDAP_CONST # define LDAP_CONST / no const / #endif #endif / no prototypes / #if (__GNUC__) 1000 + (__GNUC_MINOR__) >= 2006 # define LDAP_GCCATTR(attrs) __attribute__(attrs) #else # define LDAP_GCCATTR(attrs) #endif /* * Support for Windows DLLs. * * When external source code includes header files for dynamic libraries, * the external source code is "importing" DLL symbols into its resulting * object code. On Windows, symbols imported from DLLs must be explicitly * indicated in header files with the __declspec(dllimport) directive. * This is not totally necessary for functions because the compiler * (gcc or MSVC) will generate stubs when this directive is absent. * However, this is required for imported variables. * * The LDAP libraries, i.e. liblber and libldap, can be built as * static or shared, based on configuration. Just about all other source * code in OpenLDAP use these libraries. If the LDAP libraries * are configured as shared, 'configure' defines the LDAP_LIBS_DYNAMIC * macro. When other source files include LDAP library headers, the * LDAP library symbols will automatically be marked as imported. When * the actual LDAP libraries are being built, the symbols will not * be marked as imported because the LBER_LIBRARY or LDAP_LIBRARY macros * will be respectively defined. * * Any project outside of OpenLDAP with source code wanting to use * LDAP dynamic libraries should explicitly define LDAP_LIBS_DYNAMIC. * This will ensure that external source code appropriately marks symbols * that will be imported. * * The slapd executable, itself, can be used as a dynamic library. * For example, if a backend module is compiled as shared, it will * import symbols from slapd. When this happens, the slapd symbols * must be marked as imported in header files that the backend module * includes. Remember that slapd links with various static libraries. * If the LDAP libraries were configured as static, their object * code is also part of the monolithic slapd executable. Thus, when * a backend module imports symbols from slapd, it imports symbols from * all of the static libraries in slapd as well. Thus, the SLAP_IMPORT * macro, when defined, will appropriately mark symbols as imported. * This macro should be used by shared backend modules as well as any * other external source code that imports symbols from the slapd * executable as if it were a DLL. * * Note that we don't actually have to worry about using the * __declspec(dllexport) directive anywhere. This is because both * MSVC and Mingw provide alternate (more effective) methods for exporting * symbols out of binaries, i.e. the use of a DEF file. * * NOTE ABOUT BACKENDS: Backends can be configured as static or dynamic. * When a backend is configured as dynamic, slapd will load the backend * explicitly and populate function pointer structures by calling * the backend's well-known initialization function. Because of this * procedure, slapd never implicitly imports symbols from dynamic backends. * This makes it unnecessary to tag various backend functions with the * __declspec(dllimport) directive. This is because neither slapd nor * any other external binary should ever be implicitly loading a backend * dynamic module. * * Backends are supposed to be self-contained. However, it appears that * back-meta DOES implicitly import symbols from back-ldap. This means * that the __declspec(dllimport) directive should be marked on back-ldap * functions (in its header files) if and only if we're compiling for * windows AND back-ldap has been configured as dynamic AND back-meta * is the client of back-ldap. When client is slapd, there is no effect * since slapd does not implicitly import symbols. * * TODO(?): Currently, back-meta nor back-ldap is supported for Mingw32. * Thus, there's no need to worry about this right now. This is something that * may or may not have to be addressed in the future. / / LBER library / #if defined(_WIN32) && \ ((defined(LDAP_LIBS_DYNAMIC) && !defined(LBER_LIBRARY)) \|\| \ (!defined(LDAP_LIBS_DYNAMIC) && defined(SLAPD_IMPORT))) # define LBER_F(type) extern __declspec(dllimport) type # define LBER_V(type) extern __declspec(dllimport) type #else # define LBER_F(type) extern type # define LBER_V(type) extern type #endif / LDAP library / #if defined(_WIN32) && \ ((defined(LDAP_LIBS_DYNAMIC) && !defined(LDAP_LIBRARY)) \|\| \ (!defined(LDAP_LIBS_DYNAMIC) && defined(SLAPD_IMPORT))) # define LDAP_F(type) extern __declspec(dllimport) type # define LDAP_V(type) extern __declspec(dllimport) type #else # define LDAP_F(type) extern type # define LDAP_V(type) extern type #endif / AVL library / #if defined(_WIN32) && defined(SLAPD_IMPORT) # define LDAP_AVL_F(type) extern __declspec(dllimport) type # define LDAP_AVL_V(type) extern __declspec(dllimport) type #else # define LDAP_AVL_F(type) extern type # define LDAP_AVL_V(type) extern type #endif / LDIF library / #if defined(_WIN32) && defined(SLAPD_IMPORT) # define LDAP_LDIF_F(type) extern __declspec(dllimport) type # define LDAP_LDIF_V(type) extern __declspec(dllimport) type #else # define LDAP_LDIF_F(type) extern type # define LDAP_LDIF_V(type) extern type #endif / LUNICODE library / #if defined(_WIN32) && defined(SLAPD_IMPORT) # define LDAP_LUNICODE_F(type) extern __declspec(dllimport) type # define LDAP_LUNICODE_V(type) extern __declspec(dllimport) type #else # define LDAP_LUNICODE_F(type) extern type # define LDAP_LUNICODE_V(type) extern type #endif / LUTIL library / #if defined(_WIN32) && defined(SLAPD_IMPORT) # define LDAP_LUTIL_F(type) extern __declspec(dllimport) type # define LDAP_LUTIL_V(type) extern __declspec(dllimport) type #else # define LDAP_LUTIL_F(type) extern type # define LDAP_LUTIL_V(type) extern type #endif / REWRITE library / #if defined(_WIN32) && defined(SLAPD_IMPORT) # define LDAP_REWRITE_F(type) extern __declspec(dllimport) type # define LDAP_REWRITE_V(type) extern __declspec(dllimport) type #else # define LDAP_REWRITE_F(type) extern type # define LDAP_REWRITE_V(type) extern type #endif / SLAPD (as a dynamic library exporting symbols) / #if defined(_WIN32) && defined(SLAPD_IMPORT) # define LDAP_SLAPD_F(type) extern __declspec(dllimport) type # define LDAP_SLAPD_V(type) extern __declspec(dllimport) type #else # define LDAP_SLAPD_F(type) extern type # define LDAP_SLAPD_V(type) extern type #endif / SLAPD (as a dynamic library exporting symbols) / #if defined(_WIN32) && defined(SLAPD_IMPORT) # define LDAP_SLAPI_F(type) extern __declspec(dllimport) type # define LDAP_SLAPI_V(type) extern __declspec(dllimport) type #else # define LDAP_SLAPI_F(type) extern type # define LDAP_SLAPI_V(type) extern type #endif / SLAPD (as a dynamic library exporting symbols) / #if defined(_WIN32) && defined(SLAPD_IMPORT) # define SLAPI_F(type) extern __declspec(dllimport) type # define SLAPI_V(type) extern __declspec(dllimport) type #else # define SLAPI_F(type) extern type # define SLAPI_V(type) extern type #endif / * C library. Mingw32 links with the dynamic C run-time library by default, * so the explicit definition of CSTATIC will keep dllimport from * being defined, if desired. * * MSVC defines the _DLL macro when the compiler is invoked with /MD or /MDd, * which means the resulting object code will be linked with the dynamic * C run-time library. * * Technically, it shouldn't be necessary to redefine any functions that * the headers for the C library should already contain. Nevertheless, this * is here as a safe-guard. * * TODO: Determine if these macros ever get expanded for Windows. If not, * the declspec expansion can probably be removed. / #if (defined(__MINGW32__) && !defined(CSTATIC)) \|\| \ (defined(_MSC_VER) && defined(_DLL)) # define LDAP_LIBC_F(type) extern __declspec(dllimport) type # define LDAP_LIBC_V(type) extern __declspec(dllimport) type #else # define LDAP_LIBC_F(type) extern type # define LDAP_LIBC_V(type) extern type #endif #endif / _LDAP_CDEFS_H */	9.24 KB	2024-05-21 17:19
📄 ldap_features.h /* include/ldap_features.h. Generated from ldap_features.hin by configure. / / $OpenLDAP$ / / This work is part of OpenLDAP Software <http://www.openldap.org/>. * * Copyright 1998-2024 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted only as authorized by the OpenLDAP * Public License. * * A copy of this license is available in file LICENSE in the * top-level directory of the distribution or, alternatively, at * <http://www.OpenLDAP.org/license.html>. / / * LDAP Features / #ifndef _LDAP_FEATURES_H #define _LDAP_FEATURES_H 1 / OpenLDAP API version macros / #define LDAP_VENDOR_VERSION 20608 #define LDAP_VENDOR_VERSION_MAJOR 2 #define LDAP_VENDOR_VERSION_MINOR 6 #define LDAP_VENDOR_VERSION_PATCH 8 / WORK IN PROGRESS! OpenLDAP reentrancy/thread-safeness should be dynamically checked using ldap_get_option(). If built with thread support, the -lldap implementation is: LDAP_API_FEATURE_THREAD_SAFE (basic thread safety) LDAP_API_FEATURE_SESSION_THREAD_SAFE LDAP_API_FEATURE_OPERATION_THREAD_SAFE The preprocessor flag LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE can be used to determine if -lldap is thread safe at compile time. / / is -lldap reentrant or not / #define LDAP_API_FEATURE_X_OPENLDAP_REENTRANT 1 / is -lldap thread safe or not / #define LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE 1 / LDAP v2 Referrals / / #undef LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS / #endif / LDAP_FEATURES */	1.55 KB	2025-03-13 12:28
📄 ldap_schema.h /* $OpenLDAP$ / / This work is part of OpenLDAP Software <http://www.openldap.org/>. * * Copyright 1998-2024 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted only as authorized by the OpenLDAP * Public License. * * A copy of this license is available in file LICENSE in the * top-level directory of the distribution or, alternatively, at * <http://www.OpenLDAP.org/license.html>. / / ldap-schema.h - Header for basic schema handling functions that can be * used by both clients and servers. * these routines should be renamed ldap_x_... / #ifndef _LDAP_SCHEMA_H #define _LDAP_SCHEMA_H 1 #include <ldap_cdefs.h> LDAP_BEGIN_DECL / Codes for parsing errors / #define LDAP_SCHERR_OUTOFMEM 1 #define LDAP_SCHERR_UNEXPTOKEN 2 #define LDAP_SCHERR_NOLEFTPAREN 3 #define LDAP_SCHERR_NORIGHTPAREN 4 #define LDAP_SCHERR_NODIGIT 5 #define LDAP_SCHERR_BADNAME 6 #define LDAP_SCHERR_BADDESC 7 #define LDAP_SCHERR_BADSUP 8 #define LDAP_SCHERR_DUPOPT 9 #define LDAP_SCHERR_EMPTY 10 #define LDAP_SCHERR_MISSING 11 #define LDAP_SCHERR_OUT_OF_ORDER 12 typedef struct ldap_schema_extension_item { char lsei_name; char *lsei_values; } LDAPSchemaExtensionItem; typedef struct ldap_syntax { char syn_oid; /* REQUIRED / char syn_names; / OPTIONAL / char syn_desc; /* OPTIONAL / LDAPSchemaExtensionItem syn_extensions; / OPTIONAL / } LDAPSyntax; typedef struct ldap_matchingrule { char mr_oid; /* REQUIRED / char mr_names; / OPTIONAL / char mr_desc; /* OPTIONAL / int mr_obsolete; / OPTIONAL / char mr_syntax_oid; /* REQUIRED / LDAPSchemaExtensionItem mr_extensions; / OPTIONAL / } LDAPMatchingRule; typedef struct ldap_matchingruleuse { char mru_oid; /* REQUIRED / char mru_names; / OPTIONAL / char mru_desc; /* OPTIONAL / int mru_obsolete; / OPTIONAL / char mru_applies_oids; / REQUIRED / LDAPSchemaExtensionItem mru_extensions; / OPTIONAL / } LDAPMatchingRuleUse; typedef struct ldap_attributetype { char at_oid; /* REQUIRED / char at_names; / OPTIONAL / char at_desc; /* OPTIONAL / int at_obsolete; / 0=no, 1=yes / char at_sup_oid; /* OPTIONAL / char at_equality_oid; /* OPTIONAL / char at_ordering_oid; /* OPTIONAL / char at_substr_oid; /* OPTIONAL / char at_syntax_oid; /* OPTIONAL / int at_syntax_len; / OPTIONAL / int at_single_value; / 0=no, 1=yes / int at_collective; / 0=no, 1=yes / int at_no_user_mod; / 0=no, 1=yes / int at_usage; / 0=userApplications, 1=directoryOperation, 2=distributedOperation, 3=dSAOperation / LDAPSchemaExtensionItem at_extensions; / OPTIONAL / } LDAPAttributeType; typedef struct ldap_objectclass { char oc_oid; /* REQUIRED / char oc_names; / OPTIONAL / char oc_desc; /* OPTIONAL / int oc_obsolete; / 0=no, 1=yes / char oc_sup_oids; / OPTIONAL / int oc_kind; / 0=ABSTRACT, 1=STRUCTURAL, 2=AUXILIARY / char oc_at_oids_must; / OPTIONAL / char oc_at_oids_may; / OPTIONAL / LDAPSchemaExtensionItem oc_extensions; / OPTIONAL / } LDAPObjectClass; typedef struct ldap_contentrule { char cr_oid; /* REQUIRED / char cr_names; / OPTIONAL / char cr_desc; /* OPTIONAL / char cr_sup_oids; / OPTIONAL / int cr_obsolete; / 0=no, 1=yes / char cr_oc_oids_aux; / OPTIONAL / char cr_at_oids_must; / OPTIONAL / char cr_at_oids_may; / OPTIONAL / char cr_at_oids_not; / OPTIONAL / LDAPSchemaExtensionItem cr_extensions; / OPTIONAL / } LDAPContentRule; typedef struct ldap_nameform { char nf_oid; /* REQUIRED / char nf_names; / OPTIONAL / char nf_desc; /* OPTIONAL / int nf_obsolete; / 0=no, 1=yes / char nf_objectclass; /* REQUIRED / char nf_at_oids_must; / REQUIRED / char nf_at_oids_may; / OPTIONAL / LDAPSchemaExtensionItem nf_extensions; / OPTIONAL / } LDAPNameForm; typedef struct ldap_structurerule { int sr_ruleid; / REQUIRED / char sr_names; / OPTIONAL / char sr_desc; /* OPTIONAL / int sr_obsolete; / 0=no, 1=yes / char sr_nameform; /* REQUIRED / int sr_nsup_ruleids;/ number of sr_sup_ruleids / int sr_sup_ruleids;/* OPTIONAL / LDAPSchemaExtensionItem sr_extensions; / OPTIONAL / } LDAPStructureRule; / * Misc macros / #define LDAP_SCHEMA_NO 0 #define LDAP_SCHEMA_YES 1 #define LDAP_SCHEMA_USER_APPLICATIONS 0 #define LDAP_SCHEMA_DIRECTORY_OPERATION 1 #define LDAP_SCHEMA_DISTRIBUTED_OPERATION 2 #define LDAP_SCHEMA_DSA_OPERATION 3 #define LDAP_SCHEMA_ABSTRACT 0 #define LDAP_SCHEMA_STRUCTURAL 1 #define LDAP_SCHEMA_AUXILIARY 2 / * Flags that control how liberal the parsing routines are. / #define LDAP_SCHEMA_ALLOW_NONE 0x00U / Strict parsing / #define LDAP_SCHEMA_ALLOW_NO_OID 0x01U / Allow missing oid / #define LDAP_SCHEMA_ALLOW_QUOTED 0x02U / Allow bogus extra quotes / #define LDAP_SCHEMA_ALLOW_DESCR 0x04U / Allow descr instead of OID / #define LDAP_SCHEMA_ALLOW_DESCR_PREFIX 0x08U / Allow descr as OID prefix / #define LDAP_SCHEMA_ALLOW_OID_MACRO 0x10U / Allow OID macros in slapd / #define LDAP_SCHEMA_ALLOW_OUT_OF_ORDER_FIELDS 0x20U / Allow fields in most any order / #define LDAP_SCHEMA_ALLOW_ALL 0x3fU / Be very liberal in parsing / #define LDAP_SCHEMA_SKIP 0x80U / Don't malloc any result / LDAP_F( LDAP_CONST char ) ldap_syntax2name LDAP_P(( LDAPSyntax * syn )); LDAP_F( LDAP_CONST char * ) ldap_matchingrule2name LDAP_P(( LDAPMatchingRule * mr )); LDAP_F( LDAP_CONST char * ) ldap_matchingruleuse2name LDAP_P(( LDAPMatchingRuleUse * mru )); LDAP_F( LDAP_CONST char * ) ldap_attributetype2name LDAP_P(( LDAPAttributeType * at )); LDAP_F( LDAP_CONST char * ) ldap_objectclass2name LDAP_P(( LDAPObjectClass * oc )); LDAP_F( LDAP_CONST char * ) ldap_contentrule2name LDAP_P(( LDAPContentRule * cr )); LDAP_F( LDAP_CONST char * ) ldap_nameform2name LDAP_P(( LDAPNameForm * nf )); LDAP_F( LDAP_CONST char * ) ldap_structurerule2name LDAP_P(( LDAPStructureRule * sr )); LDAP_F( void ) ldap_syntax_free LDAP_P(( LDAPSyntax * syn )); LDAP_F( void ) ldap_matchingrule_free LDAP_P(( LDAPMatchingRule * mr )); LDAP_F( void ) ldap_matchingruleuse_free LDAP_P(( LDAPMatchingRuleUse * mr )); LDAP_F( void ) ldap_attributetype_free LDAP_P(( LDAPAttributeType * at )); LDAP_F( void ) ldap_objectclass_free LDAP_P(( LDAPObjectClass * oc )); LDAP_F( void ) ldap_contentrule_free LDAP_P(( LDAPContentRule * cr )); LDAP_F( void ) ldap_nameform_free LDAP_P(( LDAPNameForm * nf )); LDAP_F( void ) ldap_structurerule_free LDAP_P(( LDAPStructureRule * sr )); LDAP_F( LDAPStructureRule * ) ldap_str2structurerule LDAP_P(( LDAP_CONST char * s, int * code, LDAP_CONST char ** errp, LDAP_CONST unsigned flags )); LDAP_F( LDAPNameForm * ) ldap_str2nameform LDAP_P(( LDAP_CONST char * s, int * code, LDAP_CONST char ** errp, LDAP_CONST unsigned flags )); LDAP_F( LDAPContentRule * ) ldap_str2contentrule LDAP_P(( LDAP_CONST char * s, int * code, LDAP_CONST char ** errp, LDAP_CONST unsigned flags )); LDAP_F( LDAPObjectClass * ) ldap_str2objectclass LDAP_P(( LDAP_CONST char * s, int * code, LDAP_CONST char ** errp, LDAP_CONST unsigned flags )); LDAP_F( LDAPAttributeType * ) ldap_str2attributetype LDAP_P(( LDAP_CONST char * s, int * code, LDAP_CONST char ** errp, LDAP_CONST unsigned flags )); LDAP_F( LDAPSyntax * ) ldap_str2syntax LDAP_P(( LDAP_CONST char * s, int * code, LDAP_CONST char ** errp, LDAP_CONST unsigned flags )); LDAP_F( LDAPMatchingRule * ) ldap_str2matchingrule LDAP_P(( LDAP_CONST char * s, int * code, LDAP_CONST char ** errp, LDAP_CONST unsigned flags )); LDAP_F( LDAPMatchingRuleUse * ) ldap_str2matchingruleuse LDAP_P(( LDAP_CONST char * s, int * code, LDAP_CONST char ** errp, LDAP_CONST unsigned flags )); LDAP_F( char * ) ldap_structurerule2str LDAP_P(( LDAPStructureRule * sr )); LDAP_F( struct berval * ) ldap_structurerule2bv LDAP_P(( LDAPStructureRule * sr, struct berval bv )); LDAP_F( char ) ldap_nameform2str LDAP_P(( LDAPNameForm * nf )); LDAP_F( struct berval * ) ldap_nameform2bv LDAP_P(( LDAPNameForm * nf, struct berval bv )); LDAP_F( char ) ldap_contentrule2str LDAP_P(( LDAPContentRule * cr )); LDAP_F( struct berval * ) ldap_contentrule2bv LDAP_P(( LDAPContentRule * cr, struct berval bv )); LDAP_F( char ) ldap_objectclass2str LDAP_P(( LDAPObjectClass * oc )); LDAP_F( struct berval * ) ldap_objectclass2bv LDAP_P(( LDAPObjectClass * oc, struct berval bv )); LDAP_F( char ) ldap_attributetype2str LDAP_P(( LDAPAttributeType * at )); LDAP_F( struct berval * ) ldap_attributetype2bv LDAP_P(( LDAPAttributeType * at, struct berval bv )); LDAP_F( char ) ldap_syntax2str LDAP_P(( LDAPSyntax * syn )); LDAP_F( struct berval * ) ldap_syntax2bv LDAP_P(( LDAPSyntax * syn, struct berval bv )); LDAP_F( char ) ldap_matchingrule2str LDAP_P(( LDAPMatchingRule * mr )); LDAP_F( struct berval * ) ldap_matchingrule2bv LDAP_P(( LDAPMatchingRule * mr, struct berval bv )); LDAP_F( char ) ldap_matchingruleuse2str LDAP_P(( LDAPMatchingRuleUse * mru )); LDAP_F( struct berval * ) ldap_matchingruleuse2bv LDAP_P(( LDAPMatchingRuleUse * mru, struct berval bv )); LDAP_F( char ) ldap_scherr2str LDAP_P(( int code )) LDAP_GCCATTR((const)); LDAP_END_DECL #endif	9.23 KB	2024-05-21 17:19
📄 ldap_utf8.h /* $OpenLDAP$ / / This work is part of OpenLDAP Software <http://www.openldap.org/>. * * Copyright 1998-2024 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted only as authorized by the OpenLDAP * Public License. * * A copy of this license is available in file LICENSE in the * top-level directory of the distribution or, alternatively, at * <http://www.OpenLDAP.org/license.html>. / / This notice applies to changes, created by or for Novell, Inc., * to preexisting works for which notices appear elsewhere in this file. * * Copyright (C) 2000 Novell, Inc. All Rights Reserved. * * THIS WORK IS SUBJECT TO U.S. AND INTERNATIONAL COPYRIGHT LAWS AND TREATIES. * USE, MODIFICATION, AND REDISTRIBUTION OF THIS WORK IS SUBJECT TO VERSION * 2.0.1 OF THE OPENLDAP PUBLIC LICENSE, A COPY OF WHICH IS AVAILABLE AT * HTTP://WWW.OPENLDAP.ORG/LICENSE.HTML OR IN THE FILE "LICENSE" IN THE * TOP-LEVEL DIRECTORY OF THE DISTRIBUTION. ANY USE OR EXPLOITATION OF THIS * WORK OTHER THAN AS AUTHORIZED IN VERSION 2.0.1 OF THE OPENLDAP PUBLIC * LICENSE, OR OTHER PRIOR WRITTEN CONSENT FROM NOVELL, COULD SUBJECT THE * PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY. / / Note: A verbatim copy of version 2.0.1 of the OpenLDAP Public License * can be found in the file "build/LICENSE-2.0.1" in this distribution * of OpenLDAP Software. / #ifndef _LDAP_UTF8_H #define _LDAP_UTF8_H #include <lber_types.h> / get ber__t / /* * UTF-8 Utility Routines / LDAP_BEGIN_DECL #define LDAP_UCS4_INVALID (0x80000000U) typedef ber_int_t ldap_ucs4_t; / LDAP_MAX_UTF8_LEN is 3 or 6 depending on size of wchar_t / #define LDAP_MAX_UTF8_LEN ( sizeof(wchar_t) 3/2 ) /* Unicode conversion routines / LDAP_F( ldap_ucs4_t ) ldap_x_utf8_to_ucs4( LDAP_CONST char p ); LDAP_F( int ) ldap_x_ucs4_to_utf8( ldap_ucs4_t c, char buf ); / * Wide Char / UTF-8 Conversion Routines / / UTF-8 character to Wide Char / LDAP_F(int) ldap_x_utf8_to_wc LDAP_P(( wchar_t wchar, LDAP_CONST char utf8char )); / UTF-8 string to Wide Char string / LDAP_F(int) ldap_x_utf8s_to_wcs LDAP_P(( wchar_t wcstr, LDAP_CONST char utf8str, size_t count )); / Wide Char to UTF-8 character / LDAP_F(int) ldap_x_wc_to_utf8 LDAP_P(( char utf8char, wchar_t wchar, size_t count )); /* Wide Char string to UTF-8 string / LDAP_F(int) ldap_x_wcs_to_utf8s LDAP_P(( char utf8str, LDAP_CONST wchar_t wcstr, size_t count )); / * MultiByte Char / UTF-8 Conversion Routines / / UTF-8 character to MultiByte character / LDAP_F(int) ldap_x_utf8_to_mb LDAP_P(( char mbchar, LDAP_CONST char utf8char, int (ldap_f_wctomb)( char mbchar, wchar_t wchar ))); / UTF-8 string to MultiByte string / LDAP_F(int) ldap_x_utf8s_to_mbs LDAP_P(( char mbstr, LDAP_CONST char utf8str, size_t count, size_t (ldap_f_wcstombs)( char mbstr, LDAP_CONST wchar_t wcstr, size_t count) )); /* MultiByte character to UTF-8 character / LDAP_F(int) ldap_x_mb_to_utf8 LDAP_P(( char utf8char, LDAP_CONST char mbchar, size_t mbsize, int (ldap_f_mbtowc)( wchar_t wchar, LDAP_CONST char mbchar, size_t count) )); /* MultiByte string to UTF-8 string / LDAP_F(int) ldap_x_mbs_to_utf8s LDAP_P(( char utf8str, LDAP_CONST char mbstr, size_t count, size_t (ldap_f_mbstowcs)( wchar_t wcstr, LDAP_CONST char mbstr, size_t count) )); LDAP_END_DECL #endif /* _LDAP_UTF8_H */	3.39 KB	2024-05-21 17:19
📄 ldif.h /* $OpenLDAP$ / / This work is part of OpenLDAP Software <http://www.openldap.org/>. * * Copyright 1998-2024 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted only as authorized by the OpenLDAP * Public License. * * A copy of this license is available in file LICENSE in the * top-level directory of the distribution or, alternatively, at * <http://www.OpenLDAP.org/license.html>. / / Portions Copyright (c) 1996 Regents of the University of Michigan. * All rights reserved. * * Redistribution and use in source and binary forms are permitted * provided that this notice is preserved and that due credit is given * to the University of Michigan at Ann Arbor. The name of the University * may not be used to endorse or promote products derived from this * software without specific prior written permission. This software * is provided ``as is'' without express or implied warranty. / #ifndef _LDIF_H #define _LDIF_H #include <ldap_cdefs.h> LDAP_BEGIN_DECL / This is NOT a bogus extern declaration (unlike ldap_debug) / LDAP_LDIF_V (int) ldif_debug; #define LDIF_LINE_WIDTH 78 / default maximum length of LDIF lines / #define LDIF_LINE_WIDTH_MAX ((ber_len_t)-1) / maximum length of LDIF lines / #define LDIF_LINE_WIDTH_WRAP(wrap) ((wrap) == 0 ? LDIF_LINE_WIDTH : (wrap)) / * Macro to calculate maximum number of bytes that the base64 equivalent * of an item that is "len" bytes long will take up. Base64 encoding * uses one byte for every six bits in the value plus up to two pad bytes. / #define LDIF_BASE64_LEN(len) (((len) 4 / 3 ) + 3) /* * Macro to calculate maximum size that an LDIF-encoded type (length * tlen) and value (length vlen) will take up: room for type + ":: " + * first newline + base64 value + continued lines. Each continued line * needs room for a newline and a leading space character. / #define LDIF_SIZE_NEEDED(nlen,vlen) LDIF_SIZE_NEEDED_WRAP(nlen, vlen, 0) #define LDIF_SIZE_NEEDED_WRAP(nlen,vlen,wrap) \ ((nlen) + 4 + LDIF_BASE64_LEN(vlen) \ + ((wrap) == 0 ? ((LDIF_BASE64_LEN(vlen) + (nlen) + 3) / ( LDIF_LINE_WIDTH-1 ) 2 ) : \ ((wrap) == LDIF_LINE_WIDTH_MAX ? 0 : ((LDIF_BASE64_LEN(vlen) + (nlen) + 3) / (wrap-1) * 2 )))) LDAP_LDIF_F( int ) ldif_parse_line LDAP_P(( LDAP_CONST char line, char name, char value, ber_len_t vlen )); LDAP_LDIF_F( int ) ldif_parse_line2 LDAP_P(( char line, struct berval type, struct berval value, int freeval )); LDAP_LDIF_F( FILE * ) ldif_open_url LDAP_P(( LDAP_CONST char urlstr )); LDAP_LDIF_F( int ) ldif_fetch_url LDAP_P(( LDAP_CONST char line, char *value, ber_len_t vlen )); LDAP_LDIF_F( char * ) ldif_getline LDAP_P(( char *next )); LDAP_LDIF_F( int ) ldif_countlines LDAP_P(( LDAP_CONST char line )); /* ldif_ropen, rclose, read_record - just for reading LDIF files, * no special open/close needed to write LDIF files. / typedef struct LDIFFP { FILE fp; struct LDIFFP prev; } LDIFFP; LDAP_LDIF_F( LDIFFP ) ldif_open LDAP_P(( LDAP_CONST char file, LDAP_CONST char mode )); /* ldif_open equivalent that opens ldif stream in memory rather than from file / LDAP_LDIF_F( LDIFFP ) ldif_open_mem LDAP_P(( char ldif, size_t size, LDAP_CONST char mode )); LDAP_LDIF_F( void ) ldif_close LDAP_P(( LDIFFP * )); LDAP_LDIF_F( int ) ldif_read_record LDAP_P(( LDIFFP fp, unsigned long lineno, char *bufp, int buflen )); LDAP_LDIF_F( int ) ldif_must_b64_encode_register LDAP_P(( LDAP_CONST char name, LDAP_CONST char oid )); LDAP_LDIF_F( void ) ldif_must_b64_encode_release LDAP_P(( void )); #define LDIF_PUT_NOVALUE 0x0000 /* no value / #define LDIF_PUT_VALUE 0x0001 / value w/ auto detection / #define LDIF_PUT_TEXT 0x0002 / assume text / #define LDIF_PUT_BINARY 0x0004 / assume binary (convert to base64) / #define LDIF_PUT_B64 0x0008 / pre-converted base64 value / #define LDIF_PUT_COMMENT 0x0010 / comment / #define LDIF_PUT_URL 0x0020 / url / #define LDIF_PUT_SEP 0x0040 / separator / LDAP_LDIF_F( void ) ldif_sput LDAP_P(( char out, int type, LDAP_CONST char name, LDAP_CONST char val, ber_len_t vlen )); LDAP_LDIF_F( void ) ldif_sput_wrap LDAP_P(( char out, int type, LDAP_CONST char name, LDAP_CONST char val, ber_len_t vlen, ber_len_t wrap )); LDAP_LDIF_F( char ) ldif_put LDAP_P(( int type, LDAP_CONST char name, LDAP_CONST char val, ber_len_t vlen )); LDAP_LDIF_F( char * ) ldif_put_wrap LDAP_P(( int type, LDAP_CONST char name, LDAP_CONST char val, ber_len_t vlen, ber_len_t wrap )); LDAP_LDIF_F( int ) ldif_is_not_printable LDAP_P(( LDAP_CONST char val, ber_len_t vlen )); LDAP_END_DECL #endif / _LDIF_H */	4.68 KB	2024-05-21 17:19
📄 libelf.h /* Interface for libelf. Copyright (C) 1998-2010, 2015 Red Hat, Inc. This file is part of elfutils. This file is free software; you can redistribute it and/or modify it under the terms of either * the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version or * the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version or both in parallel, as here. elfutils is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received copies of the GNU General Public License and the GNU Lesser General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. / #ifndef _LIBELF_H #define _LIBELF_H 1 #include <stdint.h> #include <sys/types.h> / Get the ELF types. / #include <elf.h> #ifndef SHF_COMPRESSED / Older glibc elf.h might not yet define the ELF compression types. / #define SHF_COMPRESSED (1 << 11) / Section with compressed data. / / Section compression header. Used when SHF_COMPRESSED is set. / typedef struct { Elf32_Word ch_type; / Compression format. / Elf32_Word ch_size; / Uncompressed data size. / Elf32_Word ch_addralign; / Uncompressed data alignment. / } Elf32_Chdr; typedef struct { Elf64_Word ch_type; / Compression format. / Elf64_Word ch_reserved; Elf64_Xword ch_size; / Uncompressed data size. / Elf64_Xword ch_addralign; / Uncompressed data alignment. / } Elf64_Chdr; / Legal values for ch_type (compression algorithm). / #define ELFCOMPRESS_ZLIB 1 / ZLIB/DEFLATE algorithm. / #define ELFCOMPRESS_LOOS 0x60000000 / Start of OS-specific. / #define ELFCOMPRESS_HIOS 0x6fffffff / End of OS-specific. / #define ELFCOMPRESS_LOPROC 0x70000000 / Start of processor-specific. / #define ELFCOMPRESS_HIPROC 0x7fffffff / End of processor-specific. / #endif #ifndef ELFCOMPRESS_ZSTD / So ZSTD compression can be used even with an old system elf.h. / #define ELFCOMPRESS_ZSTD 2 / Zstandard algorithm. / #endif #ifndef SHT_RELR / So RELR defines/typedefs can be used even with an old system elf.h. / #define SHT_RELR 19 / RELR relative relocations / / RELR relocation table entry / typedef Elf32_Word Elf32_Relr; typedef Elf64_Xword Elf64_Relr; #define DT_RELRSZ 35 / Total size of RELR relative relocations / #define DT_RELR 36 / Address of RELR relative relocations / #define DT_RELRENT 37 / Size of one RELR relative relocaction / #endif #if __GNUC__ > 3 \|\| (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) # define __nonnull_attribute__(...) __attribute__ ((__nonnull__ (__VA_ARGS__))) # define __deprecated_attribute__ __attribute__ ((__deprecated__)) # define __pure_attribute__ __attribute__ ((__pure__)) # define __const_attribute__ __attribute__ ((__const__)) #else # define __nonnull_attribute__(...) # define __deprecated_attribute__ # define __pure_attribute__ # define __const_attribute__ #endif #if __GNUC__ < 4 #define __noreturn_attribute__ #else #define __noreturn_attribute__ __attribute__ ((noreturn)) #endif #ifdef __GNUC_STDC_INLINE__ # define __libdw_extern_inline extern __inline __attribute__ ((__gnu_inline__)) #else # define __libdw_extern_inline extern __inline #endif / Known translation types. / typedef enum { ELF_T_BYTE, / unsigned char / ELF_T_ADDR, / Elf32_Addr, Elf64_Addr, ... / ELF_T_DYN, / Dynamic section record. / ELF_T_EHDR, / ELF header. / ELF_T_HALF, / Elf32_Half, Elf64_Half, ... / ELF_T_OFF, / Elf32_Off, Elf64_Off, ... / ELF_T_PHDR, / Program header. / ELF_T_RELA, / Relocation entry with addend. / ELF_T_REL, / Relocation entry. / ELF_T_SHDR, / Section header. / ELF_T_SWORD, / Elf32_Sword, Elf64_Sword, ... / ELF_T_SYM, / Symbol record. / ELF_T_WORD, / Elf32_Word, Elf64_Word, ... / ELF_T_XWORD, / Elf32_Xword, Elf64_Xword, ... / ELF_T_SXWORD, / Elf32_Sxword, Elf64_Sxword, ... / ELF_T_VDEF, / Elf32_Verdef, Elf64_Verdef, ... / ELF_T_VDAUX, / Elf32_Verdaux, Elf64_Verdaux, ... / ELF_T_VNEED, / Elf32_Verneed, Elf64_Verneed, ... / ELF_T_VNAUX, / Elf32_Vernaux, Elf64_Vernaux, ... / ELF_T_NHDR, / Elf32_Nhdr, Elf64_Nhdr, ... / ELF_T_SYMINFO, / Elf32_Syminfo, Elf64_Syminfo, ... / ELF_T_MOVE, / Elf32_Move, Elf64_Move, ... / ELF_T_LIB, / Elf32_Lib, Elf64_Lib, ... / ELF_T_GNUHASH, / GNU-style hash section. / ELF_T_AUXV, / Elf32_auxv_t, Elf64_auxv_t, ... / ELF_T_CHDR, / Compressed, Elf32_Chdr, Elf64_Chdr, ... / ELF_T_NHDR8, / Special GNU Properties note. Same as Nhdr, except padding. / ELF_T_RELR, / Relative relocation entry. / / Keep this the last entry. / ELF_T_NUM } Elf_Type; / Descriptor for data to be converted to or from memory format. / typedef struct { void d_buf; /* Pointer to the actual data. / Elf_Type d_type; / Type of this piece of data. / unsigned int d_version; / ELF version. / size_t d_size; / Size in bytes. / int64_t d_off; / Offset into section. / size_t d_align; / Alignment in section. / } Elf_Data; / Commands for `...'. / typedef enum { ELF_C_NULL, / Nothing, terminate, or compute only. / ELF_C_READ, / Read .. / ELF_C_RDWR, / Read and write .. / ELF_C_WRITE, / Write .. / ELF_C_CLR, / Clear flag. / ELF_C_SET, / Set flag. / ELF_C_FDDONE, / Signal that file descriptor will not be used anymore. / ELF_C_FDREAD, / Read rest of data so that file descriptor is not used anymore. / / The following are extensions. / ELF_C_READ_MMAP, / Read, but mmap the file if possible. / ELF_C_RDWR_MMAP, / Read and write, with mmap. / ELF_C_WRITE_MMAP, / Write, with mmap. / ELF_C_READ_MMAP_PRIVATE, / Read, but memory is writable, results are not written to the file. / ELF_C_EMPTY, / Copy basic file data but not the content. / / Keep this the last entry. / ELF_C_NUM } Elf_Cmd; / Flags for the ELF structures. / enum { ELF_F_DIRTY = 0x1, #define ELF_F_DIRTY ELF_F_DIRTY ELF_F_LAYOUT = 0x4, #define ELF_F_LAYOUT ELF_F_LAYOUT ELF_F_PERMISSIVE = 0x8 #define ELF_F_PERMISSIVE ELF_F_PERMISSIVE }; / Flags for elf_compress[_gnu]. / enum { ELF_CHF_FORCE = 0x1 #define ELF_CHF_FORCE ELF_CHF_FORCE }; / Identification values for recognized object files. / typedef enum { ELF_K_NONE, / Unknown. / ELF_K_AR, / Archive. / ELF_K_COFF, / Stupid old COFF. / ELF_K_ELF, / ELF file. / / Keep this the last entry. / ELF_K_NUM } Elf_Kind; / Archive member header. / typedef struct { char ar_name; /* Name of archive member. / time_t ar_date; / File date. / uid_t ar_uid; / User ID. / gid_t ar_gid; / Group ID. / mode_t ar_mode; / File mode. / int64_t ar_size; / File size. / char ar_rawname; /* Original name of archive member. / } Elf_Arhdr; / Archive symbol table entry. / typedef struct { char as_name; /* Symbol name. / size_t as_off; / Offset for this file in the archive. / unsigned long int as_hash; / Hash value of the name. / } Elf_Arsym; / Descriptor for the ELF file. / typedef struct Elf Elf; / Descriptor for ELF file section. / typedef struct Elf_Scn Elf_Scn; #ifdef __cplusplus extern "C" { #endif / Return descriptor for ELF file to work according to CMD. / extern Elf elf_begin (int __fildes, Elf_Cmd __cmd, Elf __ref); / Create a clone of an existing ELF descriptor. / extern Elf elf_clone (Elf __elf, Elf_Cmd __cmd); / Create descriptor for memory region. / extern Elf elf_memory (char __image, size_t __size); / Advance archive descriptor to next element. / extern Elf_Cmd elf_next (Elf __elf); /* Free resources allocated for ELF. / extern int elf_end (Elf __elf); /* Update ELF descriptor and write file to disk. / extern int64_t elf_update (Elf __elf, Elf_Cmd __cmd); /* Determine what kind of file is associated with ELF. / extern Elf_Kind elf_kind (Elf __elf) __pure_attribute__; /* Get the base offset for an object file. / extern int64_t elf_getbase (Elf __elf); /* Retrieve file identification data. / extern char elf_getident (Elf __elf, size_t __nbytes); /* Retrieve class-dependent object file header. / extern Elf32_Ehdr elf32_getehdr (Elf __elf); / Similar but this time the binary calls is ELFCLASS64. / extern Elf64_Ehdr elf64_getehdr (Elf __elf); / Create ELF header if none exists. / extern Elf32_Ehdr elf32_newehdr (Elf __elf); / Similar but this time the binary calls is ELFCLASS64. / extern Elf64_Ehdr elf64_newehdr (Elf __elf); / Get the number of program headers in the ELF file. If the file uses more headers than can be represented in the e_phnum field of the ELF header the information from the sh_info field in the zeroth section header is used. / extern int elf_getphdrnum (Elf __elf, size_t __dst); / Retrieve class-dependent program header table. / extern Elf32_Phdr elf32_getphdr (Elf __elf); / Similar but this time the binary calls is ELFCLASS64. / extern Elf64_Phdr elf64_getphdr (Elf __elf); / Create ELF program header. / extern Elf32_Phdr elf32_newphdr (Elf __elf, size_t __cnt); / Similar but this time the binary calls is ELFCLASS64. / extern Elf64_Phdr elf64_newphdr (Elf __elf, size_t __cnt); / Get section at INDEX. / extern Elf_Scn elf_getscn (Elf __elf, size_t __index); / Get section at OFFSET. / extern Elf_Scn elf32_offscn (Elf __elf, Elf32_Off __offset); / Similar but this time the binary calls is ELFCLASS64. / extern Elf_Scn elf64_offscn (Elf __elf, Elf64_Off __offset); / Get index of section. / extern size_t elf_ndxscn (Elf_Scn __scn); /* Get section with next section index. / extern Elf_Scn elf_nextscn (Elf __elf, Elf_Scn __scn); /* Create a new section and append it at the end of the table. / extern Elf_Scn elf_newscn (Elf __elf); / Get the section index of the extended section index table for the given symbol table. Returns -1 when the given Elf_Scn is NULL or if an error occurred during lookup, elf_errno will be set. Returns 0 if the given Elf_Scn isn't a symbol table (sh_type is not SHT_SYMTAB) or no extended section index table could be found. Otherwise the section index of the extended section index table for the given Elf_Scn is returned. An extended index table has a sh_type of SHT_SYMTAB_SHNDX and a sh_link equal to the given symbol table section index. / extern int elf_scnshndx (Elf_Scn __scn); /* Get the number of sections in the ELF file. If the file uses more sections than can be represented in the e_shnum field of the ELF header the information from the sh_size field in the zeroth section header is used. / extern int elf_getshdrnum (Elf __elf, size_t __dst); / Sun messed up the implementation of 'elf_getshnum' in their implementation. It was agreed to make the same functionality available under a different name and obsolete the old name. / extern int elf_getshnum (Elf __elf, size_t __dst) __deprecated_attribute__; / Get the section index of the section header string table in the ELF file. If the index cannot be represented in the e_shstrndx field of the ELF header the information from the sh_link field in the zeroth section header is used. / extern int elf_getshdrstrndx (Elf __elf, size_t __dst); / Sun messed up the implementation of 'elf_getshstrndx' in their implementation. It was agreed to make the same functionality available under a different name and obsolete the old name. / extern int elf_getshstrndx (Elf __elf, size_t __dst) __deprecated_attribute__; / Retrieve section header of ELFCLASS32 binary. / extern Elf32_Shdr elf32_getshdr (Elf_Scn __scn); / Similar for ELFCLASS64. / extern Elf64_Shdr elf64_getshdr (Elf_Scn __scn); / Returns compression header for a section if section data is compressed. Returns NULL and sets elf_errno if the section isn't compressed or an error occurred. / extern Elf32_Chdr elf32_getchdr (Elf_Scn __scn); extern Elf64_Chdr elf64_getchdr (Elf_Scn __scn); / Compress or decompress the data of a section and adjust the section header. elf_compress works by setting or clearing the SHF_COMPRESS flag from the section Shdr and will encode or decode a Elf32_Chdr or Elf64_Chdr at the start of the section data. elf_compress_gnu will encode or decode any section, but is traditionally only used for sections that have a name starting with ".debug" when uncompressed or ".zdebug" when compressed and stores just the uncompressed size. The GNU compression method is deprecated and should only be used for legacy support. elf_compress takes a compression type that should be either zero to decompress or an ELFCOMPRESS algorithm to use for compression. Currently ELFCOMPRESS_ZLIB and ELFCOMPRESS_ZSTD are supported. elf_compress_gnu will compress in the traditional GNU compression format when compress is one and decompress the section data when compress is zero. The FLAGS argument can be zero or ELF_CHF_FORCE. If FLAGS contains ELF_CHF_FORCE then it will always compress the section, even if that would not reduce the size of the data section (including the header). Otherwise elf_compress and elf_compress_gnu will compress the section only if the total data size is reduced. On successful compression or decompression the function returns one. If (not forced) compression is requested and the data section would not actually reduce in size, the section is not actually compressed and zero is returned. Otherwise -1 is returned and elf_errno is set. It is an error to request compression for a section that already has SHF_COMPRESSED set, or (for elf_compress) to request decompression for an section that doesn't have SHF_COMPRESSED set. If a section has SHF_COMPRESSED set then calling elf_compress_gnu will result in an error. The section has to be decompressed first using elf_compress. Calling elf_compress on a section compressed with elf_compress_gnu is fine, but probably useless. It is always an error to call these functions on SHT_NOBITS sections or if the section has the SHF_ALLOC flag set. elf_compress_gnu will not check whether the section name starts with ".debug" or .zdebug". It is the responsibility of the caller to make sure the deprecated GNU compression method is only called on correctly named sections (and to change the name of the section when using elf_compress_gnu). All previous returned Shdrs and Elf_Data buffers are invalidated by this call and should no longer be accessed. Note that although this changes the header and data returned it doesn't mark the section as dirty. To keep the changes when calling elf_update the section has to be flagged ELF_F_DIRTY. / extern int elf_compress (Elf_Scn scn, int type, unsigned int flags); extern int elf_compress_gnu (Elf_Scn scn, int compress, unsigned int flags); / Set or clear flags for ELF file. / extern unsigned int elf_flagelf (Elf __elf, Elf_Cmd __cmd, unsigned int __flags); /* Similarly for the ELF header. / extern unsigned int elf_flagehdr (Elf __elf, Elf_Cmd __cmd, unsigned int __flags); /* Similarly for the ELF program header. / extern unsigned int elf_flagphdr (Elf __elf, Elf_Cmd __cmd, unsigned int __flags); /* Similarly for the given ELF section. / extern unsigned int elf_flagscn (Elf_Scn __scn, Elf_Cmd __cmd, unsigned int __flags); /* Similarly for the given ELF data. / extern unsigned int elf_flagdata (Elf_Data __data, Elf_Cmd __cmd, unsigned int __flags); /* Similarly for the given ELF section header. / extern unsigned int elf_flagshdr (Elf_Scn __scn, Elf_Cmd __cmd, unsigned int __flags); /* Get data from section while translating from file representation to memory representation. The Elf_Data d_type is set based on the section type if known. Otherwise d_type is set to ELF_T_BYTE. If the section contains compressed data then d_type is always set to ELF_T_CHDR. / extern Elf_Data elf_getdata (Elf_Scn __scn, Elf_Data __data); /* Get uninterpreted section content. / extern Elf_Data elf_rawdata (Elf_Scn __scn, Elf_Data __data); /* Create new data descriptor for section SCN. / extern Elf_Data elf_newdata (Elf_Scn __scn); / Get data translated from a chunk of the file contents as section data would be for TYPE. The resulting Elf_Data pointer is valid until elf_end (ELF) is called. / extern Elf_Data elf_getdata_rawchunk (Elf __elf, int64_t __offset, size_t __size, Elf_Type __type); / Return pointer to string at OFFSET in section INDEX. / extern char elf_strptr (Elf __elf, size_t __index, size_t __offset); / Return header of archive. / extern Elf_Arhdr elf_getarhdr (Elf __elf); / Return offset in archive for current file ELF. / extern int64_t elf_getaroff (Elf __elf); /* Select archive element at OFFSET. / extern size_t elf_rand (Elf __elf, size_t __offset); /* Get symbol table of archive. / extern Elf_Arsym elf_getarsym (Elf __elf, size_t __narsyms); /* Control ELF descriptor. / extern int elf_cntl (Elf __elf, Elf_Cmd __cmd); /* Retrieve uninterpreted file contents. / extern char elf_rawfile (Elf __elf, size_t __nbytes); /* Return size of array of COUNT elements of the type denoted by TYPE in the external representation. The binary class is taken from ELF. The result is based on version VERSION of the ELF standard. / extern size_t elf32_fsize (Elf_Type __type, size_t __count, unsigned int __version) __const_attribute__; / Similar but this time the binary calls is ELFCLASS64. / extern size_t elf64_fsize (Elf_Type __type, size_t __count, unsigned int __version) __const_attribute__; / Convert data structure from the representation in the file represented by ELF to their memory representation. / extern Elf_Data elf32_xlatetom (Elf_Data __dest, const Elf_Data __src, unsigned int __encode); /* Same for 64 bit class. / extern Elf_Data elf64_xlatetom (Elf_Data __dest, const Elf_Data __src, unsigned int __encode); /* Convert data structure from to the representation in memory represented by ELF file representation. / extern Elf_Data elf32_xlatetof (Elf_Data __dest, const Elf_Data __src, unsigned int __encode); /* Same for 64 bit class. / extern Elf_Data elf64_xlatetof (Elf_Data __dest, const Elf_Data __src, unsigned int __encode); /* Return error code of last failing function call. This value is kept separately for each thread. / extern int elf_errno (void); / Return error string for ERROR. If ERROR is zero, return error string for most recent error or NULL is none occurred. If ERROR is -1 the behaviour is similar to the last case except that not NULL but a legal string is returned. / extern const char elf_errmsg (int __error); /* Coordinate ELF library and application versions. / extern unsigned int elf_version (unsigned int __version); / Set fill bytes used to fill holes in data structures. / extern void elf_fill (int __fill); / Compute hash value. / extern unsigned long int elf_hash (const char __string) __pure_attribute__; /* Compute hash value using the GNU-specific hash function. / extern unsigned long int elf_gnu_hash (const char __string) __pure_attribute__; /* Compute simple checksum from permanent parts of the ELF file. / extern long int elf32_checksum (Elf __elf); /* Similar but this time the binary calls is ELFCLASS64. / extern long int elf64_checksum (Elf __elf); #ifdef __cplusplus } #endif #endif /* libelf.h */	20.31 KB	2025-04-25 20:16
📄 libgen.h /* Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _LIBGEN_H #define _LIBGEN_H 1 #include <features.h> __BEGIN_DECLS / Return directory part of PATH or "." if none is available. / extern char dirname (char __path) __THROW; / Return final component of PATH. This is the weird XPG version of this function. It sometimes will modify its argument. Therefore we normally use the GNU version (in <string.h>) and only if this header is included make the XPG version available under the real name. / extern char __xpg_basename (char __path) __THROW; #define basename __xpg_basename __END_DECLS #endif / libgen.h */	1.35 KB	2026-02-17 11:01
📄 libintl.h /* Message catalogs for internationalization. Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. This file is derived from the file libgettext.h in the GNU gettext package. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _LIBINTL_H #define _LIBINTL_H 1 #include <features.h> / We define an additional symbol to signal that we use the GNU implementation of gettext. / #define __USE_GNU_GETTEXT 1 / Provide information about the supported file formats. Returns the maximum minor revision number supported for a given major revision. / #define __GNU_GETTEXT_SUPPORTED_REVISION(major) \ ((major) == 0 ? 1 : -1) __BEGIN_DECLS / Look up MSGID in the current default message catalog for the current LC_MESSAGES locale. If not found, returns MSGID itself (the default text). / extern char gettext (const char __msgid) __THROW __attribute_format_arg__ (1); / Look up MSGID in the DOMAINNAME message catalog for the current LC_MESSAGES locale. / extern char dgettext (const char __domainname, const char __msgid) __THROW __attribute_format_arg__ (2); extern char __dgettext (const char __domainname, const char __msgid) __THROW __attribute_format_arg__ (2); / Look up MSGID in the DOMAINNAME message catalog for the current CATEGORY locale. / extern char dcgettext (const char __domainname, const char __msgid, int __category) __THROW __attribute_format_arg__ (2); extern char __dcgettext (const char __domainname, const char __msgid, int __category) __THROW __attribute_format_arg__ (2); / Similar to `gettext' but select the plural form corresponding to the number N. / extern char ngettext (const char __msgid1, const char __msgid2, unsigned long int __n) __THROW __attribute_format_arg__ (1) __attribute_format_arg__ (2); /* Similar to `dgettext' but select the plural form corresponding to the number N. / extern char dngettext (const char __domainname, const char __msgid1, const char __msgid2, unsigned long int __n) __THROW __attribute_format_arg__ (2) __attribute_format_arg__ (3); / Similar to `dcgettext' but select the plural form corresponding to the number N. / extern char dcngettext (const char __domainname, const char __msgid1, const char __msgid2, unsigned long int __n, int __category) __THROW __attribute_format_arg__ (2) __attribute_format_arg__ (3); / Set the current default message catalog to DOMAINNAME. If DOMAINNAME is null, return the current default. If DOMAINNAME is "", reset to the default of "messages". / extern char textdomain (const char __domainname) __THROW; / Specify that the DOMAINNAME message catalog will be found in DIRNAME rather than in the system locale data base. / extern char bindtextdomain (const char __domainname, const char __dirname) __THROW; /* Specify the character encoding in which the messages from the DOMAINNAME message catalog will be returned. / extern char bind_textdomain_codeset (const char __domainname, const char __codeset) __THROW; /* Optimized version of the function above. / #if defined __OPTIMIZE__ && !defined __cplusplus / We need NULL for `gettext'. / # define __need_NULL # include <stddef.h> / We need LC_MESSAGES for `dgettext'. / # include <locale.h> / These must be macros. Inlined functions are useless because the `__builtin_constant_p' predicate in dcgettext would always return false. / # define gettext(msgid) dgettext (NULL, msgid) # define dgettext(domainname, msgid) \ dcgettext (domainname, msgid, LC_MESSAGES) # define ngettext(msgid1, msgid2, n) dngettext (NULL, msgid1, msgid2, n) # define dngettext(domainname, msgid1, msgid2, n) \ dcngettext (domainname, msgid1, msgid2, n, LC_MESSAGES) #endif / Optimizing. / __END_DECLS #endif / libintl.h */	4.47 KB	2026-02-17 11:01
📄 liblsapi-sha1.h /* public api for steve reid's public domain SHA-1 implementation / / this file is in the public domain / #ifndef __SHA1_H #define __SHA1_H #include <stdint.h> #ifdef __cplusplus extern "C" { #endif typedef struct { uint32_t state[5]; uint32_t count[2]; uint8_t buffer[64]; } SHA1_CTX; #define SHA1_DIGEST_SIZE 20 void SHA1_Init(SHA1_CTX context); void SHA1_Update(SHA1_CTX* context, const uint8_t* data, const size_t len); void SHA1_Final(SHA1_CTX* context, uint8_t digest[SHA1_DIGEST_SIZE]); #ifdef __cplusplus } #endif #endif /* __SHA1_H */	569 B	2026-02-13 18:38
📄 libpsl.h /* * Copyright(c) 2014-2018 Tim Ruehsen * * 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. * * This file is part of libpsl. * * Header file for libpsl library routines * * Changelog * 20.03.2014 Tim Ruehsen created * / #ifndef LIBPSL_LIBPSL_H #define LIBPSL_LIBPSL_H #include <stdio.h> #include <time.h> #define PSL_VERSION "0.21.1" #define PSL_VERSION_MAJOR 0 #define PSL_VERSION_MINOR 21 #define PSL_VERSION_PATCH 1 #define PSL_VERSION_NUMBER 0x001501 / support clang's __has_declspec_attribute attribute / #ifndef __has_declspec_attribute # define __has_declspec_attribute(x) 0 #endif #ifndef PSL_API #if defined BUILDING_PSL && HAVE_VISIBILITY # define PSL_API __attribute__ ((__visibility__("default"))) #elif defined BUILDING_PSL && (defined _MSC_VER \|\| __has_declspec_attribute(dllexport)) && !defined PSL_STATIC # define PSL_API __declspec(dllexport) #elif (defined _MSC_VER \|\| __has_declspec_attribute(dllimport)) && !defined PSL_STATIC # define PSL_API __declspec(dllimport) #else # define PSL_API #endif #endif #ifdef __cplusplus extern "C" { #endif / types for psl_is_public_suffix2() / #define PSL_TYPE_ICANN (1<<0) #define PSL_TYPE_PRIVATE (1<<1) #define PSL_TYPE_NO_STAR_RULE (1<<2) #define PSL_TYPE_ANY (PSL_TYPE_ICANN \| PSL_TYPE_PRIVATE) /* * psl_error_t: * @PSL_SUCCESS: Successful return. * @PSL_ERR_INVALID_ARG: Invalid argument. * @PSL_ERR_CONVERTER: Failed to open libicu utf-16 converter. * @PSL_ERR_TO_UTF16: Failed to convert to utf-16. * @PSL_ERR_TO_LOWER: Failed to convert utf-16 to lowercase. * @PSL_ERR_TO_UTF8: Failed to convert utf-16 to utf-8. * @PSL_ERR_NO_MEM: Failed to allocate memory. * * Return codes for PSL functions. * Negative return codes mean failure. * Positive values are reserved for non-error return codes. / typedef enum { PSL_SUCCESS = 0, PSL_ERR_INVALID_ARG = -1, PSL_ERR_CONVERTER = -2, / failed to open libicu utf-16 converter / PSL_ERR_TO_UTF16 = -3, / failed to convert to utf-16 / PSL_ERR_TO_LOWER = -4, / failed to convert utf-16 to lowercase / PSL_ERR_TO_UTF8 = -5, / failed to convert utf-16 to utf-8 / PSL_ERR_NO_MEM = -6 / failed to allocate memory / } psl_error_t; typedef struct psl_ctx_st psl_ctx_t; / frees PSL context / PSL_API void psl_free(psl_ctx_t psl); /* frees memory allocated by libpsl routines / PSL_API void psl_free_string(char str); /* loads PSL data from file / PSL_API psl_ctx_t psl_load_file(const char fname); / loads PSL data from FILE pointer / PSL_API psl_ctx_t psl_load_fp(FILE fp); / retrieves builtin PSL data / PSL_API const psl_ctx_t psl_builtin(void); /* retrieves most recent PSL data / PSL_API psl_ctx_t psl_latest(const char fname); / checks whether domain is a public suffix or not / PSL_API int psl_is_public_suffix(const psl_ctx_t psl, const char domain); / checks whether domain is a public suffix regarding the type or not / PSL_API int psl_is_public_suffix2(const psl_ctx_t psl, const char domain, int type); / checks whether cookie_domain is acceptable for domain or not / PSL_API int psl_is_cookie_domain_acceptable(const psl_ctx_t psl, const char hostname, const char cookie_domain); /* returns the longest not registrable domain within 'domain' or NULL if none found / PSL_API const char psl_unregistrable_domain(const psl_ctx_t psl, const char domain); /* returns the shortest possible registrable domain part or NULL if domain is not registrable at all / PSL_API const char psl_registrable_domain(const psl_ctx_t psl, const char domain); /* convert a string into lowercase UTF-8 / PSL_API psl_error_t psl_str_to_utf8lower(const char str, const char encoding, const char locale, char *lower); / does not include exceptions / PSL_API int psl_suffix_count(const psl_ctx_t psl); /* just counts exceptions / PSL_API int psl_suffix_exception_count(const psl_ctx_t psl); /* just counts wildcards / PSL_API int psl_suffix_wildcard_count(const psl_ctx_t psl); /* returns mtime of PSL source file / PSL_API time_t psl_builtin_file_time(void); / returns SHA1 checksum (hex-encoded, lowercase) of PSL source file / PSL_API const char psl_builtin_sha1sum(void); /* returns file name of PSL source file / PSL_API const char psl_builtin_filename(void); /* returns name of distribution PSL data file / PSL_API const char psl_dist_filename(void); /* returns library version string / PSL_API const char psl_get_version(void); /* checks library version number / PSL_API int psl_check_version_number(int version); / returns whether the built-in data is outdated or not / PSL_API int psl_builtin_outdated(void); #ifdef __cplusplus } #endif #endif / LIBPSL_LIBPSL_H */	5.66 KB	2022-02-10 03:17
📄 libssh2.h /* Copyright (C) Sara Golemon <sarag@libssh2.org> * Copyright (C) Daniel Stenberg * Copyright (C) Simon Josefsson <simon@josefsson.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: * * 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. * * Neither the name of the copyright holder nor the names * of any other contributors may be used to endorse or * promote products derived from this software without * specific prior written permission. * * 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. * * SPDX-License-Identifier: BSD-3-Clause / #ifndef LIBSSH2_H #define LIBSSH2_H 1 #define LIBSSH2_COPYRIGHT "The libssh2 project and its contributors." / We use underscore instead of dash when appending DEV in dev versions just to make the BANNER define (used by src/session.c) be a valid SSH banner. Release versions have no appended strings and may of course not have dashes either. / #define LIBSSH2_VERSION "1.11.1" / The numeric version number is also available "in parts" by using these defines: / #define LIBSSH2_VERSION_MAJOR 1 #define LIBSSH2_VERSION_MINOR 11 #define LIBSSH2_VERSION_PATCH 1 / This is the numeric version of the libssh2 version number, meant for easier parsing and comparisons by programs. The LIBSSH2_VERSION_NUM define will always follow this syntax: 0xXXYYZZ Where XX, YY and ZZ are the main version, release and patch numbers in hexadecimal (using 8 bits each). All three numbers are always represented using two digits. 1.2 would appear as "0x010200" while version 9.11.7 appears as "0x090b07". This 6-digit (24 bits) hexadecimal number does not show pre-release number, and it is always a greater number in a more recent release. It makes comparisons with greater than and less than work. / #define LIBSSH2_VERSION_NUM 0x010b01 / * This is the date and time when the full source package was created. The * timestamp is not stored in the source code repo, as the timestamp is * properly set in the tarballs by the maketgz script. * * The format of the date should follow this template: * * "Mon Feb 12 11:35:33 UTC 2007" / #define LIBSSH2_TIMESTAMP "Wed Oct 16 08:03:21 UTC 2024" #ifndef RC_INVOKED #ifdef __cplusplus extern "C" { #endif #ifdef _WIN32 # include <basetsd.h> # include <winsock2.h> #endif #include <stddef.h> #include <string.h> #include <sys/stat.h> #include <sys/types.h> / Allow alternate API prefix from CFLAGS or calling app / #ifndef LIBSSH2_API # ifdef _WIN32 # if defined(LIBSSH2_EXPORTS) \|\| defined(_WINDLL) # ifdef LIBSSH2_LIBRARY # define LIBSSH2_API __declspec(dllexport) # else # define LIBSSH2_API __declspec(dllimport) # endif / LIBSSH2_LIBRARY / # else # define LIBSSH2_API # endif # else / !_WIN32 / # define LIBSSH2_API # endif / _WIN32 / #endif / LIBSSH2_API / #ifdef HAVE_SYS_UIO_H # include <sys/uio.h> #endif #ifdef _MSC_VER typedef unsigned char uint8_t; typedef unsigned short int uint16_t; typedef unsigned int uint32_t; typedef __int32 int32_t; typedef __int64 int64_t; typedef unsigned __int64 uint64_t; typedef unsigned __int64 libssh2_uint64_t; typedef __int64 libssh2_int64_t; #if (!defined(HAVE_SSIZE_T) && !defined(ssize_t)) typedef SSIZE_T ssize_t; #define HAVE_SSIZE_T #endif #else #include <stdint.h> typedef unsigned long long libssh2_uint64_t; typedef long long libssh2_int64_t; #endif #ifdef _WIN32 typedef SOCKET libssh2_socket_t; #define LIBSSH2_INVALID_SOCKET INVALID_SOCKET #define LIBSSH2_SOCKET_CLOSE(s) closesocket(s) #else / !_WIN32 / typedef int libssh2_socket_t; #define LIBSSH2_INVALID_SOCKET -1 #define LIBSSH2_SOCKET_CLOSE(s) close(s) #endif / _WIN32 / / Compile-time deprecation macros / #if !defined(LIBSSH2_DISABLE_DEPRECATION) && !defined(LIBSSH2_LIBRARY) # if defined(_MSC_VER) # if _MSC_VER >= 1400 # define LIBSSH2_DEPRECATED(version, message) \ __declspec(deprecated("since libssh2 " # version ". " message)) # elif _MSC_VER >= 1310 # define LIBSSH2_DEPRECATED(version, message) \ __declspec(deprecated) # endif # elif defined(__GNUC__) && !defined(__INTEL_COMPILER) # if (defined(__clang__) && __clang_major__ >= 3) \|\| \ (__GNUC__ > 4 \|\| (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)) # define LIBSSH2_DEPRECATED(version, message) \ __attribute__((deprecated("since libssh2 " # version ". " message))) # elif __GNUC__ > 3 \|\| (__GNUC__ == 3 && __GNUC_MINOR__ > 0) # define LIBSSH2_DEPRECATED(version, message) \ __attribute__((deprecated)) # endif # elif defined(__SUNPRO_C) && __SUNPRO_C >= 0x5130 # define LIBSSH2_DEPRECATED(version, message) \ __attribute__((deprecated)) # endif #endif #ifndef LIBSSH2_DEPRECATED #define LIBSSH2_DEPRECATED(version, message) #endif / * Determine whether there is small or large file support on windows. / #if defined(_MSC_VER) && !defined(_WIN32_WCE) # if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64) # define LIBSSH2_USE_WIN32_LARGE_FILES # else # define LIBSSH2_USE_WIN32_SMALL_FILES # endif #endif #if defined(__MINGW32__) && !defined(LIBSSH2_USE_WIN32_LARGE_FILES) # define LIBSSH2_USE_WIN32_LARGE_FILES #endif #if defined(__WATCOMC__) && !defined(LIBSSH2_USE_WIN32_LARGE_FILES) # define LIBSSH2_USE_WIN32_LARGE_FILES #endif #if defined(__POCC__) # undef LIBSSH2_USE_WIN32_LARGE_FILES #endif #if defined(_WIN32) && !defined(LIBSSH2_USE_WIN32_LARGE_FILES) && \ !defined(LIBSSH2_USE_WIN32_SMALL_FILES) # define LIBSSH2_USE_WIN32_SMALL_FILES #endif / * Large file (>2Gb) support using WIN32 functions. / #ifdef LIBSSH2_USE_WIN32_LARGE_FILES # include <io.h> # define LIBSSH2_STRUCT_STAT_SIZE_FORMAT "%I64d" typedef struct _stati64 libssh2_struct_stat; typedef __int64 libssh2_struct_stat_size; #endif / * Small file (<2Gb) support using WIN32 functions. / #ifdef LIBSSH2_USE_WIN32_SMALL_FILES # ifndef _WIN32_WCE # define LIBSSH2_STRUCT_STAT_SIZE_FORMAT "%d" typedef struct _stat libssh2_struct_stat; typedef off_t libssh2_struct_stat_size; # endif #endif #ifndef LIBSSH2_STRUCT_STAT_SIZE_FORMAT # ifdef __VMS / We have to roll our own format here because %z is a C99-ism we don't have. / # if __USE_OFF64_T \|\| __USING_STD_STAT # define LIBSSH2_STRUCT_STAT_SIZE_FORMAT "%Ld" # else # define LIBSSH2_STRUCT_STAT_SIZE_FORMAT "%d" # endif # else # define LIBSSH2_STRUCT_STAT_SIZE_FORMAT "%zd" # endif typedef struct stat libssh2_struct_stat; typedef off_t libssh2_struct_stat_size; #endif / Part of every banner, user specified or not / #define LIBSSH2_SSH_BANNER "SSH-2.0-libssh2_" LIBSSH2_VERSION #define LIBSSH2_SSH_DEFAULT_BANNER LIBSSH2_SSH_BANNER #define LIBSSH2_SSH_DEFAULT_BANNER_WITH_CRLF LIBSSH2_SSH_DEFAULT_BANNER "\r\n" / Defaults for pty requests / #define LIBSSH2_TERM_WIDTH 80 #define LIBSSH2_TERM_HEIGHT 24 #define LIBSSH2_TERM_WIDTH_PX 0 #define LIBSSH2_TERM_HEIGHT_PX 0 / 1/4 second / #define LIBSSH2_SOCKET_POLL_UDELAY 250000 / 0.25 * 120 == 30 seconds / #define LIBSSH2_SOCKET_POLL_MAXLOOPS 120 / Maximum size to allow a payload to compress to, plays it safe by falling short of spec limits / #define LIBSSH2_PACKET_MAXCOMP 32000 / Maximum size to allow a payload to deccompress to, plays it safe by allowing more than spec requires / #define LIBSSH2_PACKET_MAXDECOMP 40000 / Maximum size for an inbound compressed payload, plays it safe by overshooting spec limits / #define LIBSSH2_PACKET_MAXPAYLOAD 40000 / Malloc callbacks / #define LIBSSH2_ALLOC_FUNC(name) void name(size_t count, void *abstract) #define LIBSSH2_REALLOC_FUNC(name) void name(void ptr, size_t count, \ void abstract) #define LIBSSH2_FREE_FUNC(name) void name(void ptr, void *abstract) typedef struct _LIBSSH2_USERAUTH_KBDINT_PROMPT { unsigned char text; size_t length; unsigned char echo; } LIBSSH2_USERAUTH_KBDINT_PROMPT; typedef struct _LIBSSH2_USERAUTH_KBDINT_RESPONSE { char text; unsigned int length; / FIXME: change type to size_t / } LIBSSH2_USERAUTH_KBDINT_RESPONSE; typedef struct _LIBSSH2_SK_SIG_INFO { uint8_t flags; uint32_t counter; unsigned char sig_r; size_t sig_r_len; unsigned char sig_s; size_t sig_s_len; } LIBSSH2_SK_SIG_INFO; / 'publickey' authentication callback / #define LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC(name) \ int name(LIBSSH2_SESSION session, unsigned char *sig, size_t sig_len, \ const unsigned char data, size_t data_len, void abstract) / 'keyboard-interactive' authentication callback / / FIXME: name_len, instruction_len -> size_t, num_prompts -> unsigned int? / #define LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC(name_) \ void name_(const char name, int name_len, const char instruction, \ int instruction_len, int num_prompts, \ const LIBSSH2_USERAUTH_KBDINT_PROMPT prompts, \ LIBSSH2_USERAUTH_KBDINT_RESPONSE responses, void abstract) / SK authentication callback / #define LIBSSH2_USERAUTH_SK_SIGN_FUNC(name) \ int name(LIBSSH2_SESSION session, LIBSSH2_SK_SIG_INFO sig_info, \ const unsigned char data, size_t data_len, \ int algorithm, uint8_t flags, \ const char application, const unsigned char key_handle, \ size_t handle_len, \ void *abstract) / Flags for SK authentication / #define LIBSSH2_SK_PRESENCE_REQUIRED 0x01 #define LIBSSH2_SK_VERIFICATION_REQUIRED 0x04 / FIXME: update lengths to size_t (or ssize_t): / / Callbacks for special SSH packets / #define LIBSSH2_IGNORE_FUNC(name) \ void name(LIBSSH2_SESSION session, const char message, int message_len, \ void abstract) #define LIBSSH2_DEBUG_FUNC(name) \ void name(LIBSSH2_SESSION session, int always_display, \ const char message, int message_len, \ const char language, int language_len, \ void *abstract) #define LIBSSH2_DISCONNECT_FUNC(name) \ void name(LIBSSH2_SESSION session, int reason, \ const char message, int message_len, \ const char language, int language_len, \ void *abstract) #define LIBSSH2_PASSWD_CHANGEREQ_FUNC(name) \ void name(LIBSSH2_SESSION session, char *newpw, int newpw_len, \ void *abstract) #define LIBSSH2_MACERROR_FUNC(name) \ int name(LIBSSH2_SESSION session, const char packet, int packet_len, \ void abstract) #define LIBSSH2_X11_OPEN_FUNC(name) \ void name(LIBSSH2_SESSION session, LIBSSH2_CHANNEL channel, \ const char shost, int sport, void *abstract) #define LIBSSH2_AUTHAGENT_FUNC(name) \ void name(LIBSSH2_SESSION session, LIBSSH2_CHANNEL channel, \ void abstract) #define LIBSSH2_ADD_IDENTITIES_FUNC(name) \ void name(LIBSSH2_SESSION session, void buffer, \ const char agent_path, void *abstract) #define LIBSSH2_AUTHAGENT_SIGN_FUNC(name) \ int name(LIBSSH2_SESSION session, \ unsigned char blob, unsigned int blen, \ const unsigned char data, unsigned int dlen, \ unsigned char *signature, unsigned int sigLen, \ const char agentPath, \ void abstract) #define LIBSSH2_CHANNEL_CLOSE_FUNC(name) \ void name(LIBSSH2_SESSION session, void *session_abstract, \ LIBSSH2_CHANNEL channel, void *channel_abstract) / I/O callbacks / #define LIBSSH2_RECV_FUNC(name) \ ssize_t name(libssh2_socket_t socket, \ void buffer, size_t length, \ int flags, void *abstract) #define LIBSSH2_SEND_FUNC(name) \ ssize_t name(libssh2_socket_t socket, \ const void buffer, size_t length, \ int flags, void *abstract) / libssh2_session_callback_set() constants / #define LIBSSH2_CALLBACK_IGNORE 0 #define LIBSSH2_CALLBACK_DEBUG 1 #define LIBSSH2_CALLBACK_DISCONNECT 2 #define LIBSSH2_CALLBACK_MACERROR 3 #define LIBSSH2_CALLBACK_X11 4 #define LIBSSH2_CALLBACK_SEND 5 #define LIBSSH2_CALLBACK_RECV 6 #define LIBSSH2_CALLBACK_AUTHAGENT 7 #define LIBSSH2_CALLBACK_AUTHAGENT_IDENTITIES 8 #define LIBSSH2_CALLBACK_AUTHAGENT_SIGN 9 / libssh2_session_method_pref() constants / #define LIBSSH2_METHOD_KEX 0 #define LIBSSH2_METHOD_HOSTKEY 1 #define LIBSSH2_METHOD_CRYPT_CS 2 #define LIBSSH2_METHOD_CRYPT_SC 3 #define LIBSSH2_METHOD_MAC_CS 4 #define LIBSSH2_METHOD_MAC_SC 5 #define LIBSSH2_METHOD_COMP_CS 6 #define LIBSSH2_METHOD_COMP_SC 7 #define LIBSSH2_METHOD_LANG_CS 8 #define LIBSSH2_METHOD_LANG_SC 9 #define LIBSSH2_METHOD_SIGN_ALGO 10 / flags / #define LIBSSH2_FLAG_SIGPIPE 1 #define LIBSSH2_FLAG_COMPRESS 2 #define LIBSSH2_FLAG_QUOTE_PATHS 3 typedef struct _LIBSSH2_SESSION LIBSSH2_SESSION; typedef struct _LIBSSH2_CHANNEL LIBSSH2_CHANNEL; typedef struct _LIBSSH2_LISTENER LIBSSH2_LISTENER; typedef struct _LIBSSH2_KNOWNHOSTS LIBSSH2_KNOWNHOSTS; typedef struct _LIBSSH2_AGENT LIBSSH2_AGENT; / SK signature callback / typedef struct _LIBSSH2_PRIVKEY_SK { int algorithm; uint8_t flags; const char application; const unsigned char key_handle; size_t handle_len; LIBSSH2_USERAUTH_SK_SIGN_FUNC((sign_callback)); void *orig_abstract; } LIBSSH2_PRIVKEY_SK; int libssh2_sign_sk(LIBSSH2_SESSION session, unsigned char *sig, size_t sig_len, const unsigned char data, size_t data_len, void abstract); typedef struct _LIBSSH2_POLLFD { unsigned char type; / LIBSSH2_POLLFD_* below / union { libssh2_socket_t socket; / File descriptors -- examined with system select() call / LIBSSH2_CHANNEL channel; /* Examined by checking internal state / LIBSSH2_LISTENER listener; /* Read polls only -- are inbound connections waiting to be accepted? / } fd; unsigned long events; / Requested Events / unsigned long revents; / Returned Events / } LIBSSH2_POLLFD; / Poll FD Descriptor Types / #define LIBSSH2_POLLFD_SOCKET 1 #define LIBSSH2_POLLFD_CHANNEL 2 #define LIBSSH2_POLLFD_LISTENER 3 / Note: Win32 Doesn't actually have a poll() implementation, so some of these values are faked with select() data / / Poll FD events/revents -- Match sys/poll.h where possible / #define LIBSSH2_POLLFD_POLLIN 0x0001 / Data available to be read or connection available -- All / #define LIBSSH2_POLLFD_POLLPRI 0x0002 / Priority data available to be read -- Socket only / #define LIBSSH2_POLLFD_POLLEXT 0x0002 / Extended data available to be read -- Channel only / #define LIBSSH2_POLLFD_POLLOUT 0x0004 / Can may be written -- Socket/Channel / / revents only / #define LIBSSH2_POLLFD_POLLERR 0x0008 / Error Condition -- Socket / #define LIBSSH2_POLLFD_POLLHUP 0x0010 / HangUp/EOF -- Socket / #define LIBSSH2_POLLFD_SESSION_CLOSED 0x0010 / Session Disconnect / #define LIBSSH2_POLLFD_POLLNVAL 0x0020 / Invalid request -- Socket Only / #define LIBSSH2_POLLFD_POLLEX 0x0040 / Exception Condition -- Socket/Win32 / #define LIBSSH2_POLLFD_CHANNEL_CLOSED 0x0080 / Channel Disconnect / #define LIBSSH2_POLLFD_LISTENER_CLOSED 0x0080 / Listener Disconnect / #define HAVE_LIBSSH2_SESSION_BLOCK_DIRECTION / Block Direction Types / #define LIBSSH2_SESSION_BLOCK_INBOUND 0x0001 #define LIBSSH2_SESSION_BLOCK_OUTBOUND 0x0002 / Hash Types / #define LIBSSH2_HOSTKEY_HASH_MD5 1 #define LIBSSH2_HOSTKEY_HASH_SHA1 2 #define LIBSSH2_HOSTKEY_HASH_SHA256 3 / Hostkey Types / #define LIBSSH2_HOSTKEY_TYPE_UNKNOWN 0 #define LIBSSH2_HOSTKEY_TYPE_RSA 1 #define LIBSSH2_HOSTKEY_TYPE_DSS 2 / deprecated / #define LIBSSH2_HOSTKEY_TYPE_ECDSA_256 3 #define LIBSSH2_HOSTKEY_TYPE_ECDSA_384 4 #define LIBSSH2_HOSTKEY_TYPE_ECDSA_521 5 #define LIBSSH2_HOSTKEY_TYPE_ED25519 6 / Disconnect Codes (defined by SSH protocol) / #define SSH_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT 1 #define SSH_DISCONNECT_PROTOCOL_ERROR 2 #define SSH_DISCONNECT_KEY_EXCHANGE_FAILED 3 #define SSH_DISCONNECT_RESERVED 4 #define SSH_DISCONNECT_MAC_ERROR 5 #define SSH_DISCONNECT_COMPRESSION_ERROR 6 #define SSH_DISCONNECT_SERVICE_NOT_AVAILABLE 7 #define SSH_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED 8 #define SSH_DISCONNECT_HOST_KEY_NOT_VERIFIABLE 9 #define SSH_DISCONNECT_CONNECTION_LOST 10 #define SSH_DISCONNECT_BY_APPLICATION 11 #define SSH_DISCONNECT_TOO_MANY_CONNECTIONS 12 #define SSH_DISCONNECT_AUTH_CANCELLED_BY_USER 13 #define SSH_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE 14 #define SSH_DISCONNECT_ILLEGAL_USER_NAME 15 / Error Codes (defined by libssh2) / #define LIBSSH2_ERROR_NONE 0 / The library once used -1 as a generic error return value on numerous places through the code, which subsequently was converted to LIBSSH2_ERROR_SOCKET_NONE uses over time. As this is a generic error code, the goal is to never ever return this code but instead make sure that a more accurate and descriptive error code is used. / #define LIBSSH2_ERROR_SOCKET_NONE -1 #define LIBSSH2_ERROR_BANNER_RECV -2 #define LIBSSH2_ERROR_BANNER_SEND -3 #define LIBSSH2_ERROR_INVALID_MAC -4 #define LIBSSH2_ERROR_KEX_FAILURE -5 #define LIBSSH2_ERROR_ALLOC -6 #define LIBSSH2_ERROR_SOCKET_SEND -7 #define LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE -8 #define LIBSSH2_ERROR_TIMEOUT -9 #define LIBSSH2_ERROR_HOSTKEY_INIT -10 #define LIBSSH2_ERROR_HOSTKEY_SIGN -11 #define LIBSSH2_ERROR_DECRYPT -12 #define LIBSSH2_ERROR_SOCKET_DISCONNECT -13 #define LIBSSH2_ERROR_PROTO -14 #define LIBSSH2_ERROR_PASSWORD_EXPIRED -15 #define LIBSSH2_ERROR_FILE -16 #define LIBSSH2_ERROR_METHOD_NONE -17 #define LIBSSH2_ERROR_AUTHENTICATION_FAILED -18 #define LIBSSH2_ERROR_PUBLICKEY_UNRECOGNIZED \ LIBSSH2_ERROR_AUTHENTICATION_FAILED #define LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED -19 #define LIBSSH2_ERROR_CHANNEL_OUTOFORDER -20 #define LIBSSH2_ERROR_CHANNEL_FAILURE -21 #define LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED -22 #define LIBSSH2_ERROR_CHANNEL_UNKNOWN -23 #define LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED -24 #define LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED -25 #define LIBSSH2_ERROR_CHANNEL_CLOSED -26 #define LIBSSH2_ERROR_CHANNEL_EOF_SENT -27 #define LIBSSH2_ERROR_SCP_PROTOCOL -28 #define LIBSSH2_ERROR_ZLIB -29 #define LIBSSH2_ERROR_SOCKET_TIMEOUT -30 #define LIBSSH2_ERROR_SFTP_PROTOCOL -31 #define LIBSSH2_ERROR_REQUEST_DENIED -32 #define LIBSSH2_ERROR_METHOD_NOT_SUPPORTED -33 #define LIBSSH2_ERROR_INVAL -34 #define LIBSSH2_ERROR_INVALID_POLL_TYPE -35 #define LIBSSH2_ERROR_PUBLICKEY_PROTOCOL -36 #define LIBSSH2_ERROR_EAGAIN -37 #define LIBSSH2_ERROR_BUFFER_TOO_SMALL -38 #define LIBSSH2_ERROR_BAD_USE -39 #define LIBSSH2_ERROR_COMPRESS -40 #define LIBSSH2_ERROR_OUT_OF_BOUNDARY -41 #define LIBSSH2_ERROR_AGENT_PROTOCOL -42 #define LIBSSH2_ERROR_SOCKET_RECV -43 #define LIBSSH2_ERROR_ENCRYPT -44 #define LIBSSH2_ERROR_BAD_SOCKET -45 #define LIBSSH2_ERROR_KNOWN_HOSTS -46 #define LIBSSH2_ERROR_CHANNEL_WINDOW_FULL -47 #define LIBSSH2_ERROR_KEYFILE_AUTH_FAILED -48 #define LIBSSH2_ERROR_RANDGEN -49 #define LIBSSH2_ERROR_MISSING_USERAUTH_BANNER -50 #define LIBSSH2_ERROR_ALGO_UNSUPPORTED -51 #define LIBSSH2_ERROR_MAC_FAILURE -52 #define LIBSSH2_ERROR_HASH_INIT -53 #define LIBSSH2_ERROR_HASH_CALC -54 / this is a define to provide the old (<= 1.2.7) name / #define LIBSSH2_ERROR_BANNER_NONE LIBSSH2_ERROR_BANNER_RECV / Global API / #define LIBSSH2_INIT_NO_CRYPTO 0x0001 / * libssh2_init() * * Initialize the libssh2 functions. This typically initialize the * crypto library. It uses a global state, and is not thread safe -- * you must make sure this function is not called concurrently. * * Flags can be: * 0: Normal initialize * LIBSSH2_INIT_NO_CRYPTO: Do not initialize the crypto library (ie. * OPENSSL_add_cipher_algoritms() for OpenSSL * * Returns 0 if succeeded, or a negative value for error. / LIBSSH2_API int libssh2_init(int flags); / * libssh2_exit() * * Exit the libssh2 functions and free's all memory used internal. / LIBSSH2_API void libssh2_exit(void); / * libssh2_free() * * Deallocate memory allocated by earlier call to libssh2 functions. / LIBSSH2_API void libssh2_free(LIBSSH2_SESSION session, void ptr); / * libssh2_session_supported_algs() * * Fills algs with a list of supported acryptographic algorithms. Returns a * non-negative number (number of supported algorithms) on success or a * negative number (an error code) on failure. * * NOTE: on success, algs must be deallocated (by calling libssh2_free) when * not needed anymore / LIBSSH2_API int libssh2_session_supported_algs(LIBSSH2_SESSION session, int method_type, const char **algs); / Session API / LIBSSH2_API LIBSSH2_SESSION libssh2_session_init_ex(LIBSSH2_ALLOC_FUNC((my_alloc)), LIBSSH2_FREE_FUNC((my_free)), LIBSSH2_REALLOC_FUNC((my_realloc)), void abstract); #define libssh2_session_init() libssh2_session_init_ex(NULL, NULL, NULL, NULL) LIBSSH2_API void *libssh2_session_abstract(LIBSSH2_SESSION session); typedef void (libssh2_cb_generic)(void); LIBSSH2_API libssh2_cb_generic * libssh2_session_callback_set2(LIBSSH2_SESSION session, int cbtype, libssh2_cb_generic callback); LIBSSH2_DEPRECATED(1.11.1, "Use libssh2_session_callback_set2()") LIBSSH2_API void libssh2_session_callback_set(LIBSSH2_SESSION session, int cbtype, void callback); LIBSSH2_API int libssh2_session_banner_set(LIBSSH2_SESSION session, const char banner); #ifndef LIBSSH2_NO_DEPRECATED LIBSSH2_DEPRECATED(1.4.0, "Use libssh2_session_banner_set()") LIBSSH2_API int libssh2_banner_set(LIBSSH2_SESSION session, const char banner); LIBSSH2_DEPRECATED(1.2.8, "Use libssh2_session_handshake()") LIBSSH2_API int libssh2_session_startup(LIBSSH2_SESSION session, int sock); #endif LIBSSH2_API int libssh2_session_handshake(LIBSSH2_SESSION session, libssh2_socket_t sock); LIBSSH2_API int libssh2_session_disconnect_ex(LIBSSH2_SESSION session, int reason, const char description, const char lang); #define libssh2_session_disconnect(session, description) \ libssh2_session_disconnect_ex((session), SSH_DISCONNECT_BY_APPLICATION, \ (description), "") LIBSSH2_API int libssh2_session_free(LIBSSH2_SESSION session); LIBSSH2_API const char libssh2_hostkey_hash(LIBSSH2_SESSION session, int hash_type); LIBSSH2_API const char libssh2_session_hostkey(LIBSSH2_SESSION session, size_t len, int type); LIBSSH2_API int libssh2_session_method_pref(LIBSSH2_SESSION session, int method_type, const char prefs); LIBSSH2_API const char libssh2_session_methods(LIBSSH2_SESSION session, int method_type); LIBSSH2_API int libssh2_session_last_error(LIBSSH2_SESSION session, char *errmsg, int errmsg_len, int want_buf); LIBSSH2_API int libssh2_session_last_errno(LIBSSH2_SESSION session); LIBSSH2_API int libssh2_session_set_last_error(LIBSSH2_SESSION session, int errcode, const char errmsg); LIBSSH2_API int libssh2_session_block_directions(LIBSSH2_SESSION session); LIBSSH2_API int libssh2_session_flag(LIBSSH2_SESSION session, int flag, int value); LIBSSH2_API const char libssh2_session_banner_get(LIBSSH2_SESSION session); / Userauth API / LIBSSH2_API char libssh2_userauth_list(LIBSSH2_SESSION session, const char username, unsigned int username_len); LIBSSH2_API int libssh2_userauth_banner(LIBSSH2_SESSION session, char banner); LIBSSH2_API int libssh2_userauth_authenticated(LIBSSH2_SESSION session); LIBSSH2_API int libssh2_userauth_password_ex(LIBSSH2_SESSION session, const char username, unsigned int username_len, const char password, unsigned int password_len, LIBSSH2_PASSWD_CHANGEREQ_FUNC ((passwd_change_cb))); #define libssh2_userauth_password(session, username, password) \ libssh2_userauth_password_ex((session), (username), \ (unsigned int)strlen(username), \ (password), (unsigned int)strlen(password), \ NULL) LIBSSH2_API int libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION session, const char username, unsigned int username_len, const char publickey, const char privatekey, const char passphrase); #define libssh2_userauth_publickey_fromfile(session, username, publickey, \ privatekey, passphrase) \ libssh2_userauth_publickey_fromfile_ex((session), (username), \ (unsigned int)strlen(username), \ (publickey), \ (privatekey), (passphrase)) LIBSSH2_API int libssh2_userauth_publickey(LIBSSH2_SESSION session, const char username, const unsigned char pubkeydata, size_t pubkeydata_len, LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC ((sign_callback)), void abstract); LIBSSH2_API int libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION session, const char username, unsigned int username_len, const char publickey, const char privatekey, const char passphrase, const char hostname, unsigned int hostname_len, const char local_username, unsigned int local_username_len); #define libssh2_userauth_hostbased_fromfile(session, username, publickey, \ privatekey, passphrase, hostname) \ libssh2_userauth_hostbased_fromfile_ex((session), (username), \ (unsigned int)strlen(username), \ (publickey), \ (privatekey), (passphrase), \ (hostname), \ (unsigned int)strlen(hostname), \ (username), \ (unsigned int)strlen(username)) LIBSSH2_API int libssh2_userauth_publickey_frommemory(LIBSSH2_SESSION session, const char username, size_t username_len, const char publickeyfiledata, size_t publickeyfiledata_len, const char privatekeyfiledata, size_t privatekeyfiledata_len, const char passphrase); / * response_callback is provided with filled by library prompts array, * but client must allocate and fill individual responses. Responses * array is already allocated. Responses data will be freed by libssh2 * after callback return, but before subsequent callback invocation. / LIBSSH2_API int libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION session, const char username, unsigned int username_len, LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC ((response_callback))); #define libssh2_userauth_keyboard_interactive(session, username, \ response_callback) \ libssh2_userauth_keyboard_interactive_ex((session), (username), \ (unsigned int)strlen(username), \ (response_callback)) LIBSSH2_API int libssh2_userauth_publickey_sk(LIBSSH2_SESSION session, const char username, size_t username_len, const unsigned char pubkeydata, size_t pubkeydata_len, const char privatekeydata, size_t privatekeydata_len, const char passphrase, LIBSSH2_USERAUTH_SK_SIGN_FUNC ((sign_callback)), void *abstract); LIBSSH2_API int libssh2_poll(LIBSSH2_POLLFD fds, unsigned int nfds, long timeout); /* Channel API / #define LIBSSH2_CHANNEL_WINDOW_DEFAULT (210241024) #define LIBSSH2_CHANNEL_PACKET_DEFAULT 32768 #define LIBSSH2_CHANNEL_MINADJUST 1024 / Extended Data Handling / #define LIBSSH2_CHANNEL_EXTENDED_DATA_NORMAL 0 #define LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE 1 #define LIBSSH2_CHANNEL_EXTENDED_DATA_MERGE 2 #define SSH_EXTENDED_DATA_STDERR 1 / Returned by any function that would block during a read/write operation / #define LIBSSH2CHANNEL_EAGAIN LIBSSH2_ERROR_EAGAIN LIBSSH2_API LIBSSH2_CHANNEL libssh2_channel_open_ex(LIBSSH2_SESSION session, const char channel_type, unsigned int channel_type_len, unsigned int window_size, unsigned int packet_size, const char message, unsigned int message_len); #define libssh2_channel_open_session(session) \ libssh2_channel_open_ex((session), "session", sizeof("session") - 1, \ LIBSSH2_CHANNEL_WINDOW_DEFAULT, \ LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, 0) LIBSSH2_API LIBSSH2_CHANNEL libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION session, const char host, int port, const char shost, int sport); #define libssh2_channel_direct_tcpip(session, host, port) \ libssh2_channel_direct_tcpip_ex((session), (host), (port), "127.0.0.1", 22) LIBSSH2_API LIBSSH2_CHANNEL libssh2_channel_direct_streamlocal_ex(LIBSSH2_SESSION * session, const char socket_path, const char shost, int sport); LIBSSH2_API LIBSSH2_LISTENER * libssh2_channel_forward_listen_ex(LIBSSH2_SESSION session, const char host, int port, int bound_port, int queue_maxsize); #define libssh2_channel_forward_listen(session, port) \ libssh2_channel_forward_listen_ex((session), NULL, (port), NULL, 16) LIBSSH2_API int libssh2_channel_forward_cancel(LIBSSH2_LISTENER listener); LIBSSH2_API LIBSSH2_CHANNEL * libssh2_channel_forward_accept(LIBSSH2_LISTENER listener); LIBSSH2_API int libssh2_channel_setenv_ex(LIBSSH2_CHANNEL channel, const char varname, unsigned int varname_len, const char value, unsigned int value_len); #define libssh2_channel_setenv(channel, varname, value) \ libssh2_channel_setenv_ex((channel), (varname), \ (unsigned int)strlen(varname), (value), \ (unsigned int)strlen(value)) LIBSSH2_API int libssh2_channel_request_auth_agent(LIBSSH2_CHANNEL channel); LIBSSH2_API int libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL channel, const char term, unsigned int term_len, const char modes, unsigned int modes_len, int width, int height, int width_px, int height_px); #define libssh2_channel_request_pty(channel, term) \ libssh2_channel_request_pty_ex((channel), (term), \ (unsigned int)strlen(term), \ NULL, 0, \ LIBSSH2_TERM_WIDTH, \ LIBSSH2_TERM_HEIGHT, \ LIBSSH2_TERM_WIDTH_PX, \ LIBSSH2_TERM_HEIGHT_PX) LIBSSH2_API int libssh2_channel_request_pty_size_ex(LIBSSH2_CHANNEL channel, int width, int height, int width_px, int height_px); #define libssh2_channel_request_pty_size(channel, width, height) \ libssh2_channel_request_pty_size_ex((channel), (width), (height), 0, 0) LIBSSH2_API int libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL channel, int single_connection, const char auth_proto, const char auth_cookie, int screen_number); #define libssh2_channel_x11_req(channel, screen_number) \ libssh2_channel_x11_req_ex((channel), 0, NULL, NULL, (screen_number)) LIBSSH2_API int libssh2_channel_signal_ex(LIBSSH2_CHANNEL channel, const char signame, size_t signame_len); #define libssh2_channel_signal(channel, signame) \ libssh2_channel_signal_ex((channel), signame, strlen(signame)) LIBSSH2_API int libssh2_channel_process_startup(LIBSSH2_CHANNEL channel, const char request, unsigned int request_len, const char message, unsigned int message_len); #define libssh2_channel_shell(channel) \ libssh2_channel_process_startup((channel), "shell", sizeof("shell") - 1, \ NULL, 0) #define libssh2_channel_exec(channel, command) \ libssh2_channel_process_startup((channel), "exec", sizeof("exec") - 1, \ (command), (unsigned int)strlen(command)) #define libssh2_channel_subsystem(channel, subsystem) \ libssh2_channel_process_startup((channel), "subsystem", \ sizeof("subsystem") - 1, (subsystem), \ (unsigned int)strlen(subsystem)) LIBSSH2_API ssize_t libssh2_channel_read_ex(LIBSSH2_CHANNEL channel, int stream_id, char buf, size_t buflen); #define libssh2_channel_read(channel, buf, buflen) \ libssh2_channel_read_ex((channel), 0, \ (buf), (buflen)) #define libssh2_channel_read_stderr(channel, buf, buflen) \ libssh2_channel_read_ex((channel), SSH_EXTENDED_DATA_STDERR, \ (buf), (buflen)) LIBSSH2_API int libssh2_poll_channel_read(LIBSSH2_CHANNEL channel, int extended); LIBSSH2_API unsigned long libssh2_channel_window_read_ex(LIBSSH2_CHANNEL channel, unsigned long read_avail, unsigned long window_size_initial); #define libssh2_channel_window_read(channel) \ libssh2_channel_window_read_ex((channel), NULL, NULL) #ifndef LIBSSH2_NO_DEPRECATED LIBSSH2_DEPRECATED(1.1.0, "Use libssh2_channel_receive_window_adjust2()") LIBSSH2_API unsigned long libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL channel, unsigned long adjustment, unsigned char force); #endif LIBSSH2_API int libssh2_channel_receive_window_adjust2(LIBSSH2_CHANNEL channel, unsigned long adjustment, unsigned char force, unsigned int storewindow); LIBSSH2_API ssize_t libssh2_channel_write_ex(LIBSSH2_CHANNEL channel, int stream_id, const char buf, size_t buflen); #define libssh2_channel_write(channel, buf, buflen) \ libssh2_channel_write_ex((channel), 0, \ (buf), (buflen)) #define libssh2_channel_write_stderr(channel, buf, buflen) \ libssh2_channel_write_ex((channel), SSH_EXTENDED_DATA_STDERR, \ (buf), (buflen)) LIBSSH2_API unsigned long libssh2_channel_window_write_ex(LIBSSH2_CHANNEL channel, unsigned long window_size_initial); #define libssh2_channel_window_write(channel) \ libssh2_channel_window_write_ex((channel), NULL) LIBSSH2_API void libssh2_session_set_blocking(LIBSSH2_SESSION* session, int blocking); LIBSSH2_API int libssh2_session_get_blocking(LIBSSH2_SESSION* session); LIBSSH2_API void libssh2_channel_set_blocking(LIBSSH2_CHANNEL channel, int blocking); LIBSSH2_API void libssh2_session_set_timeout(LIBSSH2_SESSION session, long timeout); LIBSSH2_API long libssh2_session_get_timeout(LIBSSH2_SESSION* session); LIBSSH2_API void libssh2_session_set_read_timeout(LIBSSH2_SESSION* session, long timeout); LIBSSH2_API long libssh2_session_get_read_timeout(LIBSSH2_SESSION* session); #ifndef LIBSSH2_NO_DEPRECATED LIBSSH2_DEPRECATED(1.1.0, "libssh2_channel_handle_extended_data2()") LIBSSH2_API void libssh2_channel_handle_extended_data(LIBSSH2_CHANNEL channel, int ignore_mode); #endif LIBSSH2_API int libssh2_channel_handle_extended_data2(LIBSSH2_CHANNEL channel, int ignore_mode); #ifndef LIBSSH2_NO_DEPRECATED /* libssh2_channel_ignore_extended_data() is defined below for BC with version * 0.1 * * Future uses should use libssh2_channel_handle_extended_data() directly if * LIBSSH2_CHANNEL_EXTENDED_DATA_MERGE is passed, extended data will be read * (FIFO) from the standard data channel / / DEPRECATED since 0.3.0. Use libssh2_channel_handle_extended_data2(). / #define libssh2_channel_ignore_extended_data(channel, ignore) \ libssh2_channel_handle_extended_data((channel), (ignore) ? \ LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE : \ LIBSSH2_CHANNEL_EXTENDED_DATA_NORMAL) #endif #define LIBSSH2_CHANNEL_FLUSH_EXTENDED_DATA -1 #define LIBSSH2_CHANNEL_FLUSH_ALL -2 LIBSSH2_API int libssh2_channel_flush_ex(LIBSSH2_CHANNEL channel, int streamid); #define libssh2_channel_flush(channel) libssh2_channel_flush_ex((channel), 0) #define libssh2_channel_flush_stderr(channel) \ libssh2_channel_flush_ex((channel), SSH_EXTENDED_DATA_STDERR) LIBSSH2_API int libssh2_channel_get_exit_status(LIBSSH2_CHANNEL* channel); LIBSSH2_API int libssh2_channel_get_exit_signal(LIBSSH2_CHANNEL* channel, char *exitsignal, size_t exitsignal_len, char *errmsg, size_t errmsg_len, char *langtag, size_t langtag_len); LIBSSH2_API int libssh2_channel_send_eof(LIBSSH2_CHANNEL channel); LIBSSH2_API int libssh2_channel_eof(LIBSSH2_CHANNEL channel); LIBSSH2_API int libssh2_channel_wait_eof(LIBSSH2_CHANNEL channel); LIBSSH2_API int libssh2_channel_close(LIBSSH2_CHANNEL channel); LIBSSH2_API int libssh2_channel_wait_closed(LIBSSH2_CHANNEL channel); LIBSSH2_API int libssh2_channel_free(LIBSSH2_CHANNEL channel); #ifndef LIBSSH2_NO_DEPRECATED LIBSSH2_DEPRECATED(1.7.0, "Use libssh2_scp_recv2()") LIBSSH2_API LIBSSH2_CHANNEL libssh2_scp_recv(LIBSSH2_SESSION session, const char path, struct stat sb); #endif /* Use libssh2_scp_recv2() for large (> 2GB) file support on windows / LIBSSH2_API LIBSSH2_CHANNEL libssh2_scp_recv2(LIBSSH2_SESSION session, const char path, libssh2_struct_stat sb); LIBSSH2_API LIBSSH2_CHANNEL libssh2_scp_send_ex(LIBSSH2_SESSION session, const char path, int mode, size_t size, long mtime, long atime); LIBSSH2_API LIBSSH2_CHANNEL * libssh2_scp_send64(LIBSSH2_SESSION session, const char path, int mode, libssh2_int64_t size, time_t mtime, time_t atime); #define libssh2_scp_send(session, path, mode, size) \ libssh2_scp_send_ex((session), (path), (mode), (size), 0, 0) /* DEPRECATED / LIBSSH2_API int libssh2_base64_decode(LIBSSH2_SESSION session, char *dest, unsigned int dest_len, const char src, unsigned int src_len); LIBSSH2_API const char libssh2_version(int req_version_num); typedef enum { libssh2_no_crypto = 0, libssh2_openssl, libssh2_gcrypt, libssh2_mbedtls, libssh2_wincng, libssh2_os400qc3 } libssh2_crypto_engine_t; LIBSSH2_API libssh2_crypto_engine_t libssh2_crypto_engine(void); #define HAVE_LIBSSH2_KNOWNHOST_API 0x010101 /* since 1.1.1 / #define HAVE_LIBSSH2_VERSION_API 0x010100 / libssh2_version since 1.1 / #define HAVE_LIBSSH2_CRYPTOENGINE_API 0x011100 / libssh2_crypto_engine since 1.11 / struct libssh2_knownhost { unsigned int magic; / magic stored by the library / void node; /* handle to the internal representation of this host / char name; /* this is NULL if no plain text host name exists / char key; /* key in base64/printable format / int typemask; }; / * libssh2_knownhost_init() * * Init a collection of known hosts. Returns the pointer to a collection. * / LIBSSH2_API LIBSSH2_KNOWNHOSTS libssh2_knownhost_init(LIBSSH2_SESSION session); / * libssh2_knownhost_add() * * Add a host and its associated key to the collection of known hosts. * * The 'type' argument specifies on what format the given host and keys are: * * plain - ascii "hostname.domain.tld" * sha1 - SHA1(<salt> <host>) base64-encoded! * custom - another hash * * If 'sha1' is selected as type, the salt must be provided to the salt * argument. This too base64 encoded. * * The SHA-1 hash is what OpenSSH can be told to use in known_hosts files. If * a custom type is used, salt is ignored and you must provide the host * pre-hashed when checking for it in the libssh2_knownhost_check() function. * * The keylen parameter may be omitted (zero) if the key is provided as a * NULL-terminated base64-encoded string. / / host format (2 bits) / #define LIBSSH2_KNOWNHOST_TYPE_MASK 0xffff #define LIBSSH2_KNOWNHOST_TYPE_PLAIN 1 #define LIBSSH2_KNOWNHOST_TYPE_SHA1 2 / always base64 encoded / #define LIBSSH2_KNOWNHOST_TYPE_CUSTOM 3 / key format (2 bits) / #define LIBSSH2_KNOWNHOST_KEYENC_MASK (3<<16) #define LIBSSH2_KNOWNHOST_KEYENC_RAW (1<<16) #define LIBSSH2_KNOWNHOST_KEYENC_BASE64 (2<<16) / type of key (4 bits) / #define LIBSSH2_KNOWNHOST_KEY_MASK (15<<18) #define LIBSSH2_KNOWNHOST_KEY_SHIFT 18 #define LIBSSH2_KNOWNHOST_KEY_RSA1 (1<<18) #define LIBSSH2_KNOWNHOST_KEY_SSHRSA (2<<18) #define LIBSSH2_KNOWNHOST_KEY_SSHDSS (3<<18) / deprecated / #define LIBSSH2_KNOWNHOST_KEY_ECDSA_256 (4<<18) #define LIBSSH2_KNOWNHOST_KEY_ECDSA_384 (5<<18) #define LIBSSH2_KNOWNHOST_KEY_ECDSA_521 (6<<18) #define LIBSSH2_KNOWNHOST_KEY_ED25519 (7<<18) #define LIBSSH2_KNOWNHOST_KEY_UNKNOWN (15<<18) LIBSSH2_API int libssh2_knownhost_add(LIBSSH2_KNOWNHOSTS hosts, const char host, const char salt, const char key, size_t keylen, int typemask, struct libssh2_knownhost store); / * libssh2_knownhost_addc() * * Add a host and its associated key to the collection of known hosts. * * Takes a comment argument that may be NULL. A NULL comment indicates * there is no comment and the entry will end directly after the key * when written out to a file. An empty string "" comment will indicate an * empty comment which will cause a single space to be written after the key. * * The 'type' argument specifies on what format the given host and keys are: * * plain - ascii "hostname.domain.tld" * sha1 - SHA1(<salt> <host>) base64-encoded! * custom - another hash * * If 'sha1' is selected as type, the salt must be provided to the salt * argument. This too base64 encoded. * * The SHA-1 hash is what OpenSSH can be told to use in known_hosts files. * If a custom type is used, salt is ignored and you must provide the host * pre-hashed when checking for it in the libssh2_knownhost_check() function. * * The keylen parameter may be omitted (zero) if the key is provided as a * NULL-terminated base64-encoded string. / LIBSSH2_API int libssh2_knownhost_addc(LIBSSH2_KNOWNHOSTS hosts, const char host, const char salt, const char key, size_t keylen, const char comment, size_t commentlen, int typemask, struct libssh2_knownhost *store); / * libssh2_knownhost_check() * * Check a host and its associated key against the collection of known hosts. * * The type is the type/format of the given host name. * * plain - ascii "hostname.domain.tld" * custom - prehashed base64 encoded. Note that this cannot use any salts. * * * 'knownhost' may be set to NULL if you don't care about that info. * * Returns: * * LIBSSH2_KNOWNHOST_CHECK_* values, see below * / #define LIBSSH2_KNOWNHOST_CHECK_MATCH 0 #define LIBSSH2_KNOWNHOST_CHECK_MISMATCH 1 #define LIBSSH2_KNOWNHOST_CHECK_NOTFOUND 2 #define LIBSSH2_KNOWNHOST_CHECK_FAILURE 3 LIBSSH2_API int libssh2_knownhost_check(LIBSSH2_KNOWNHOSTS hosts, const char host, const char key, size_t keylen, int typemask, struct libssh2_knownhost *knownhost); / this function is identital to the above one, but also takes a port argument that allows libssh2 to do a better check / LIBSSH2_API int libssh2_knownhost_checkp(LIBSSH2_KNOWNHOSTS hosts, const char host, int port, const char key, size_t keylen, int typemask, struct libssh2_knownhost *knownhost); / * libssh2_knownhost_del() * * Remove a host from the collection of known hosts. The 'entry' struct is * retrieved by a call to libssh2_knownhost_check(). * / LIBSSH2_API int libssh2_knownhost_del(LIBSSH2_KNOWNHOSTS hosts, struct libssh2_knownhost entry); / * libssh2_knownhost_free() * * Free an entire collection of known hosts. * / LIBSSH2_API void libssh2_knownhost_free(LIBSSH2_KNOWNHOSTS hosts); /* * libssh2_knownhost_readline() * * Pass in a line of a file of 'type'. It makes libssh2 read this line. * * LIBSSH2_KNOWNHOST_FILE_OPENSSH is the only supported type. * / LIBSSH2_API int libssh2_knownhost_readline(LIBSSH2_KNOWNHOSTS hosts, const char line, size_t len, int type); / * libssh2_knownhost_readfile() * * Add hosts+key pairs from a given file. * * Returns a negative value for error or number of successfully added hosts. * * This implementation currently only knows one 'type' (openssh), all others * are reserved for future use. / #define LIBSSH2_KNOWNHOST_FILE_OPENSSH 1 LIBSSH2_API int libssh2_knownhost_readfile(LIBSSH2_KNOWNHOSTS hosts, const char filename, int type); / * libssh2_knownhost_writeline() * * Ask libssh2 to convert a known host to an output line for storage. * * Note that this function returns LIBSSH2_ERROR_BUFFER_TOO_SMALL if the given * output buffer is too small to hold the desired output. * * This implementation currently only knows one 'type' (openssh), all others * are reserved for future use. * / LIBSSH2_API int libssh2_knownhost_writeline(LIBSSH2_KNOWNHOSTS hosts, struct libssh2_knownhost known, char buffer, size_t buflen, size_t outlen, / the amount of written data / int type); / * libssh2_knownhost_writefile() * * Write hosts+key pairs to a given file. * * This implementation currently only knows one 'type' (openssh), all others * are reserved for future use. / LIBSSH2_API int libssh2_knownhost_writefile(LIBSSH2_KNOWNHOSTS hosts, const char filename, int type); / * libssh2_knownhost_get() * * Traverse the internal list of known hosts. Pass NULL to 'prev' to get * the first one. Or pass a pointer to the previously returned one to get the * next. * * Returns: * 0 if a fine host was stored in 'store' * 1 if end of hosts * [negative] on errors / LIBSSH2_API int libssh2_knownhost_get(LIBSSH2_KNOWNHOSTS hosts, struct libssh2_knownhost *store, struct libssh2_knownhost prev); #define HAVE_LIBSSH2_AGENT_API 0x010202 /* since 1.2.2 / struct libssh2_agent_publickey { unsigned int magic; / magic stored by the library / void node; /* handle to the internal representation of key / unsigned char blob; /* public key blob / size_t blob_len; / length of the public key blob / char comment; /* comment in printable format / }; / * libssh2_agent_init() * * Init an ssh-agent handle. Returns the pointer to the handle. * / LIBSSH2_API LIBSSH2_AGENT libssh2_agent_init(LIBSSH2_SESSION session); / * libssh2_agent_connect() * * Connect to an ssh-agent. * * Returns 0 if succeeded, or a negative value for error. / LIBSSH2_API int libssh2_agent_connect(LIBSSH2_AGENT agent); /* * libssh2_agent_list_identities() * * Request an ssh-agent to list identities. * * Returns 0 if succeeded, or a negative value for error. / LIBSSH2_API int libssh2_agent_list_identities(LIBSSH2_AGENT agent); /* * libssh2_agent_get_identity() * * Traverse the internal list of public keys. Pass NULL to 'prev' to get * the first one. Or pass a pointer to the previously returned one to get the * next. * * Returns: * 0 if a fine public key was stored in 'store' * 1 if end of public keys * [negative] on errors / LIBSSH2_API int libssh2_agent_get_identity(LIBSSH2_AGENT agent, struct libssh2_agent_publickey *store, struct libssh2_agent_publickey prev); /* * libssh2_agent_userauth() * * Do publickey user authentication with the help of ssh-agent. * * Returns 0 if succeeded, or a negative value for error. / LIBSSH2_API int libssh2_agent_userauth(LIBSSH2_AGENT agent, const char username, struct libssh2_agent_publickey identity); /* * libssh2_agent_sign() * * Sign a payload using a system-installed ssh-agent. * * Returns 0 if succeeded, or a negative value for error. / LIBSSH2_API int libssh2_agent_sign(LIBSSH2_AGENT agent, struct libssh2_agent_publickey identity, unsigned char sig, size_t s_len, const unsigned char data, size_t d_len, const char method, unsigned int method_len); /* * libssh2_agent_disconnect() * * Close a connection to an ssh-agent. * * Returns 0 if succeeded, or a negative value for error. / LIBSSH2_API int libssh2_agent_disconnect(LIBSSH2_AGENT agent); /* * libssh2_agent_free() * * Free an ssh-agent handle. This function also frees the internal * collection of public keys. / LIBSSH2_API void libssh2_agent_free(LIBSSH2_AGENT agent); /* * libssh2_agent_set_identity_path() * * Allows a custom agent identity socket path beyond SSH_AUTH_SOCK env * / LIBSSH2_API void libssh2_agent_set_identity_path(LIBSSH2_AGENT agent, const char path); / * libssh2_agent_get_identity_path() * * Returns the custom agent identity socket path if set * / LIBSSH2_API const char libssh2_agent_get_identity_path(LIBSSH2_AGENT agent); / * libssh2_keepalive_config() * * Set how often keepalive messages should be sent. WANT_REPLY * indicates whether the keepalive messages should request a response * from the server. INTERVAL is number of seconds that can pass * without any I/O, use 0 (the default) to disable keepalives. To * avoid some busy-loop corner-cases, if you specify an interval of 1 * it will be treated as 2. * * Note that non-blocking applications are responsible for sending the * keepalive messages using libssh2_keepalive_send(). / LIBSSH2_API void libssh2_keepalive_config(LIBSSH2_SESSION session, int want_reply, unsigned int interval); /* * libssh2_keepalive_send() * * Send a keepalive message if needed. SECONDS_TO_NEXT indicates how * many seconds you can sleep after this call before you need to call * it again. Returns 0 on success, or LIBSSH2_ERROR_SOCKET_SEND on * I/O errors. / LIBSSH2_API int libssh2_keepalive_send(LIBSSH2_SESSION session, int seconds_to_next); / NOTE NOTE NOTE libssh2_trace() has no function in builds that aren't built with debug enabled / LIBSSH2_API int libssh2_trace(LIBSSH2_SESSION session, int bitmask); #define LIBSSH2_TRACE_TRANS (1<<1) #define LIBSSH2_TRACE_KEX (1<<2) #define LIBSSH2_TRACE_AUTH (1<<3) #define LIBSSH2_TRACE_CONN (1<<4) #define LIBSSH2_TRACE_SCP (1<<5) #define LIBSSH2_TRACE_SFTP (1<<6) #define LIBSSH2_TRACE_ERROR (1<<7) #define LIBSSH2_TRACE_PUBLICKEY (1<<8) #define LIBSSH2_TRACE_SOCKET (1<<9) typedef void (libssh2_trace_handler_func)(LIBSSH2_SESSION, void , const char , size_t); LIBSSH2_API int libssh2_trace_sethandler(LIBSSH2_SESSION session, void context, libssh2_trace_handler_func callback); #ifdef __cplusplus } /* extern "C" / #endif #endif / !RC_INVOKED / #endif / LIBSSH2_H */	59.24 KB	2024-10-16 08:03
📄 libssh2_publickey.h /* Copyright (C) Sara Golemon <sarag@libssh2.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: * * 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. * * Neither the name of the copyright holder nor the names * of any other contributors may be used to endorse or * promote products derived from this software without * specific prior written permission. * * 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. / / Note: This include file is only needed for using the * publickey SUBSYSTEM which is not the same as publickey * authentication. For authentication you only need libssh2.h * * For more information on the publickey subsystem, * refer to IETF draft: secsh-publickey * * SPDX-License-Identifier: BSD-3-Clause / #ifndef LIBSSH2_PUBLICKEY_H #define LIBSSH2_PUBLICKEY_H 1 #include "libssh2.h" typedef struct _LIBSSH2_PUBLICKEY LIBSSH2_PUBLICKEY; typedef struct _libssh2_publickey_attribute { const char name; unsigned long name_len; const char value; unsigned long value_len; char mandatory; } libssh2_publickey_attribute; typedef struct _libssh2_publickey_list { unsigned char packet; /* For freeing / const unsigned char name; unsigned long name_len; const unsigned char blob; unsigned long blob_len; unsigned long num_attrs; libssh2_publickey_attribute attrs; /* free me / } libssh2_publickey_list; / Generally use the first macro here, but if both name and value are string literals, you can use _fast() to take advantage of preprocessing / #define libssh2_publickey_attribute(name, value, mandatory) \ { (name), strlen(name), (value), strlen(value), (mandatory) }, #define libssh2_publickey_attribute_fast(name, value, mandatory) \ { (name), sizeof(name) - 1, (value), sizeof(value) - 1, (mandatory) }, #ifdef __cplusplus extern "C" { #endif / Publickey Subsystem / LIBSSH2_API LIBSSH2_PUBLICKEY libssh2_publickey_init(LIBSSH2_SESSION session); LIBSSH2_API int libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY pkey, const unsigned char name, unsigned long name_len, const unsigned char blob, unsigned long blob_len, char overwrite, unsigned long num_attrs, const libssh2_publickey_attribute attrs[]); #define libssh2_publickey_add(pkey, name, blob, blob_len, overwrite, \ num_attrs, attrs) \ libssh2_publickey_add_ex((pkey), \ (name), strlen(name), \ (blob), (blob_len), \ (overwrite), (num_attrs), (attrs)) LIBSSH2_API int libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY pkey, const unsigned char name, unsigned long name_len, const unsigned char blob, unsigned long blob_len); #define libssh2_publickey_remove(pkey, name, blob, blob_len) \ libssh2_publickey_remove_ex((pkey), \ (name), strlen(name), \ (blob), (blob_len)) LIBSSH2_API int libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY pkey, unsigned long num_keys, libssh2_publickey_list pkey_list); LIBSSH2_API void libssh2_publickey_list_free(LIBSSH2_PUBLICKEY pkey, libssh2_publickey_list pkey_list); LIBSSH2_API int libssh2_publickey_shutdown(LIBSSH2_PUBLICKEY pkey); #ifdef __cplusplus } /* extern "C" / #endif #endif / LIBSSH2_PUBLICKEY_H */	4.83 KB	2024-10-16 08:03
📄 libssh2_sftp.h /* Copyright (C) Sara Golemon <sarag@libssh2.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: * * 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. * * Neither the name of the copyright holder nor the names * of any other contributors may be used to endorse or * promote products derived from this software without * specific prior written permission. * * 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. * * SPDX-License-Identifier: BSD-3-Clause / #ifndef LIBSSH2_SFTP_H #define LIBSSH2_SFTP_H 1 #include "libssh2.h" #ifndef _WIN32 #include <unistd.h> #endif #ifdef __cplusplus extern "C" { #endif / Note: Version 6 was documented at the time of writing * However it was marked as "DO NOT IMPLEMENT" due to pending changes * * Let's start with Version 3 (The version found in OpenSSH) and go from there / #define LIBSSH2_SFTP_VERSION 3 typedef struct _LIBSSH2_SFTP LIBSSH2_SFTP; typedef struct _LIBSSH2_SFTP_HANDLE LIBSSH2_SFTP_HANDLE; typedef struct _LIBSSH2_SFTP_ATTRIBUTES LIBSSH2_SFTP_ATTRIBUTES; typedef struct _LIBSSH2_SFTP_STATVFS LIBSSH2_SFTP_STATVFS; / Flags for open_ex() / #define LIBSSH2_SFTP_OPENFILE 0 #define LIBSSH2_SFTP_OPENDIR 1 / Flags for rename_ex() / #define LIBSSH2_SFTP_RENAME_OVERWRITE 0x00000001 #define LIBSSH2_SFTP_RENAME_ATOMIC 0x00000002 #define LIBSSH2_SFTP_RENAME_NATIVE 0x00000004 / Flags for stat_ex() / #define LIBSSH2_SFTP_STAT 0 #define LIBSSH2_SFTP_LSTAT 1 #define LIBSSH2_SFTP_SETSTAT 2 / Flags for symlink_ex() / #define LIBSSH2_SFTP_SYMLINK 0 #define LIBSSH2_SFTP_READLINK 1 #define LIBSSH2_SFTP_REALPATH 2 / Flags for sftp_mkdir() / #define LIBSSH2_SFTP_DEFAULT_MODE -1 / SFTP attribute flag bits / #define LIBSSH2_SFTP_ATTR_SIZE 0x00000001 #define LIBSSH2_SFTP_ATTR_UIDGID 0x00000002 #define LIBSSH2_SFTP_ATTR_PERMISSIONS 0x00000004 #define LIBSSH2_SFTP_ATTR_ACMODTIME 0x00000008 #define LIBSSH2_SFTP_ATTR_EXTENDED 0x80000000 / SFTP statvfs flag bits / #define LIBSSH2_SFTP_ST_RDONLY 0x00000001 #define LIBSSH2_SFTP_ST_NOSUID 0x00000002 struct _LIBSSH2_SFTP_ATTRIBUTES { / If flags & ATTR_* bit is set, then the value in this struct will be * meaningful Otherwise it should be ignored / unsigned long flags; libssh2_uint64_t filesize; unsigned long uid, gid; unsigned long permissions; unsigned long atime, mtime; }; struct _LIBSSH2_SFTP_STATVFS { libssh2_uint64_t f_bsize; / file system block size / libssh2_uint64_t f_frsize; / fragment size / libssh2_uint64_t f_blocks; / size of fs in f_frsize units / libssh2_uint64_t f_bfree; / # free blocks / libssh2_uint64_t f_bavail; / # free blocks for non-root / libssh2_uint64_t f_files; / # inodes / libssh2_uint64_t f_ffree; / # free inodes / libssh2_uint64_t f_favail; / # free inodes for non-root / libssh2_uint64_t f_fsid; / file system ID / libssh2_uint64_t f_flag; / mount flags / libssh2_uint64_t f_namemax; / maximum filename length / }; / SFTP filetypes / #define LIBSSH2_SFTP_TYPE_REGULAR 1 #define LIBSSH2_SFTP_TYPE_DIRECTORY 2 #define LIBSSH2_SFTP_TYPE_SYMLINK 3 #define LIBSSH2_SFTP_TYPE_SPECIAL 4 #define LIBSSH2_SFTP_TYPE_UNKNOWN 5 #define LIBSSH2_SFTP_TYPE_SOCKET 6 #define LIBSSH2_SFTP_TYPE_CHAR_DEVICE 7 #define LIBSSH2_SFTP_TYPE_BLOCK_DEVICE 8 #define LIBSSH2_SFTP_TYPE_FIFO 9 / * Reproduce the POSIX file modes here for systems that are not POSIX * compliant. * * These is used in "permissions" of "struct _LIBSSH2_SFTP_ATTRIBUTES" / / File type / #define LIBSSH2_SFTP_S_IFMT 0170000 / type of file mask / #define LIBSSH2_SFTP_S_IFIFO 0010000 / named pipe (fifo) / #define LIBSSH2_SFTP_S_IFCHR 0020000 / character special / #define LIBSSH2_SFTP_S_IFDIR 0040000 / directory / #define LIBSSH2_SFTP_S_IFBLK 0060000 / block special / #define LIBSSH2_SFTP_S_IFREG 0100000 / regular / #define LIBSSH2_SFTP_S_IFLNK 0120000 / symbolic link / #define LIBSSH2_SFTP_S_IFSOCK 0140000 / socket / / File mode / / Read, write, execute/search by owner / #define LIBSSH2_SFTP_S_IRWXU 0000700 / RWX mask for owner / #define LIBSSH2_SFTP_S_IRUSR 0000400 / R for owner / #define LIBSSH2_SFTP_S_IWUSR 0000200 / W for owner / #define LIBSSH2_SFTP_S_IXUSR 0000100 / X for owner / / Read, write, execute/search by group / #define LIBSSH2_SFTP_S_IRWXG 0000070 / RWX mask for group / #define LIBSSH2_SFTP_S_IRGRP 0000040 / R for group / #define LIBSSH2_SFTP_S_IWGRP 0000020 / W for group / #define LIBSSH2_SFTP_S_IXGRP 0000010 / X for group / / Read, write, execute/search by others / #define LIBSSH2_SFTP_S_IRWXO 0000007 / RWX mask for other / #define LIBSSH2_SFTP_S_IROTH 0000004 / R for other / #define LIBSSH2_SFTP_S_IWOTH 0000002 / W for other / #define LIBSSH2_SFTP_S_IXOTH 0000001 / X for other / / macros to check for specific file types, added in 1.2.5 / #define LIBSSH2_SFTP_S_ISLNK(m) \ (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK) #define LIBSSH2_SFTP_S_ISREG(m) \ (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG) #define LIBSSH2_SFTP_S_ISDIR(m) \ (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR) #define LIBSSH2_SFTP_S_ISCHR(m) \ (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR) #define LIBSSH2_SFTP_S_ISBLK(m) \ (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK) #define LIBSSH2_SFTP_S_ISFIFO(m) \ (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO) #define LIBSSH2_SFTP_S_ISSOCK(m) \ (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK) / SFTP File Transfer Flags -- (e.g. flags parameter to sftp_open()) * Danger will robinson... APPEND doesn't have any effect on OpenSSH servers / #define LIBSSH2_FXF_READ 0x00000001 #define LIBSSH2_FXF_WRITE 0x00000002 #define LIBSSH2_FXF_APPEND 0x00000004 #define LIBSSH2_FXF_CREAT 0x00000008 #define LIBSSH2_FXF_TRUNC 0x00000010 #define LIBSSH2_FXF_EXCL 0x00000020 / SFTP Status Codes (returned by libssh2_sftp_last_error() ) / #define LIBSSH2_FX_OK 0UL #define LIBSSH2_FX_EOF 1UL #define LIBSSH2_FX_NO_SUCH_FILE 2UL #define LIBSSH2_FX_PERMISSION_DENIED 3UL #define LIBSSH2_FX_FAILURE 4UL #define LIBSSH2_FX_BAD_MESSAGE 5UL #define LIBSSH2_FX_NO_CONNECTION 6UL #define LIBSSH2_FX_CONNECTION_LOST 7UL #define LIBSSH2_FX_OP_UNSUPPORTED 8UL #define LIBSSH2_FX_INVALID_HANDLE 9UL #define LIBSSH2_FX_NO_SUCH_PATH 10UL #define LIBSSH2_FX_FILE_ALREADY_EXISTS 11UL #define LIBSSH2_FX_WRITE_PROTECT 12UL #define LIBSSH2_FX_NO_MEDIA 13UL #define LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM 14UL #define LIBSSH2_FX_QUOTA_EXCEEDED 15UL #define LIBSSH2_FX_UNKNOWN_PRINCIPLE 16UL / Initial mis-spelling / #define LIBSSH2_FX_UNKNOWN_PRINCIPAL 16UL #define LIBSSH2_FX_LOCK_CONFlICT 17UL / Initial mis-spelling / #define LIBSSH2_FX_LOCK_CONFLICT 17UL #define LIBSSH2_FX_DIR_NOT_EMPTY 18UL #define LIBSSH2_FX_NOT_A_DIRECTORY 19UL #define LIBSSH2_FX_INVALID_FILENAME 20UL #define LIBSSH2_FX_LINK_LOOP 21UL / Returned by any function that would block during a read/write operation / #define LIBSSH2SFTP_EAGAIN LIBSSH2_ERROR_EAGAIN / SFTP API / LIBSSH2_API LIBSSH2_SFTP libssh2_sftp_init(LIBSSH2_SESSION session); LIBSSH2_API int libssh2_sftp_shutdown(LIBSSH2_SFTP sftp); LIBSSH2_API unsigned long libssh2_sftp_last_error(LIBSSH2_SFTP sftp); LIBSSH2_API LIBSSH2_CHANNEL libssh2_sftp_get_channel(LIBSSH2_SFTP sftp); / File / Directory Ops / LIBSSH2_API LIBSSH2_SFTP_HANDLE libssh2_sftp_open_ex(LIBSSH2_SFTP sftp, const char filename, unsigned int filename_len, unsigned long flags, long mode, int open_type); #define libssh2_sftp_open(sftp, filename, flags, mode) \ libssh2_sftp_open_ex((sftp), \ (filename), (unsigned int)strlen(filename), \ (flags), (mode), LIBSSH2_SFTP_OPENFILE) #define libssh2_sftp_opendir(sftp, path) \ libssh2_sftp_open_ex((sftp), \ (path), (unsigned int)strlen(path), \ 0, 0, LIBSSH2_SFTP_OPENDIR) LIBSSH2_API LIBSSH2_SFTP_HANDLE * libssh2_sftp_open_ex_r(LIBSSH2_SFTP sftp, const char filename, size_t filename_len, unsigned long flags, long mode, int open_type, LIBSSH2_SFTP_ATTRIBUTES attrs); #define libssh2_sftp_open_r(sftp, filename, flags, mode, attrs) \ libssh2_sftp_open_ex_r((sftp), (filename), strlen(filename), \ (flags), (mode), LIBSSH2_SFTP_OPENFILE, \ (attrs)) LIBSSH2_API ssize_t libssh2_sftp_read(LIBSSH2_SFTP_HANDLE handle, char buffer, size_t buffer_maxlen); LIBSSH2_API int libssh2_sftp_readdir_ex(LIBSSH2_SFTP_HANDLE handle, \ char buffer, size_t buffer_maxlen, char longentry, size_t longentry_maxlen, LIBSSH2_SFTP_ATTRIBUTES attrs); #define libssh2_sftp_readdir(handle, buffer, buffer_maxlen, attrs) \ libssh2_sftp_readdir_ex((handle), (buffer), (buffer_maxlen), NULL, 0, \ (attrs)) LIBSSH2_API ssize_t libssh2_sftp_write(LIBSSH2_SFTP_HANDLE handle, const char buffer, size_t count); LIBSSH2_API int libssh2_sftp_fsync(LIBSSH2_SFTP_HANDLE handle); LIBSSH2_API int libssh2_sftp_close_handle(LIBSSH2_SFTP_HANDLE handle); #define libssh2_sftp_close(handle) libssh2_sftp_close_handle(handle) #define libssh2_sftp_closedir(handle) libssh2_sftp_close_handle(handle) LIBSSH2_API void libssh2_sftp_seek(LIBSSH2_SFTP_HANDLE handle, size_t offset); LIBSSH2_API void libssh2_sftp_seek64(LIBSSH2_SFTP_HANDLE handle, libssh2_uint64_t offset); #define libssh2_sftp_rewind(handle) libssh2_sftp_seek64((handle), 0) LIBSSH2_API size_t libssh2_sftp_tell(LIBSSH2_SFTP_HANDLE handle); LIBSSH2_API libssh2_uint64_t libssh2_sftp_tell64(LIBSSH2_SFTP_HANDLE handle); LIBSSH2_API int libssh2_sftp_fstat_ex(LIBSSH2_SFTP_HANDLE handle, LIBSSH2_SFTP_ATTRIBUTES attrs, int setstat); #define libssh2_sftp_fstat(handle, attrs) \ libssh2_sftp_fstat_ex((handle), (attrs), 0) #define libssh2_sftp_fsetstat(handle, attrs) \ libssh2_sftp_fstat_ex((handle), (attrs), 1) / Miscellaneous Ops / LIBSSH2_API int libssh2_sftp_rename_ex(LIBSSH2_SFTP sftp, const char source_filename, unsigned int srouce_filename_len, const char dest_filename, unsigned int dest_filename_len, long flags); #define libssh2_sftp_rename(sftp, sourcefile, destfile) \ libssh2_sftp_rename_ex((sftp), \ (sourcefile), (unsigned int)strlen(sourcefile), \ (destfile), (unsigned int)strlen(destfile), \ LIBSSH2_SFTP_RENAME_OVERWRITE \| \ LIBSSH2_SFTP_RENAME_ATOMIC \| \ LIBSSH2_SFTP_RENAME_NATIVE) LIBSSH2_API int libssh2_sftp_posix_rename_ex(LIBSSH2_SFTP sftp, const char source_filename, size_t srouce_filename_len, const char dest_filename, size_t dest_filename_len); #define libssh2_sftp_posix_rename(sftp, sourcefile, destfile) \ libssh2_sftp_posix_rename_ex((sftp), (sourcefile), strlen(sourcefile), \ (destfile), strlen(destfile)) LIBSSH2_API int libssh2_sftp_unlink_ex(LIBSSH2_SFTP sftp, const char filename, unsigned int filename_len); #define libssh2_sftp_unlink(sftp, filename) \ libssh2_sftp_unlink_ex((sftp), (filename), (unsigned int)strlen(filename)) LIBSSH2_API int libssh2_sftp_fstatvfs(LIBSSH2_SFTP_HANDLE handle, LIBSSH2_SFTP_STATVFS st); LIBSSH2_API int libssh2_sftp_statvfs(LIBSSH2_SFTP sftp, const char path, size_t path_len, LIBSSH2_SFTP_STATVFS st); LIBSSH2_API int libssh2_sftp_mkdir_ex(LIBSSH2_SFTP sftp, const char path, unsigned int path_len, long mode); #define libssh2_sftp_mkdir(sftp, path, mode) \ libssh2_sftp_mkdir_ex((sftp), (path), (unsigned int)strlen(path), (mode)) LIBSSH2_API int libssh2_sftp_rmdir_ex(LIBSSH2_SFTP sftp, const char path, unsigned int path_len); #define libssh2_sftp_rmdir(sftp, path) \ libssh2_sftp_rmdir_ex((sftp), (path), (unsigned int)strlen(path)) LIBSSH2_API int libssh2_sftp_stat_ex(LIBSSH2_SFTP sftp, const char path, unsigned int path_len, int stat_type, LIBSSH2_SFTP_ATTRIBUTES attrs); #define libssh2_sftp_stat(sftp, path, attrs) \ libssh2_sftp_stat_ex((sftp), (path), (unsigned int)strlen(path), \ LIBSSH2_SFTP_STAT, (attrs)) #define libssh2_sftp_lstat(sftp, path, attrs) \ libssh2_sftp_stat_ex((sftp), (path), (unsigned int)strlen(path), \ LIBSSH2_SFTP_LSTAT, (attrs)) #define libssh2_sftp_setstat(sftp, path, attrs) \ libssh2_sftp_stat_ex((sftp), (path), (unsigned int)strlen(path), \ LIBSSH2_SFTP_SETSTAT, (attrs)) LIBSSH2_API int libssh2_sftp_symlink_ex(LIBSSH2_SFTP sftp, const char path, unsigned int path_len, char target, unsigned int target_len, int link_type); #define libssh2_sftp_symlink(sftp, orig, linkpath) \ libssh2_sftp_symlink_ex((sftp), \ (orig), (unsigned int)strlen(orig), \ (linkpath), (unsigned int)strlen(linkpath), \ LIBSSH2_SFTP_SYMLINK) #define libssh2_sftp_readlink(sftp, path, target, maxlen) \ libssh2_sftp_symlink_ex((sftp), \ (path), (unsigned int)strlen(path), \ (target), (maxlen), \ LIBSSH2_SFTP_READLINK) #define libssh2_sftp_realpath(sftp, path, target, maxlen) \ libssh2_sftp_symlink_ex((sftp), \ (path), (unsigned int)strlen(path), \ (target), (maxlen), \ LIBSSH2_SFTP_REALPATH) #ifdef __cplusplus } /* extern "C" / #endif #endif / LIBSSH2_SFTP_H */	16.96 KB	2024-10-16 08:03
📁 libxml2	-	2025-12-01 03:41
📄 limits.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99 Standard: 7.10/5.2.4.2.1 Sizes of integer types <limits.h> / #ifndef _LIBC_LIMITS_H_ #define _LIBC_LIMITS_H_ 1 #define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION #include <bits/libc-header-start.h> / Maximum length of any multibyte character in any locale. We define this value here since the gcc header does not define the correct value. / #define MB_LEN_MAX 16 / If we are not using GNU CC we have to define all the symbols ourself. Otherwise use gcc's definitions (see below). / #if !defined __GNUC__ \|\| __GNUC__ < 2 / We only protect from multiple inclusion here, because all the other #include's protect themselves, and in GCC 2 we may #include_next through multiple copies of this file before we get to GCC's. / # ifndef _LIMITS_H # define _LIMITS_H 1 #include <bits/wordsize.h> / We don't have #include_next. Define ANSI <limits.h> for standard 32-bit words. / / These assume 8-bit `char's, 16-bit `short int's, and 32-bit `int's and `long int's. / / Number of bits in a `char'. / # define CHAR_BIT 8 / Minimum and maximum values a `signed char' can hold. / # define SCHAR_MIN (-128) # define SCHAR_MAX 127 / Maximum value an `unsigned char' can hold. (Minimum is 0.) / # define UCHAR_MAX 255 / Minimum and maximum values a `char' can hold. / # ifdef __CHAR_UNSIGNED__ # define CHAR_MIN 0 # define CHAR_MAX UCHAR_MAX # else # define CHAR_MIN SCHAR_MIN # define CHAR_MAX SCHAR_MAX # endif / Minimum and maximum values a `signed short int' can hold. / # define SHRT_MIN (-32768) # define SHRT_MAX 32767 / Maximum value an `unsigned short int' can hold. (Minimum is 0.) / # define USHRT_MAX 65535 / Minimum and maximum values a `signed int' can hold. / # define INT_MIN (-INT_MAX - 1) # define INT_MAX 2147483647 / Maximum value an `unsigned int' can hold. (Minimum is 0.) / # define UINT_MAX 4294967295U / Minimum and maximum values a `signed long int' can hold. / # if __WORDSIZE == 64 # define LONG_MAX 9223372036854775807L # else # define LONG_MAX 2147483647L # endif # define LONG_MIN (-LONG_MAX - 1L) / Maximum value an `unsigned long int' can hold. (Minimum is 0.) / # if __WORDSIZE == 64 # define ULONG_MAX 18446744073709551615UL # else # define ULONG_MAX 4294967295UL # endif # ifdef __USE_ISOC99 / Minimum and maximum values a `signed long long int' can hold. / # define LLONG_MAX 9223372036854775807LL # define LLONG_MIN (-LLONG_MAX - 1LL) / Maximum value an `unsigned long long int' can hold. (Minimum is 0.) / # define ULLONG_MAX 18446744073709551615ULL # endif / ISO C99 / # endif / limits.h / #endif / GCC 2. / #endif / !_LIBC_LIMITS_H_ / / Get the compiler's limits.h, which defines almost all the ISO constants. We put this #include_next outside the double inclusion check because it should be possible to include this file more than once and still get the definitions from gcc's header. / #if defined __GNUC__ && !defined _GCC_LIMITS_H_ / `_GCC_LIMITS_H_' is what GCC's file defines. / # include_next <limits.h> #endif / The <limits.h> files in some gcc versions don't define LLONG_MIN, LLONG_MAX, and ULLONG_MAX. Instead only the values gcc defined for ages are available. / #if defined __USE_ISOC99 && defined __GNUC__ # ifndef LLONG_MIN # define LLONG_MIN (-LLONG_MAX-1) # endif # ifndef LLONG_MAX # define LLONG_MAX __LONG_LONG_MAX__ # endif # ifndef ULLONG_MAX # define ULLONG_MAX (LLONG_MAX 2ULL + 1) # endif #endif /* The integer width macros are not defined by GCC's <limits.h> before GCC 7, or if _GNU_SOURCE rather than __STDC_WANT_IEC_60559_BFP_EXT__ is used to enable this feature. / #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) # ifndef CHAR_WIDTH # define CHAR_WIDTH 8 # endif # ifndef SCHAR_WIDTH # define SCHAR_WIDTH 8 # endif # ifndef UCHAR_WIDTH # define UCHAR_WIDTH 8 # endif # ifndef SHRT_WIDTH # define SHRT_WIDTH 16 # endif # ifndef USHRT_WIDTH # define USHRT_WIDTH 16 # endif # ifndef INT_WIDTH # define INT_WIDTH 32 # endif # ifndef UINT_WIDTH # define UINT_WIDTH 32 # endif # ifndef LONG_WIDTH # define LONG_WIDTH __WORDSIZE # endif # ifndef ULONG_WIDTH # define ULONG_WIDTH __WORDSIZE # endif # ifndef LLONG_WIDTH # define LLONG_WIDTH 64 # endif # ifndef ULLONG_WIDTH # define ULLONG_WIDTH 64 # endif #endif / Use IEC_60559_BFP_EXT. / / The macros for _Bool are not defined by GCC's <limits.h> before GCC 11, or if _GNU_SOURCE is defined rather than enabling C2x support with -std. / #if __GLIBC_USE (ISOC2X) # ifndef BOOL_MAX # define BOOL_MAX 1 # endif # ifndef BOOL_WIDTH # define BOOL_WIDTH 1 # endif #endif #ifdef __USE_POSIX / POSIX adds things to <limits.h>. */ # include <bits/posix1_lim.h> #endif #ifdef __USE_POSIX2 # include <bits/posix2_lim.h> #endif #ifdef __USE_XOPEN # include <bits/xopen_lim.h> #endif	5.57 KB	2026-02-17 11:01
📄 link.h /* Data structure for communication from the run-time dynamic linker for loaded ELF shared objects. Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _LINK_H #define _LINK_H 1 #include <features.h> #include <elf.h> #include <dlfcn.h> #include <sys/types.h> / We use this macro to refer to ELF types independent of the native wordsize. `ElfW(TYPE)' is used in place of `Elf32_TYPE' or `Elf64_TYPE'. / #define ElfW(type) _ElfW (Elf, __ELF_NATIVE_CLASS, type) #define _ElfW(e,w,t) _ElfW_1 (e, w, _##t) #define _ElfW_1(e,w,t) e##w##t #include <bits/elfclass.h> / Defines __ELF_NATIVE_CLASS. / #include <bits/link.h> / The legacy rendezvous structure used by the run-time dynamic linker to communicate details of shared object loading to the debugger. / struct r_debug { / Version number for this protocol. It should be greater than 0. / int r_version; struct link_map r_map; /* Head of the chain of loaded objects. / / This is the address of a function internal to the run-time linker, that will always be called when the linker begins to map in a library or unmap it, and again when the mapping change is complete. The debugger can set a breakpoint at this address if it wants to notice shared object mapping changes. / ElfW(Addr) r_brk; enum { / This state value describes the mapping change taking place when the `r_brk' address is called. / RT_CONSISTENT, / Mapping change is complete. / RT_ADD, / Beginning to add a new object. / RT_DELETE / Beginning to remove an object mapping. / } r_state; ElfW(Addr) r_ldbase; / Base address the linker is loaded at. / }; / This is the symbol of that structure provided by the dynamic linker. / extern struct r_debug _r_debug; / The extended rendezvous structure used by the run-time dynamic linker to communicate details of shared object loading to the debugger. If the executable's dynamic section has a DT_DEBUG element, the run-time linker sets that element's value to the address where this structure can be found. / struct r_debug_extended { struct r_debug base; / The following field is added by r_version == 2. / / Link to the next r_debug_extended structure. Each r_debug_extended structure represents a different namespace. The first r_debug_extended structure is for the default namespace. / struct r_debug_extended r_next; }; /* This symbol refers to the "dynamic structure" in the `.dynamic' section of whatever module refers to `_DYNAMIC'. So, to find its own `struct r_debug_extended', a program could do: for (dyn = _DYNAMIC; dyn->d_tag != DT_NULL; ++dyn) if (dyn->d_tag == DT_DEBUG) r_debug_extended = (struct r_debug_extended ) dyn->d_un.d_ptr; / extern ElfW(Dyn) _DYNAMIC[]; /* Structure describing a loaded shared object. The `l_next' and `l_prev' members form a chain of all the shared objects loaded at startup. These data structures exist in space used by the run-time dynamic linker; modifying them may have disastrous results. / struct link_map { / These first few members are part of the protocol with the debugger. This is the same format used in SVR4. / ElfW(Addr) l_addr; / Difference between the address in the ELF file and the addresses in memory. / char l_name; /* Absolute file name object was found in. / ElfW(Dyn) l_ld; /* Dynamic section of the shared object. / struct link_map l_next, l_prev; / Chain of loaded objects. / }; #ifdef __USE_GNU / Version numbers for la_version handshake interface. / #include <bits/link_lavcurrent.h> / Activity types signaled through la_activity. / enum { LA_ACT_CONSISTENT, / Link map consistent again. / LA_ACT_ADD, / New object will be added. / LA_ACT_DELETE / Objects will be removed. / }; / Values representing origin of name for dynamic loading. / enum { LA_SER_ORIG = 0x01, / Original name. / LA_SER_LIBPATH = 0x02, / Directory from LD_LIBRARY_PATH. / LA_SER_RUNPATH = 0x04, / Directory from RPATH/RUNPATH. / LA_SER_CONFIG = 0x08, / Found through ldconfig. / LA_SER_DEFAULT = 0x40, / Default directory. / LA_SER_SECURE = 0x80 / Unused. / }; / Values for la_objopen return value. / enum { LA_FLG_BINDTO = 0x01, / Audit symbols bound to this object. / LA_FLG_BINDFROM = 0x02 / Audit symbols bound from this object. / }; / Values for la_symbind flags parameter. / enum { LA_SYMB_NOPLTENTER = 0x01, / la_pltenter will not be called. / LA_SYMB_NOPLTEXIT = 0x02, / la_pltexit will not be called. / LA_SYMB_STRUCTCALL = 0x04, / Return value is a structure. / LA_SYMB_DLSYM = 0x08, / Binding due to dlsym call. / LA_SYMB_ALTVALUE = 0x10 / Value has been changed by a previous la_symbind call. / }; struct dl_phdr_info { ElfW(Addr) dlpi_addr; const char dlpi_name; const ElfW(Phdr) dlpi_phdr; ElfW(Half) dlpi_phnum; / Note: Following members were introduced after the first version of this structure was available. Check the SIZE argument passed to the dl_iterate_phdr callback to determine whether or not each later member is available. / / Incremented when a new object may have been added. / __extension__ unsigned long long int dlpi_adds; / Incremented when an object may have been removed. / __extension__ unsigned long long int dlpi_subs; / If there is a PT_TLS segment, its module ID as used in TLS relocations, else zero. / size_t dlpi_tls_modid; / The address of the calling thread's instance of this module's PT_TLS segment, if it has one and it has been allocated in the calling thread, otherwise a null pointer. / void dlpi_tls_data; }; __BEGIN_DECLS extern int dl_iterate_phdr (int (__callback) (struct dl_phdr_info , size_t, void ), void __data); /* Prototypes for the ld.so auditing interfaces. These are not defined anywhere in ld.so but instead have to be provided by the auditing DSO. / extern unsigned int la_version (unsigned int __version); extern void la_activity (uintptr_t __cookie, unsigned int __flag); extern char la_objsearch (const char __name, uintptr_t __cookie, unsigned int __flag); extern unsigned int la_objopen (struct link_map __map, Lmid_t __lmid, uintptr_t __cookie); extern void la_preinit (uintptr_t __cookie); extern uintptr_t la_symbind32 (Elf32_Sym __sym, unsigned int __ndx, uintptr_t __refcook, uintptr_t __defcook, unsigned int __flags, const char __symname); extern uintptr_t la_symbind64 (Elf64_Sym __sym, unsigned int __ndx, uintptr_t __refcook, uintptr_t __defcook, unsigned int __flags, const char __symname); extern unsigned int la_objclose (uintptr_t __cookie); __END_DECLS #endif #endif / link.h */	7.62 KB	2026-02-17 11:02
📁 linux	-	2026-03-27 02:43
📄 locale.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99 Standard: 7.11 Localization <locale.h> / #ifndef _LOCALE_H #define _LOCALE_H 1 #include <features.h> #define __need_NULL #include <stddef.h> #include <bits/locale.h> __BEGIN_DECLS / These are the possibilities for the first argument to setlocale. The code assumes that the lowest LC_* symbol has the value zero. / #define LC_CTYPE __LC_CTYPE #define LC_NUMERIC __LC_NUMERIC #define LC_TIME __LC_TIME #define LC_COLLATE __LC_COLLATE #define LC_MONETARY __LC_MONETARY #define LC_MESSAGES __LC_MESSAGES #define LC_ALL __LC_ALL #define LC_PAPER __LC_PAPER #define LC_NAME __LC_NAME #define LC_ADDRESS __LC_ADDRESS #define LC_TELEPHONE __LC_TELEPHONE #define LC_MEASUREMENT __LC_MEASUREMENT #define LC_IDENTIFICATION __LC_IDENTIFICATION / Structure giving information about numeric and monetary notation. / struct lconv { / Numeric (non-monetary) information. / char decimal_point; /* Decimal point character. / char thousands_sep; /* Thousands separator. / / Each element is the number of digits in each group; elements with higher indices are farther left. An element with value CHAR_MAX means that no further grouping is done. An element with value 0 means that the previous element is used for all groups farther left. / char grouping; /* Monetary information. / / First three chars are a currency symbol from ISO 4217. Fourth char is the separator. Fifth char is '\0'. / char int_curr_symbol; char currency_symbol; / Local currency symbol. / char mon_decimal_point; /* Decimal point character. / char mon_thousands_sep; /* Thousands separator. / char mon_grouping; /* Like `grouping' element (above). / char positive_sign; /* Sign for positive values. / char negative_sign; /* Sign for negative values. / char int_frac_digits; / Int'l fractional digits. / char frac_digits; / Local fractional digits. / / 1 if currency_symbol precedes a positive value, 0 if succeeds. / char p_cs_precedes; / 1 iff a space separates currency_symbol from a positive value. / char p_sep_by_space; / 1 if currency_symbol precedes a negative value, 0 if succeeds. / char n_cs_precedes; / 1 iff a space separates currency_symbol from a negative value. / char n_sep_by_space; / Positive and negative sign positions: 0 Parentheses surround the quantity and currency_symbol. 1 The sign string precedes the quantity and currency_symbol. 2 The sign string follows the quantity and currency_symbol. 3 The sign string immediately precedes the currency_symbol. 4 The sign string immediately follows the currency_symbol. / char p_sign_posn; char n_sign_posn; #ifdef __USE_ISOC99 / 1 if int_curr_symbol precedes a positive value, 0 if succeeds. / char int_p_cs_precedes; / 1 iff a space separates int_curr_symbol from a positive value. / char int_p_sep_by_space; / 1 if int_curr_symbol precedes a negative value, 0 if succeeds. / char int_n_cs_precedes; / 1 iff a space separates int_curr_symbol from a negative value. / char int_n_sep_by_space; / Positive and negative sign positions: 0 Parentheses surround the quantity and int_curr_symbol. 1 The sign string precedes the quantity and int_curr_symbol. 2 The sign string follows the quantity and int_curr_symbol. 3 The sign string immediately precedes the int_curr_symbol. 4 The sign string immediately follows the int_curr_symbol. / char int_p_sign_posn; char int_n_sign_posn; #else 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; #endif }; / Set and/or return the current locale. / extern char setlocale (int __category, const char __locale) __THROW; / Return the numeric/monetary information for the current locale. / extern struct lconv localeconv (void) __THROW; #ifdef __USE_XOPEN2K8 /* POSIX.1-2008 extends the locale interface with functions for explicit creation and manipulation of 'locale_t' objects representing locale contexts, and a set of parallel locale-sensitive text processing functions that take a locale_t argument. This enables applications to work with data from multiple locales simultaneously and thread-safely. / # include <bits/types/locale_t.h> / Return a reference to a data structure representing a set of locale datasets. Unlike for the CATEGORY parameter for `setlocale' the CATEGORY_MASK parameter here uses a single bit for each category, made by OR'ing together LC__MASK bits above. / extern locale_t newlocale (int __category_mask, const char __locale, locale_t __base) __THROW; / These are the bits that can be set in the CATEGORY_MASK argument to `newlocale'. In the GNU implementation, LC_FOO_MASK has the value of (1 << LC_FOO), but this is not a part of the interface that callers can assume will be true. / # 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 \ ) / Return a duplicate of the set of locale in DATASET. All usage counters are increased if necessary. / extern locale_t duplocale (locale_t __dataset) __THROW; / Free the data associated with a locale dataset previously returned by a call to `setlocale_r'. / extern void freelocale (locale_t __dataset) __THROW; / Switch the current thread's locale to DATASET. If DATASET is null, instead just return the current setting. The special value LC_GLOBAL_LOCALE is the initial setting for all threads and can also be installed any time, meaning the thread uses the global settings controlled by `setlocale'. / extern locale_t uselocale (locale_t __dataset) __THROW; / This value can be passed to `uselocale' and may be returned by it. Passing this value to any other function has undefined behavior. / # define LC_GLOBAL_LOCALE ((locale_t) -1L) #endif __END_DECLS #endif / locale.h */	7.5 KB	2026-02-17 11:01
📄 lsapidef.h /* Copyright (c) 2002-2018, Lite Speed Technologies 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: * 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. * Neither the name of the Lite Speed Technologies Inc 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 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 _LSAPIDEF_H_ #define _LSAPIDEF_H_ #include <inttypes.h> #include <sys/resource.h> #if defined (c_plusplus) \|\| defined (__cplusplus) extern "C" { #endif enum { H_ACCEPT = 0, H_ACC_CHARSET, H_ACC_ENCODING, H_ACC_LANG, H_AUTHORIZATION, H_CONNECTION, H_CONTENT_TYPE, H_CONTENT_LENGTH, H_COOKIE, H_COOKIE2, H_HOST, H_PRAGMA, H_REFERER, H_USERAGENT, H_CACHE_CTRL, H_IF_MODIFIED_SINCE, H_IF_MATCH, H_IF_NO_MATCH, H_IF_RANGE, H_IF_UNMOD_SINCE, H_KEEP_ALIVE, H_RANGE, H_X_FORWARDED_FOR, H_VIA, H_TRANSFER_ENCODING }; #define LSAPI_SOCK_FILENO 0 #define LSAPI_VERSION_B0 'L' #define LSAPI_VERSION_B1 'S' / Values for m_flag in lsapi_packet_header / #define LSAPI_ENDIAN_LITTLE 0 #define LSAPI_ENDIAN_BIG 1 #define LSAPI_ENDIAN_BIT 1 #if defined(__i386__)\|\|defined( __x86_64 )\|\|defined( __x86_64__ ) #define LSAPI_ENDIAN LSAPI_ENDIAN_LITTLE #else #define LSAPI_ENDIAN LSAPI_ENDIAN_BIG #endif / Values for m_type in lsapi_packet_header / #define LSAPI_BEGIN_REQUEST 1 #define LSAPI_ABORT_REQUEST 2 #define LSAPI_RESP_HEADER 3 #define LSAPI_RESP_STREAM 4 #define LSAPI_RESP_END 5 #define LSAPI_STDERR_STREAM 6 #define LSAPI_REQ_RECEIVED 7 #define LSAPI_CONN_CLOSE 8 #define LSAPI_INTERNAL_ERROR 9 / Cloudlinux added / #define LSAPI_CONN_REJECT 51 #define LSAPI_MAX_HEADER_LEN 65535 #define LSAPI_MAX_DATA_PACKET_LEN 16384 #define LSAPI_RESP_HTTP_HEADER_MAX 32768 #define LSAPI_PACKET_HEADER_LEN 8 struct lsapi_packet_header { char m_versionB0; / LSAPI protocol version / char m_versionB1; char m_type; char m_flag; union { int32_t m_iLen; / include this header / char m_bytes[4]; }m_packetLen; }; / LSAPI request header packet 1. struct lsapi_req_header 2. struct lsapi_http_header_index 3. lsapi_header_offset * unknownHeaders 4. org http request header 5. request body if available / struct lsapi_req_header { struct lsapi_packet_header m_pktHeader; int32_t m_httpHeaderLen; int32_t m_reqBodyLen; int32_t m_scriptFileOff; / path to the script file. / int32_t m_scriptNameOff; / decrypted URI, without pathinfo, / int32_t m_queryStringOff; / Query string inside env */ int32_t m_requestMethodOff; int32_t m_cntUnknownHeaders; int32_t m_cntEnv; int32_t m_cntSpecialEnv; } ; struct lsapi_http_header_index { uint16_t m_headerLen[H_TRANSFER_ENCODING+1]; int32_t m_headerOff[H_TRANSFER_ENCODING+1]; } ; struct lsapi_header_offset { int32_t nameOff; int32_t nameLen; int32_t valueOff; int32_t valueLen; } ; struct lsapi_resp_info { int32_t m_cntHeaders; int32_t m_status; }; struct lsapi_resp_header { struct lsapi_packet_header m_pktHeader; struct lsapi_resp_info m_respInfo; }; typedef struct lsapi_rlimits_t { // for each kind of limit, .rlim_cur==0 in our code means "limit not defined" struct rlimit nofile, nproc, cpu, as; } lsapi_rlimits_t; #if defined (c_plusplus) \|\| defined (__cplusplus) } #endif #endif	4.85 KB	2026-02-13 18:38
📄 lscapi.h /* * Copyright (c) Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2018 All Rights Reserved * * Licensed under CLOUD LINUX LICENSE AGREEMENT * http://cloudlinux.com/docs/LICENSE.TXT * * The part the support library for lsapi & proxy_lsapi Apache modules * author Alexander Demeshko <ademeshko@cloudlinux.com> * * Here you define exportable functions for libscapi clients. / #ifndef _LSCAPI_H_ #define _LSCAPI_H_ #define LSCAPI_PATH_PREFIX "lsapi_" / LSAPI_PRO_ONLY:BEGIN / #ifdef WITH_CRIU #ifdef LSCAPI_DEFAULT_CRIU_SOCKET_PATH #undef LSCAPI_DEFAULT_CRIU_SOCKET_PATH #endif #define LSCAPI_DEFAULT_CRIU_SOCKET_PATH "/var/run/criu/criu_service.socket" #define CRIU_IMGS_SUFFIX "_criu_imgs" #define CRIU_IMGS_RESET_FLAG "mod_lsapi_reset_me" #define CRIU_IMGS_RESET_GLOBAL_FLAG "/usr/share/criu/mod_lsapi/lsphp.criu.reset" #endif //WITH_CRIU / LSAPI_PRO_ONLY:END / #include <sys/uio.h> #include <sys/types.h> #include <stdbool.h> #include <stdint.h> #include <lsapidef.h> #include <lscapi_config.h> #include <liblsapi-sha1.h> #define LSCAPI_SECRET_SIZE 16 #define LSCAPI_SALT_SIZE 16 #define LSCAPI_SHA1_SIGN_SIZE (LSCAPI_SALT_SIZE + SHA1_DIGEST_SIZE) #define LSCAPI_ENCODED_SHA1_SIGN_SIZE (2LSCAPI_SHA1_SIGN_SIZE + 1) #define LSCAPI_ENCODED_SHA1_SIGN_WITHOUT_SALT_SIZE (2SHA1_DIGEST_SIZE + 1) / LSAPI_PRO_ONLY:BEGIN / enum { PFL_RESEND_IF_CRASHED = 0, PFL_SOCKET_FAILED, PFL_BACKEND_CONNECT_FATAL_ERROR, PFL_BACKEND_WARM_CONNECT, PFL_BACKEND_WARM_CONNECT_MS, PFL_BACKEND_COLD_CONNECT, PFL_BACKEND_COLD_CONNECT_MS, PFL_BACKEND_CONNECT_FAILED, PFL_BACKEND_SPAWN_FAILED, PFL_BACKEND_SPAWN_SUCCESS, PFL_BACKEND_SPAWN_DELAYED, / PFL_MODLS_NORM_REQ_MS, // 0 PFL_MODLS_NORM_REQ_NUM, // 0 PFL_MODLS_REQ_HAS_BODY_MS, // 0 PFL_MODLS_REQ_HAS_BODY_NUM, // 0 PFL_MODLS_REQ_WO_BODY_MS, // 0 PFL_MODLS_REQ_WO_BODY_NUM, // 0 / PFL_LAST }; #ifdef WITH_LIBPERFLOG #include <perf_log.h> extern pfl_handle_t lsapi_perf_handle; void lsapi_init_libperflog(void); static inline void lsapi_perf_inc(int event_id) { perf_inc(lsapi_perf_handle, event_id); } static inline void lsapi_perf_add(int event_id, pfl_event_count_t diff) { perf_add(lsapi_perf_handle, event_id, diff); } #else //WITH_LIBPERFLOG #define lsapi_perf_inc(event_id) #define lsapi_perf_add(event_id, diff) #endif //WITH_LIBPERFLOG /* LSAPI_PRO_ONLY:END / // lsapi structs typedef struct lsapi_req_header lsapi_req_header_t; typedef struct lsapi_http_header_index lsapi_http_header_index_t; typedef struct lsapi_header_offset lsapi_header_offset_t; typedef struct lsapi_packet_header lsapi_packet_header_t; typedef struct lsapi_resp_info lsapi_resp_info; // lscapi opaque structures struct lscapi_rec; struct lsphp_conn_t; typedef struct lscapi_rec lscapi_rec; typedef struct lsphp_conn_t lsphp_conn_t; // allocator function pointer type typedef void (lscapi_alloc_fn)(size_t size, void user_data); typedef long (lscapi_user_get_body_fn)(char buf, size_t bufLen, void user_data); typedef int (lscapi_should_get_block_fn)(void user_data); typedef void (lscapi_log_fn)(const char file, int line, int level, int errcode, const void user_data, const char fmt, ...); typedef void (lscapi_random_fn)(void buf, size_t size); typedef int(lsphp_conn_failed_fn)(lsphp_conn_t conn); #ifndef WITHOUT_LVE typedef void (lscapi_lve_alloc_t)(size_t sz, void user_data); typedef void (lscapi_lve_register_t)(void user_data, void* data, int (destroy_fn)()); #endif struct lscapi_var_t { const char key; int keyLen; const char val; int valLen; int perdir; }; typedef struct lscapi_var_t lscapi_var_t; struct lscapi_header_index_t { unsigned keyOff; unsigned keyLen; unsigned valOff; unsigned valLen; }; typedef struct lscapi_header_index_t lscapi_header_index_t; / From lsapilib.h of Litespeed API 6.11 In Litespeed API 7.4.2 increased to 1000 DEPRECATED For backward compatibility only. It it needed only for deprecated lscapi_resphdr_t / #define LSAPI_MAX_RESP_HEADERS 100 / LSAPI_PRO_ONLY:BEGIN / / DEPRECATED For backward compatibility only. Updated with lscapi_resphdr_t / struct lscapi_resphdr_info_t { char buf[LSAPI_MAX_DATA_PACKET_LEN]; size_t dataLen; uint16_t hdrSizes; int hdrNum; int respStatus; }; typedef struct lscapi_resphdr_info_t lscapi_resphdr_info_t; /* LSAPI_PRO_ONLY:END / / DEPRECATED For backward compatibility only. It it needed only for deprecated lscapi_receive_response_hdr function / struct lscapi_resphdr_t { char buf[LSAPI_MAX_RESP_HEADERS (LSAPI_RESP_HTTP_HEADER_MAX+2) + 1024]; size_t dataLen; uint16_t hdrSizes; int hdrNum; int respStatus; }; typedef struct lscapi_resphdr_t lscapi_resphdr_t; struct lscapi_resp_hdr_t { char respBuffer; size_t dataLen; uint16_t hdrSizes; int hdrNum; int respStatus; }; typedef struct lscapi_resp_hdr_t lscapi_resp_hdr_t; enum { LSAPI_BACKEND_OWN_LOG_PATH_SOURCE_AUTO = 0, // path is generated based on a generic pattern, taking into account "lsapi_backend_common_own_log" cfg setting LSAPI_BACKEND_OWN_LOG_PATH_SOURCE_ENV // path is arbitrary, defined by "LSAPI_BACKEND_OWN_LOG_PATH" request property // literal path values in ".conf" aren't yet supported }; struct lscapi_backend_info_t { uint32_t connect_tries; uint32_t connect_timeout; uint32_t backend_children; uint32_t backend_pgrp_max_idle; uint32_t backend_max_idle; uint32_t backend_max_process_time; uint32_t backend_max_reqs; uint32_t backend_pgrp_max_reqs; uint32_t backend_pgrp_max_crashes; uint32_t backend_initial_start; uint32_t poll_timeout; int32_t backend_oom_score_adj; unsigned backend_coredump: 1; unsigned dump_backend_debug_info: 1; unsigned use_suexec: 1; unsigned enable_user_ini: 1; unsigned per_user: 1; unsigned user_ini_homedir: 1; unsigned backend_coredump_was_set: 1; unsigned dump_backend_debug_info_was_set: 1; unsigned use_suexec_was_set: 1; unsigned enable_user_ini_was_set: 1; unsigned per_user_was_set: 1; unsigned user_ini_homedir_was_set: 1; unsigned avoid_zombies: 1; unsigned avoid_zombies_was_set: 1; unsigned disable_reject_mode: 1; unsigned disable_reject_mode_was_set: 1; / LSAPI_PRO_ONLY:BEGIN / unsigned use_criu: 1; unsigned use_criu_was_set: 1; unsigned criu_debug: 1; unsigned criu_debug_was_set: 1; unsigned use_criu_signals: 2; unsigned use_criu_signals_was_set: 1; / LSAPI_PRO_ONLY:END / unsigned use_own_log: 1; unsigned use_own_log_was_set: 1; / LSAPI_PRO_ONLY:BEGIN / unsigned backend_semtimedwait: 1; unsigned backend_semtimedwait_was_set: 1; / LSAPI_PRO_ONLY:END / unsigned common_own_log: 1; unsigned common_own_log_was_set: 1; unsigned own_log_path_source: 2; unsigned own_log_path_source_was_set: 1; unsigned pwd_disabled: 1; unsigned pwd_disabled_was_set: 1; / LSAPI_PRO_ONLY:BEGIN / // This flag is global, not intended to change via tree config. So without _was_set unsigned change_cgroup: 1; / LSAPI_PRO_ONLY:END / unsigned backend_loglevel_info: 1; unsigned backend_loglevel_info_was_set: 1; unsigned backend_oom_score_adj_was_set: 1; }; typedef struct lscapi_backend_info_t lscapi_backend_info_t; #define LSCAPI_PATH_MAX 128 #define LSCAPI_PHPRC_MAX 128 / struct sockaddr_un in <sys/un.h> contains integer constant instead of promised by unix(7) UNIX_PATH_MAX So we will use our own macro. / #define LSCAPI_SOCKET_MAX 108 / LSAPI_PRO_ONLY:BEGIN / struct criu_info_t { char socket_name[4086]; / Path to CRIU service socket / char images_dir[4086]; / Path to dir for CRIU images / int sock_sulsphp; / Socket for sulsphp to talk to lsphp / int sock_lsphp; / Socket for lsphp to talk to sulsphp / int pipe_pid_read; / Pipe end for dumper to read lsphp pid from / int pipe_pid_write; / Pipe end for sulsphp to write lsphp pid to / }; / LSAPI_PRO_ONLY:END / typedef struct spawn_info_t { unsigned backend_children; int backend_oom_score_adj; unsigned backend_pgrp_max_idle; unsigned backend_max_idle; unsigned backend_max_process_time; unsigned backend_max_reqs; unsigned backend_pgrp_max_reqs; unsigned backend_pgrp_max_crashes; unsigned backend_initial_start; uid_t real_uid; gid_t real_gid; uid_t lve_uid; unsigned backend_coredump: 1; unsigned dump_backend_debug_info: 1; unsigned use_suexec: 1; unsigned backend_accept_notify: 1; unsigned use_own_log: 1; unsigned enable_user_ini: 1; unsigned common_own_log: 1; unsigned user_ini_homedir: 1; unsigned debug_enabled: 1; unsigned expose_phprc_as_lsphprc: 1; char phprc[LSCAPI_PHPRC_MAX]; char cmd[LSCAPI_PATH_MAX]; char socket_name[LSCAPI_SOCKET_MAX]; char handler[LSCAPI_SOCKET_MAX]; char docroot[LSCAPI_PATH_MAX]; char hostname[LSCAPI_PATH_MAX]; char own_log_path[LSCAPI_PATH_MAX]; lsapi_rlimits_t rlimits; // after zero init no limits are defined unsigned has_rlimits: 1; // redundant flag to speed up checks, true if any limit in "rlimits" is defined / LSAPI_PRO_ONLY:BEGIN / unsigned use_criu: 1; unsigned criu_debug: 1; unsigned use_criu_signals: 2; / LSAPI_PRO_ONLY:END / unsigned pwd_disabled: 1; unsigned avoid_zombies: 1; unsigned disable_reject_mode: 1; / LSAPI_PRO_ONLY:BEGIN / unsigned change_cgroup: 1; / LSAPI_PRO_ONLY:END / char uniq_socket_name[LSCAPI_SOCKET_MAX]; / LSAPI_PRO_ONLY:BEGIN / struct criu_info_t criu; / LSAPI_PRO_ONLY:END / } spawn_info_t; typedef struct spawn_context_t { int log_sock; int restore; } spawn_context_t; typedef pid_t (lscapi_spawn_backend_fn)(const spawn_info_t spawn_info, void user_data, int force_start); // Event masks /* LSAPI_PRO_ONLY:BEGIN / // DEPRECATED #define LSCAPI_BACKEND_LOG_RECEIVED (1u << 0) / LSAPI_PRO_ONLY:END / #define LSCAPI_RESPONSE_FINISHED (1u << 1) / LSAPI_PRO_ONLY:BEGIN / // DEPRECATED #define LSCAPI_BACKEND_LOG_FATAL (1u << 2) / LSAPI_PRO_ONLY:END / #define LSCAPI_SENDREQ_INTERNAL_ERROR (1u << 3) #define LSCAPI_SENDREQ_BACKEND_ERROR (1u << 4) #define LSCAPI_SENDREQ_CLIENT_ERROR (1u << 5) #define LSCAPI_CONNECT_REJECTED (1u << 6) #define LSCAPI_CONNECT_GENERIC_ERROR (1u << 7) #define LSCAPI_CONNECT_RESET_ERROR (1u << 8) enum lscapi_create_flags { LSCAPI_CREATE_WITH_LVE = 1 << 0, LSCAPI_OUT_ALREADY_INSIDE_LVE = 1 << 16, LSCAPI_OUT_RESOURCE_LIMIT_LVE = 1 << 17, }; / * For backward compatibility with mod_lsapi * LSCAPI_SPECIAL_ENV_PHPVAL_SYSTEM should be 0 * LSCAPI_SPECIAL_ENV_PHPVAL_PERDIR should be 1 * / enum lscapi_special_env_types { LSCAPI_SPECIAL_ENV_PHPVAL_SYSTEM = 0, LSCAPI_SPECIAL_ENV_PHPVAL_PERDIR = 1, LSCAPI_SPECIAL_ENV_ALTER_PHPINI = 2 }; extern const char defaultHandler[]; // "application/x-httpd-lsphp"; int lscapi_init(char errbuf, size_t errlen); // Here caller must use memory pool associated with process void lscapi_child_init(lscapi_alloc_fn user_alloc, void user_data); // for backward compatibility, use lscapi_get_backend_heuristic instead const char lscapi_get_backend(const char handler); // Here caller must use memory pool associated with HTTP request const char lscapi_get_backend_heuristic(const char handler, lscapi_alloc_fn user_alloc, void user_data); uint32_t lscapi_get_real_uid(lscapi_rec lscapi); /* * create opaque structure to store connection to lsphp on logical level * args: * user_alloc = pointer to allocator function * user_data = arbitrary user data to pass to allocator function * real_uid = uid for suexec * real_gid = gid for suexec * lve_uid = uid for lve * flags = * errbuf = buffer to store error description on error * errlen = length of the error buffer * return codes: * allocated and initialized structure = on success, NULL on error / lscapi_rec lscapi_create_ex(lscapi_alloc_fn user_alloc, lscapi_log_fn user_log, void user_data, uint32_t real_uid, uint32_t real_gid, uint32_t lve_uid, unsigned flagsPtr, char errbuf, unsigned errlen); /* * close connection to lsphp on logical level * args: * lscapi = opaque structure created with lscapi_create / void lscapi_destroy(lscapi_rec lscapi); /** * return codes: * 0 = on success, -1 on error and sets appropriate flag on eventMaskPtr / int lscapi_send_request(lsphp_conn_t conn, unsigned eventMaskPtr, char errbuf, unsigned errlen); void lscapi_set_socket_path(lscapi_rec lscapi, char socket_path); void lscapi_set_phprc(lscapi_rec lscapi, const char phprc, bool expose_as_lsphprc); void lscapi_set_user_body_info(lscapi_rec lscapi, size_t body_len, lscapi_user_get_body_fn user_get_body, lscapi_should_get_block_fn user_should_get_block); void lscapi_set_use_request_scope_buffer(lscapi_rec lscapi, bool value); size_t lscapi_get_body_len(lscapi_rec lscapi); void lscapi_set_header_info(lscapi_rec lscapi, lsapi_http_header_index_t hdrIndexPtr, lsapi_header_offset_t hdrOffsets, size_t hdrOffsetsNum, char httpHeader, size_t httpHeaderLen); void lscapi_set_envs(lscapi_rec lscapi, lscapi_var_t envs, int envNum); void lscapi_set_special_envs(lscapi_rec lscapi, lscapi_var_t specialEnvs, int specialEnvNum); void lscapi_set_backend_path(lscapi_rec lscapi, const char handler, const char backend_path); void lscapi_set_debug_enabled(lscapi_rec lscapi, int debug_enabled); void lscapi_set_error(lscapi_rec lscapi); void lscapi_set_recoverable_error(lscapi_rec lscapi); bool lscapi_get_error(const lscapi_rec lscapi, bool outIsRecoverableError); void lscapi_reset_internal_error_state(lscapi_rec lscapi); void lscapi_set_random(lscapi_rec lscapi, lscapi_random_fn get_random_bytes); void lscapi_set_user_spawn_backend(lscapi_rec lscapi, lscapi_spawn_backend_fn user_spawn_backend); void lscapi_set_accept_notify(lscapi_rec lscapi, int accept_notify); void lscapi_set_domain(lscapi_rec lscapi, const char domain); void lscapi_set_docroot(lscapi_rec lscapi, const char docroot); void lscapi_set_rlimits(lscapi_rec lscapi, const lsapi_rlimits_t rlimits); void lscapi_set_protocol_log(lscapi_rec lscapi, const char protocol_log); void lscapi_set_backend_own_log_path(lscapi_rec lscapi, const char path); void lscapi_set_tmpdir(lscapi_rec lscapi, const char tmpdir); / LSAPI_PRO_ONLY:BEGIN / / DEPRECATED / const char lscapi_get_backend_log(lscapi_rec lscapi); / LSAPI_PRO_ONLY:END / void lscapi_init_backend_info(lscapi_backend_info_t infoPtr); void lscapi_merge_backend_info(lscapi_backend_info_t base, lscapi_backend_info_t cur, lscapi_backend_info_t merged); lsphp_conn_t lscapi_acquire_lsphp_conn(lscapi_rec lscapi, char errbuf, unsigned errlen); void lscapi_release_lsphp_conn(lsphp_conn_t conn); / LSAPI_PRO_ONLY:BEGIN / / This function creates a safe environment for spawning new lsphp process. Memory for this is allocated with call to calloc and calls to strdup. So this function is intended to be called just after call to fork from within a child process and just before call to exec. DO NOT USE it otherwise to avoid memory leaks. / / DEPRECATED / int lscapi_prepare_env_for_lsphp(spawn_info_t spawn_info, const char customEnv, int envLen, int envNum, const char safePath, char errbuf, unsigned errlen); / LSAPI_PRO_ONLY:END / / This function creates a safe environment for spawning new lsphp process. Memory for this is allocated with call to calloc and calls to strdup. So this function is intended to be called just after call to fork from within a child process and just before call to exec. DO NOT USE it otherwise to avoid memory leaks. / char* lscapi_prepare_env(spawn_info_t spawn_info, const char customEnv, int envLen, int envNum, const char safePath, char errbuf, unsigned errlen); int lscapi_lsphp_conn_get_socket(lsphp_conn_t conn); void lscapi_remove_stale_data_from_socket(lsphp_conn_t conn); int lscapi_is_conn_closed(lsphp_conn_t conn); / LSAPI_PRO_ONLY:BEGIN / / DEPRECATED Do nothing. For compatibility with mod_lsapi ver. 0.2 only. / void lscapi_set_userdir(lscapi_rec lscapi, int userdir); /* DEPRECATED Do nothing. For compatibility with mod_lsapi ver. 0.2 only. / void lscapi_set_backend_coredump(lscapi_rec lscapi, int coredump_enabled); /* DEPRECATED Do nothing. For compatibility with mod_lsapi ver. 0.2 only. / void lscapi_terminate_backends(void); / LSAPI_PRO_ONLY:END / int lscapi_determine_conn_lsphp(lsphp_conn_t conn, lscapi_backend_info_t backendInfoPtr, char errbuf, unsigned errlen); int lscapi_determine_conn_lsphp_ex(lsphp_conn_t conn, lscapi_backend_info_t backendInfoPtr, const char sockName, char errbuf, unsigned errlen); /* LSAPI_PRO_ONLY:BEGIN / / DEPRECATED / int lscapi_connect_lsphp(lsphp_conn_t conn, char errbuf, unsigned errlen); / DEPRECATED / int lscapi_connect_lsphp_ex(lsphp_conn_t conn, char errbuf, unsigned errlen, int chunked); / LSAPI_PRO_ONLY:END / int lscapi_connect_backend(lsphp_conn_t conn, unsigned eventMaskPtr, char errbuf, unsigned errlen); int lscapi_connect_backend_ex(lsphp_conn_t conn, unsigned eventMaskPtr, char errbuf, unsigned errlen, int chunked); void lscapi_conn_set_failed_cb(lsphp_conn_t conn, lsphp_conn_failed_fn cb, void opaque); lscapi_rec lscapi_conn_get_lsapi_handle(lsphp_conn_t conn); void lscapi_conn_get_opaque(lsphp_conn_t conn); const char lscapi_conn_get_socket_name(lsphp_conn_t conn); pid_t lscapi_conn_get_worker_pid(lsphp_conn_t conn); /* DEPRECATED / void lscapi_lsphp_use_sock(lsphp_conn_t conn, int sock, char errbuf, unsigned errlen); void lscapi_lsphp_use_sock_ext(lsphp_conn_t conn, int sock, pid_t backend_pid, char errbuf, unsigned errlen); / LSAPI_PRO_ONLY:BEGIN / / DEPRECATED For backward compatibility only. Updated with lscapi_receive_response_hdr / int lscapi_receive_response_header(lsphp_conn_t conn, lscapi_resphdr_info_t hdrInfoPtr, unsigned eventMaskPtr, char errbuf, unsigned errlen); / LSAPI_PRO_ONLY:END / / DEPRECATED For backward compatibility only. Use lscapi_receive_resp_hdr and lscapi_free_resp_hdr instead / int lscapi_receive_response_hdr(lsphp_conn_t conn, lscapi_resphdr_t hdrInfoPtr, unsigned eventMaskPtr, char errbuf, unsigned errlen); / Use it instead of deprecated lscapi_receive_response_hdr to receive header of http response from backend. lscapi_free_resp_hdr should called to free allocated resources. / int lscapi_receive_resp_hdr(lsphp_conn_t conn, lscapi_resp_hdr_t rspHdr, unsigned eventMaskPtr, char errbuf, unsigned errlen); void lscapi_free_resp_hdr(lsphp_conn_t conn, lscapi_resp_hdr_t rspHdr); int lscapi_receive_response_chunk(lsphp_conn_t conn, char buf, size_t lenPtr, unsigned eventMaskPtr, char errbuf, unsigned errlen); /* LSAPI_PRO_ONLY:BEGIN / // lve.c #ifndef WITHOUT_LVE /* * load LVE library by dlopen and initialize it * args: * lve_alloc = pointer to function to allocate memory * lve_register = pointer to function to register allocated block * lve_user_data = user data for lve_alloc and lve_register calls * errbuf = buffer to store error description on error * errlen = length of the error buffer * return codes: * 0 = on success, -1 on error / int lscapi_load_lve(lscapi_lve_alloc_t lve_alloc, lscapi_lve_register_t lve_register, void lve_user_data, char errbuf, int errlen); /* * check whether lscapi_load_lve was successfully called previously * return codes: * 1 = in case of success, 0 otherwise / int lscapi_is_lve_loaded(void); #endif / LSAPI_PRO_ONLY:END / / socket_path - sockets with patterns lsapi_.sock in this directory will be deleted after stop of backends / void lscapi_terminate_backends_ex(const char socket_path); / LSAPI_PRO_ONLY:BEGIN / #ifdef WITH_CRIU / socket_path - sockets matched to pattern lsapi_.sock in this directory will be deleted after stop of backends criu_imgs_dir_path - subdirectories matched to pattern lsapi__criu_imgs in this directory will be deleted after stop of backends / void lscapi_terminate_backends_criu(const char socket_path, const char criu_imgs_dir_path); void lscapi_check_imgs_cleanup(const char criu_imgs_dir_path); #endif /* LSAPI_PRO_ONLY:END / void lscapi_sign_uidgid_md5(lscapi_rec lscapi, const uint32_t ids[2], const uint8_t salt[LSCAPI_SALT_SIZE], unsigned char sign[32]); void lscapi_sign_uidgid_sha1(lscapi_rec lscapi, const uint32_t ids[2], const uint8_t salt[LSCAPI_SALT_SIZE], uint8_t sign[LSCAPI_SHA1_SIGN_SIZE]); void lscapi_sign_string_sha1(lscapi_rec lscapi, const char to_sign, const uint8_t salt[LSCAPI_SALT_SIZE], uint8_t sign[LSCAPI_SHA1_SIGN_SIZE]); void lscapi_encode_bytes(const uint8_t bytes, size_t len, char buf); void lscapi_encode_sha1_sign_without_salt(const uint8_t sign[LSCAPI_SHA1_SIGN_SIZE], char buf); pid_t lscapi_spawn_backend(spawn_info_t spawn_info, const spawn_context_t spawn_context); /* LSAPI_PRO_ONLY:BEGIN / #ifdef WITH_CRIU void lscapi_set_criu_socket_path(lscapi_rec lscapi, char criu_socket_path); void lscapi_set_criu_imgs_dir_path(lscapi_rec lscapi, char criu_imgs_dir_path); pid_t lscapi_restore(spawn_info_t spawn_info); int lscapi_prepare_dump(spawn_info_t spawn_info); int lscapi_finish_prepare_dump(spawn_info_t spawn_info, pid_t pid); int lscapi_dump(spawn_info_t spawn_info); int lscapi_prepare_me(void); int lscapi_dump_me(void); void set_spawn_info_criu_opts(spawn_info_t spawn_info, char criu_socket_name, char criu_images_dir, unsigned criu_backend_initial_start, unsigned use_criu, unsigned use_criu_debug, unsigned use_criu_signals); #endif //WITH_CRIU /* LSAPI_PRO_ONLY:END / #define LSCAPI_PROC_CREATE_EXPORTED pid_t lscapi_proc_create(const char const args, const char const env ); / #define PROFILE_ENABLED #ifndef PROFILE_LOG #define PROFILE_LOG #endif / #ifdef PROFILE_ENABLED #include <sys/time.h> #include <sys/resource.h> extern __thread int PROFILE_counter; extern char PROFILE_margins[]; #ifdef PROFILE_LOG #define PROFILE_START(pr) \ static __thread struct timeval pr##_U##__LINE__, pr##_S##__LINE__; \ static __thread int32_t pr##_CUMU##__LINE__, pr##_CUMS##__LINE__; \ static __thread int pr##_CNT##__LINE__; \ static __thread int pr##_ENTERED##__LINE__; \ do { \ struct rusage ruse; \ getrusage(RUSAGE_THREAD, &ruse); \ pr##_U##__LINE__ = ruse.ru_utime; \ pr##_S##__LINE__ = ruse.ru_stime; \ (pr##_CNT##__LINE__)++; \ if(!((pr##_CNT##__LINE__) % 100)) { \ fprintf(stderr, "%s%s.%d: " #pr ": ENTER\n", \ PROFILE_margins[PROFILE_counter], __FUNCTION__, __LINE__ ); \ PROFILE_counter++; \ pr##_ENTERED##__LINE__ = 1; \ } \ } while(0) #define PROFILE_STOP(pr) do { \ struct rusage ruse; \ struct timeval res_utime, res_stime; \ getrusage(RUSAGE_THREAD, &ruse); \ timersub(&ruse.ru_utime, &(pr##_U##__LINE__), &res_utime); \ timersub(&ruse.ru_stime, &(pr##_S##__LINE__), &res_stime); \ pr##_CUMU##__LINE__ += res_utime.tv_sec * 1000000 + res_utime.tv_usec; \ pr##_CUMS##__LINE__ += res_stime.tv_sec * 1000000 + res_stime.tv_usec; \ if(pr##_ENTERED##__LINE__) { \ pr##_ENTERED##__LINE__ = 0; \ PROFILE_counter--; \ double u = pr##_CUMU##__LINE__; u /= pr##_CNT##__LINE__; \ double s = pr##_CUMS##__LINE__; s /= pr##_CNT##__LINE__; \ fprintf(stderr, "%s%s.%d: " #pr ": u:%g; s:%g; cnt %d\n", \ PROFILE_margins[PROFILE_counter], __FUNCTION__, __LINE__, u, s, pr##_CNT##__LINE__ ); \ } \ } while(0) #else // PROFILE_LOG #define PROFILE_START(pr) #define PROFILE_STOP(pr) #endif // PROFILE_LOG #else // PROFILE_ENABLED #define PROFILE_START(pr) #define PROFILE_STOP(pr) #ifdef __clang__ #define ENVIRONMENT __environ #else #define ENVIRONMENT environ #endif #endif // PROFILE_ENABLED #endif // _LSCAPI_H_	25.36 KB	2026-02-13 18:38
📄 lscapi_config.h /* * Copyright (c) Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2018 All Rights Reserved * * Licensed under CLOUD LINUX LICENSE AGREEMENT * http://cloudlinux.com/docs/LICENSE.TXT * The part the support library for lsapi & proxy_lsapi Apache modules * author Alexander Demeshko <ademeshko@cloudlinux.com> * / / * This file is generated automatically. Please do not edit it. */ #ifndef _LSCAPI_CONFIG_H_ #define _LSCAPI_CONFIG_H_ #define MOD_LSAPI_VERSION_MAJOR "1" #define MOD_LSAPI_VERSION_MINOR "1" #define MOD_LSAPI_VERSION_RELEASE "91" #endif // _LSCAPI_CONFIG_H_	599 B	2026-02-13 18:38
📄 lua.h /* $Id: lua.h $ Lua - A Scripting Language Lua.org, PUC-Rio, Brazil (http://www.lua.org) See Copyright Notice at the end of this file / #ifndef lua_h #define lua_h #include <stdarg.h> #include <stddef.h> #include "luaconf.h" #define LUA_VERSION_MAJOR "5" #define LUA_VERSION_MINOR "4" #define LUA_VERSION_RELEASE "4" #define LUA_VERSION_NUM 504 #define LUA_VERSION_RELEASE_NUM (LUA_VERSION_NUM 100 + 4) #define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR #define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE #define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2022 Lua.org, PUC-Rio" #define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes" /* mark for precompiled code ('<esc>Lua') / #define LUA_SIGNATURE "\x1bLua" / option for multiple returns in 'lua_pcall' and 'lua_call' / #define LUA_MULTRET (-1) / Pseudo-indices (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty ** space after that to help overflow detection) / #define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) #define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i)) / thread status / #define LUA_OK 0 #define LUA_YIELD 1 #define LUA_ERRRUN 2 #define LUA_ERRSYNTAX 3 #define LUA_ERRMEM 4 #define LUA_ERRERR 5 typedef struct lua_State lua_State; / ** basic types / #define LUA_TNONE (-1) #define LUA_TNIL 0 #define LUA_TBOOLEAN 1 #define LUA_TLIGHTUSERDATA 2 #define LUA_TNUMBER 3 #define LUA_TSTRING 4 #define LUA_TTABLE 5 #define LUA_TFUNCTION 6 #define LUA_TUSERDATA 7 #define LUA_TTHREAD 8 #define LUA_NUMTYPES 9 / minimum Lua stack available to a C function / #define LUA_MINSTACK 20 / predefined values in the registry / #define LUA_RIDX_MAINTHREAD 1 #define LUA_RIDX_GLOBALS 2 #define LUA_RIDX_LAST LUA_RIDX_GLOBALS / type of numbers in Lua / typedef LUA_NUMBER lua_Number; / type for integer functions / typedef LUA_INTEGER lua_Integer; / unsigned integer type / typedef LUA_UNSIGNED lua_Unsigned; / type for continuation-function contexts / typedef LUA_KCONTEXT lua_KContext; / ** Type for C functions registered with Lua / typedef int (lua_CFunction) (lua_State L); / ** Type for continuation functions / typedef int (lua_KFunction) (lua_State L, int status, lua_KContext ctx); / ** Type for functions that read/write blocks when loading/dumping Lua chunks / typedef const char (lua_Reader) (lua_State L, void ud, size_t sz); typedef int (lua_Writer) (lua_State L, const void p, size_t sz, void ud); /* ** Type for memory-allocation functions / typedef void (lua_Alloc) (void ud, void ptr, size_t osize, size_t nsize); / ** Type for warning functions / typedef void (lua_WarnFunction) (void ud, const char msg, int tocont); /* ** generic extra include file / #if defined(LUA_USER_H) #include LUA_USER_H #endif / ** RCS ident string / extern const char lua_ident[]; / ** state manipulation / LUA_API lua_State (lua_newstate) (lua_Alloc f, void ud); LUA_API void (lua_close) (lua_State L); LUA_API lua_State (lua_newthread) (lua_State L); LUA_API int (lua_resetthread) (lua_State L); LUA_API lua_CFunction (lua_atpanic) (lua_State L, lua_CFunction panicf); LUA_API lua_Number (lua_version) (lua_State L); / ** basic stack manipulation / LUA_API int (lua_absindex) (lua_State L, int idx); LUA_API int (lua_gettop) (lua_State L); LUA_API void (lua_settop) (lua_State L, int idx); LUA_API void (lua_pushvalue) (lua_State L, int idx); LUA_API void (lua_rotate) (lua_State L, int idx, int n); LUA_API void (lua_copy) (lua_State L, int fromidx, int toidx); LUA_API int (lua_checkstack) (lua_State L, int n); LUA_API void (lua_xmove) (lua_State from, lua_State to, int n); /* ** access functions (stack -> C) / LUA_API int (lua_isnumber) (lua_State L, int idx); LUA_API int (lua_isstring) (lua_State L, int idx); LUA_API int (lua_iscfunction) (lua_State L, int idx); LUA_API int (lua_isinteger) (lua_State L, int idx); LUA_API int (lua_isuserdata) (lua_State L, int idx); LUA_API int (lua_type) (lua_State L, int idx); LUA_API const char (lua_typename) (lua_State L, int tp); LUA_API lua_Number (lua_tonumberx) (lua_State L, int idx, int isnum); LUA_API lua_Integer (lua_tointegerx) (lua_State L, int idx, int isnum); LUA_API int (lua_toboolean) (lua_State L, int idx); LUA_API const char (lua_tolstring) (lua_State L, int idx, size_t len); LUA_API lua_Unsigned (lua_rawlen) (lua_State L, int idx); LUA_API lua_CFunction (lua_tocfunction) (lua_State L, int idx); LUA_API void (lua_touserdata) (lua_State L, int idx); LUA_API lua_State (lua_tothread) (lua_State L, int idx); LUA_API const void (lua_topointer) (lua_State L, int idx); / ** Comparison and arithmetic functions / #define LUA_OPADD 0 / ORDER TM, ORDER OP / #define LUA_OPSUB 1 #define LUA_OPMUL 2 #define LUA_OPMOD 3 #define LUA_OPPOW 4 #define LUA_OPDIV 5 #define LUA_OPIDIV 6 #define LUA_OPBAND 7 #define LUA_OPBOR 8 #define LUA_OPBXOR 9 #define LUA_OPSHL 10 #define LUA_OPSHR 11 #define LUA_OPUNM 12 #define LUA_OPBNOT 13 LUA_API void (lua_arith) (lua_State L, int op); #define LUA_OPEQ 0 #define LUA_OPLT 1 #define LUA_OPLE 2 LUA_API int (lua_rawequal) (lua_State L, int idx1, int idx2); LUA_API int (lua_compare) (lua_State L, int idx1, int idx2, int op); /* ** push functions (C -> stack) / LUA_API void (lua_pushnil) (lua_State L); LUA_API void (lua_pushnumber) (lua_State L, lua_Number n); LUA_API void (lua_pushinteger) (lua_State L, lua_Integer n); LUA_API const char (lua_pushlstring) (lua_State L, const char s, size_t len); LUA_API const char (lua_pushstring) (lua_State L, const char s); LUA_API const char (lua_pushvfstring) (lua_State L, const char fmt, va_list argp); LUA_API const char (lua_pushfstring) (lua_State L, const char fmt, ...); LUA_API void (lua_pushcclosure) (lua_State L, lua_CFunction fn, int n); LUA_API void (lua_pushboolean) (lua_State L, int b); LUA_API void (lua_pushlightuserdata) (lua_State L, void p); LUA_API int (lua_pushthread) (lua_State L); / ** get functions (Lua -> stack) / LUA_API int (lua_getglobal) (lua_State L, const char name); LUA_API int (lua_gettable) (lua_State L, int idx); LUA_API int (lua_getfield) (lua_State L, int idx, const char k); LUA_API int (lua_geti) (lua_State L, int idx, lua_Integer n); LUA_API int (lua_rawget) (lua_State L, int idx); LUA_API int (lua_rawgeti) (lua_State L, int idx, lua_Integer n); LUA_API int (lua_rawgetp) (lua_State L, int idx, const void p); LUA_API void (lua_createtable) (lua_State L, int narr, int nrec); LUA_API void (lua_newuserdatauv) (lua_State L, size_t sz, int nuvalue); LUA_API int (lua_getmetatable) (lua_State L, int objindex); LUA_API int (lua_getiuservalue) (lua_State L, int idx, int n); /* ** set functions (stack -> Lua) / LUA_API void (lua_setglobal) (lua_State L, const char name); LUA_API void (lua_settable) (lua_State L, int idx); LUA_API void (lua_setfield) (lua_State L, int idx, const char k); LUA_API void (lua_seti) (lua_State L, int idx, lua_Integer n); LUA_API void (lua_rawset) (lua_State L, int idx); LUA_API void (lua_rawseti) (lua_State L, int idx, lua_Integer n); LUA_API void (lua_rawsetp) (lua_State L, int idx, const void p); LUA_API int (lua_setmetatable) (lua_State L, int objindex); LUA_API int (lua_setiuservalue) (lua_State L, int idx, int n); / ** 'load' and 'call' functions (load and run Lua code) / LUA_API void (lua_callk) (lua_State L, int nargs, int nresults, lua_KContext ctx, lua_KFunction k); #define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL) LUA_API int (lua_pcallk) (lua_State L, int nargs, int nresults, int errfunc, lua_KContext ctx, lua_KFunction k); #define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL) LUA_API int (lua_load) (lua_State L, lua_Reader reader, void dt, const char chunkname, const char mode); LUA_API int (lua_dump) (lua_State L, lua_Writer writer, void data, int strip); / ** coroutine functions / LUA_API int (lua_yieldk) (lua_State L, int nresults, lua_KContext ctx, lua_KFunction k); LUA_API int (lua_resume) (lua_State L, lua_State from, int narg, int nres); LUA_API int (lua_status) (lua_State L); LUA_API int (lua_isyieldable) (lua_State L); #define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL) / ** Warning-related functions / LUA_API void (lua_setwarnf) (lua_State L, lua_WarnFunction f, void ud); LUA_API void (lua_warning) (lua_State L, const char msg, int tocont); / ** garbage-collection function and options / #define LUA_GCSTOP 0 #define LUA_GCRESTART 1 #define LUA_GCCOLLECT 2 #define LUA_GCCOUNT 3 #define LUA_GCCOUNTB 4 #define LUA_GCSTEP 5 #define LUA_GCSETPAUSE 6 #define LUA_GCSETSTEPMUL 7 #define LUA_GCISRUNNING 9 #define LUA_GCGEN 10 #define LUA_GCINC 11 LUA_API int (lua_gc) (lua_State L, int what, ...); /* ** miscellaneous functions / LUA_API int (lua_error) (lua_State L); LUA_API int (lua_next) (lua_State L, int idx); LUA_API void (lua_concat) (lua_State L, int n); LUA_API void (lua_len) (lua_State L, int idx); LUA_API size_t (lua_stringtonumber) (lua_State L, const char s); LUA_API lua_Alloc (lua_getallocf) (lua_State L, void *ud); LUA_API void (lua_setallocf) (lua_State L, lua_Alloc f, void ud); LUA_API void (lua_toclose) (lua_State L, int idx); LUA_API void (lua_closeslot) (lua_State L, int idx); / {============================================================== some useful macros ** =============================================================== / #define lua_getextraspace(L) ((void )((char )(L) - LUA_EXTRASPACE)) #define lua_tonumber(L,i) lua_tonumberx(L,(i),NULL) #define lua_tointeger(L,i) lua_tointegerx(L,(i),NULL) #define lua_pop(L,n) lua_settop(L, -(n)-1) #define lua_newtable(L) lua_createtable(L, 0, 0) #define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n))) #define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0) #define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION) #define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE) #define lua_islightuserdata(L,n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA) #define lua_isnil(L,n) (lua_type(L, (n)) == LUA_TNIL) #define lua_isboolean(L,n) (lua_type(L, (n)) == LUA_TBOOLEAN) #define lua_isthread(L,n) (lua_type(L, (n)) == LUA_TTHREAD) #define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE) #define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0) #define lua_pushliteral(L, s) lua_pushstring(L, "" s) #define lua_pushglobaltable(L) \ ((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)) #define lua_tostring(L,i) lua_tolstring(L, (i), NULL) #define lua_insert(L,idx) lua_rotate(L, (idx), 1) #define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) #define lua_replace(L,idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1)) / }============================================================== / / {============================================================== compatibility macros ** =============================================================== / #if defined(LUA_COMPAT_APIINTCASTS) #define lua_pushunsigned(L,n) lua_pushinteger(L, (lua_Integer)(n)) #define lua_tounsignedx(L,i,is) ((lua_Unsigned)lua_tointegerx(L,i,is)) #define lua_tounsigned(L,i) lua_tounsignedx(L,(i),NULL) #endif #define lua_newuserdata(L,s) lua_newuserdatauv(L,s,1) #define lua_getuservalue(L,idx) lua_getiuservalue(L,idx,1) #define lua_setuservalue(L,idx) lua_setiuservalue(L,idx,1) #define LUA_NUMTAGS LUA_NUMTYPES / }============================================================== / / {====================================================================== Debug API ** ======================================================================= / / ** Event codes / #define LUA_HOOKCALL 0 #define LUA_HOOKRET 1 #define LUA_HOOKLINE 2 #define LUA_HOOKCOUNT 3 #define LUA_HOOKTAILCALL 4 / ** Event masks / #define LUA_MASKCALL (1 << LUA_HOOKCALL) #define LUA_MASKRET (1 << LUA_HOOKRET) #define LUA_MASKLINE (1 << LUA_HOOKLINE) #define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) typedef struct lua_Debug lua_Debug; / activation record / / Functions to be called by the debugger in specific events / typedef void (lua_Hook) (lua_State L, lua_Debug ar); LUA_API int (lua_getstack) (lua_State L, int level, lua_Debug ar); LUA_API int (lua_getinfo) (lua_State L, const char what, lua_Debug ar); LUA_API const char (lua_getlocal) (lua_State L, const lua_Debug ar, int n); LUA_API const char (lua_setlocal) (lua_State L, const lua_Debug ar, int n); LUA_API const char (lua_getupvalue) (lua_State L, int funcindex, int n); LUA_API const char (lua_setupvalue) (lua_State L, int funcindex, int n); LUA_API void (lua_upvalueid) (lua_State L, int fidx, int n); LUA_API void (lua_upvaluejoin) (lua_State L, int fidx1, int n1, int fidx2, int n2); LUA_API void (lua_sethook) (lua_State L, lua_Hook func, int mask, int count); LUA_API lua_Hook (lua_gethook) (lua_State L); LUA_API int (lua_gethookmask) (lua_State L); LUA_API int (lua_gethookcount) (lua_State L); LUA_API int (lua_setcstacklimit) (lua_State L, unsigned int limit); struct lua_Debug { int event; const char name; /* (n) / const char namewhat; /* (n) 'global', 'local', 'field', 'method' / const char what; /* (S) 'Lua', 'C', 'main', 'tail' / const char source; /* (S) / size_t srclen; / (S) / int currentline; / (l) / int linedefined; / (S) / int lastlinedefined; / (S) / unsigned char nups; / (u) number of upvalues / unsigned char nparams;/ (u) number of parameters / char isvararg; / (u) / char istailcall; / (t) / unsigned short ftransfer; / (r) index of first value transferred / unsigned short ntransfer; / (r) number of transferred values / char short_src[LUA_IDSIZE]; / (S) / / private part / struct CallInfo i_ci; /* active function / }; / }====================================================================== / /***************************************************************************** * Copyright (C) 1994-2022 Lua.org, PUC-Rio. * * 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. ******************************************************************************/ #endif	15.45 KB	2023-09-26 18:28
📄 lua.hpp // lua.hpp // Lua header files for C++ // <<extern "C">> not supplied automatically because Lua also compiles as C++ extern "C" { #include "lua.h" #include "lualib.h" #include "lauxlib.h" }	191 B	2023-09-26 18:28
📄 luaconf-x86_64.h /* $Id: luaconf.h $ Configuration file for Lua ** See Copyright Notice in lua.h / #ifndef luaconf_h #define luaconf_h #include <limits.h> #include <stddef.h> #define LUA_USE_LINUX #define LUA_DL_DLOPEN #undef LUA_BUILD_AS_DLL #define LUA_USE_READLINE #define LUA_COMPAT_5_1 #define LUA_COMPAT_5_2 / =================================================================== General Configuration File for Lua Some definitions here can be changed externally, through the compiler (e.g., with '-D' options): They are commented out or protected by '#if !defined' guards. However, several other definitions should be changed directly here, either because they affect the Lua ABI (by making the changes here, you ensure that all software connected to Lua, such as C libraries, will be compiled with the same configuration); or because they are seldom changed. Search for "@@" to find all configurable definitions. ** =================================================================== / / {==================================================================== System Configuration: macros to adapt (if needed) Lua to some particular platform, for instance restricting it to C89. ===================================================================== / / @@ LUA_USE_C89 controls the use of non-ISO-C89 features. Define it if you want Lua to avoid the use of a few C99 features or Windows-specific features on Windows. / / #define LUA_USE_C89 / / ** By default, Lua on Windows use (some) specific Windows features / #if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE) #define LUA_USE_WINDOWS / enable goodies for regular Windows / #endif #if defined(LUA_USE_WINDOWS) #define LUA_DL_DLL / enable support for DLL / #define LUA_USE_C89 / broadly, Windows is C89 / #endif #if defined(LUA_USE_LINUX) #define LUA_USE_POSIX #define LUA_USE_DLOPEN / needs an extra library: -ldl / #endif #if defined(LUA_USE_MACOSX) #define LUA_USE_POSIX #define LUA_USE_DLOPEN / MacOS does not need -ldl / #endif / @@ LUAI_IS32INT is true iff 'int' has (at least) 32 bits. / #define LUAI_IS32INT ((UINT_MAX >> 30) >= 3) / }================================================================== / / {================================================================== Configuration for Number types. These options should not be set externally, because any other code connected to Lua must use the same configuration. ** =================================================================== / / @@ LUA_INT_TYPE defines the type for Lua integers. @@ LUA_FLOAT_TYPE defines the type for Lua floats. Lua should work fine with any mix of these options supported by your C compiler. The usual configurations are 64-bit integers and 'double' (the default), 32-bit integers and 'float' (for restricted platforms), and 'long'/'double' (for C compilers not ** compliant with C99, which may not have support for 'long long'). / / predefined options for LUA_INT_TYPE / #define LUA_INT_INT 1 #define LUA_INT_LONG 2 #define LUA_INT_LONGLONG 3 / predefined options for LUA_FLOAT_TYPE / #define LUA_FLOAT_FLOAT 1 #define LUA_FLOAT_DOUBLE 2 #define LUA_FLOAT_LONGDOUBLE 3 / Default configuration ('long long' and 'double', for 64-bit Lua) / #define LUA_INT_DEFAULT LUA_INT_LONGLONG #define LUA_FLOAT_DEFAULT LUA_FLOAT_DOUBLE / @@ LUA_32BITS enables Lua with 32-bit integers and 32-bit floats. / #define LUA_32BITS 0 / @@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for C89 ('long' and 'double'); Windows always has '__int64', so it does not need to use this case. / #if defined(LUA_USE_C89) && !defined(LUA_USE_WINDOWS) #define LUA_C89_NUMBERS 1 #else #define LUA_C89_NUMBERS 0 #endif #if LUA_32BITS / { / / ** 32-bit integers and 'float' / #if LUAI_IS32INT / use 'int' if big enough / #define LUA_INT_TYPE LUA_INT_INT #else / otherwise use 'long' / #define LUA_INT_TYPE LUA_INT_LONG #endif #define LUA_FLOAT_TYPE LUA_FLOAT_FLOAT #elif LUA_C89_NUMBERS / }{ / / ** largest types available for C89 ('long' and 'double') / #define LUA_INT_TYPE LUA_INT_LONG #define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE #else / }{ / / use defaults / #define LUA_INT_TYPE LUA_INT_DEFAULT #define LUA_FLOAT_TYPE LUA_FLOAT_DEFAULT #endif / } / / }================================================================== / / {================================================================== Configuration for Paths. ** =================================================================== / / LUA_PATH_SEP is the character that separates templates in a path. LUA_PATH_MARK is the string that marks the substitution points in a template. LUA_EXEC_DIR in a Windows path is replaced by the executable's ** directory. / #define LUA_PATH_SEP ";" #define LUA_PATH_MARK "?" #define LUA_EXEC_DIR "!" / @@ LUA_PATH_DEFAULT is the default path that Lua uses to look for Lua libraries. @@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for C libraries. CHANGE them if your machine has a non-conventional directory hierarchy or if you want to install your libraries in ** non-conventional directories. / #define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR #if defined(_WIN32) / { / / In Windows, any exclamation mark ('!') in the path is replaced by the path of the directory of the executable file of the current process. / #define LUA_LDIR "!\\lua\\" #define LUA_CDIR "!\\" #define LUA_SHRDIR "!\\..\\share\\lua\\" LUA_VDIR "\\" #if !defined(LUA_PATH_DEFAULT) #define LUA_PATH_DEFAULT \ LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \ LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" \ LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \ ".\\?.lua;" ".\\?\\init.lua" #endif #if !defined(LUA_CPATH_DEFAULT) #define LUA_CPATH_DEFAULT \ LUA_CDIR"?.dll;" \ LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \ LUA_CDIR"loadall.dll;" ".\\?.dll" #endif #else / }{ / #define LUA_ROOT "/usr/" #define LUA_LDIR "/usr/share/lua/" LUA_VDIR "/" #define LUA_CDIR "/usr/lib64/lua/" LUA_VDIR "/" #if !defined(LUA_PATH_DEFAULT) #define LUA_PATH_DEFAULT \ LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \ LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" \ "./?.lua;" "./?/init.lua" #endif #if !defined(LUA_CPATH_DEFAULT) #define LUA_CPATH_DEFAULT \ LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so" #endif #endif / } / / @@ LUA_DIRSEP is the directory separator (for submodules). CHANGE it if your machine does not use "/" as the directory separator and is not Windows. (On Windows Lua automatically uses "\".) / #if !defined(LUA_DIRSEP) #if defined(_WIN32) #define LUA_DIRSEP "\\" #else #define LUA_DIRSEP "/" #endif #endif / }================================================================== / / {================================================================== Marks for exported symbols in the C code ** =================================================================== / / @@ LUA_API is a mark for all core API functions. @@ LUALIB_API is a mark for all auxiliary library functions. @@ LUAMOD_API is a mark for all standard library opening functions. CHANGE them if you need to define those functions in some special way. For instance, if you want to create one Windows DLL with the core and the libraries, you may want to use the following definition (define LUA_BUILD_AS_DLL to get it). / #if defined(LUA_BUILD_AS_DLL) / { / #if defined(LUA_CORE) \|\| defined(LUA_LIB) / { / #define LUA_API __declspec(dllexport) #else / }{ / #define LUA_API __declspec(dllimport) #endif / } / #else / }{ / #define LUA_API extern #endif / } / / ** More often than not the libs go together with the core. / #define LUALIB_API LUA_API #define LUAMOD_API LUA_API / @@ LUAI_FUNC is a mark for all extern functions that are not to be exported to outside modules. @@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables, none of which to be exported to outside modules (LUAI_DDEF for definitions and LUAI_DDEC for declarations). CHANGE them if you need to mark them in some special way. Elf/gcc (versions 3.2 and later) mark them as "hidden" to optimize access when Lua is compiled as a shared library. Not all elf targets support this attribute. Unfortunately, gcc does not offer a way to check whether the target offers that support, and those without support give a warning about it. To avoid these warnings, change to the default definition. / #if defined(__GNUC__) && ((__GNUC__100 + __GNUC_MINOR__) >= 302) && \ defined(__ELF__) /* { / #define LUAI_FUNC __attribute__((visibility("internal"))) extern #else / }{ / #define LUAI_FUNC extern #endif / } / #define LUAI_DDEC(dec) LUAI_FUNC dec #define LUAI_DDEF / empty / / }================================================================== / / {================================================================== Compatibility with previous versions ** =================================================================== / / @@ LUA_COMPAT_5_3 controls other macros for compatibility with Lua 5.3. You can define it to get all options, or change specific options to fit your specific needs. / #if defined(LUA_COMPAT_5_3) / { / / @@ LUA_COMPAT_MATHLIB controls the presence of several deprecated functions in the mathematical library. (These functions were already officially removed in 5.3; ** nevertheless they are still available here.) / #define LUA_COMPAT_MATHLIB / @@ LUA_COMPAT_APIINTCASTS controls the presence of macros for manipulating other integer types (lua_pushunsigned, lua_tounsigned, luaL_checkint, luaL_checklong, etc.) (These macros were also officially removed in 5.3, but they are still available here.) / #define LUA_COMPAT_APIINTCASTS / @@ LUA_COMPAT_LT_LE controls the emulation of the '__le' metamethod ** using '__lt'. / #define LUA_COMPAT_LT_LE / @@ The following macros supply trivial compatibility for some changes in the API. The macros themselves document how to change your code to avoid using them. (Once more, these macros were officially removed in 5.3, but they are still available here.) / #define lua_strlen(L,i) lua_rawlen(L, (i)) #define lua_objlen(L,i) lua_rawlen(L, (i)) #define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ) #define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT) #endif / } / / }================================================================== / / {================================================================== Configuration for Numbers (low-level part). ** Change these definitions if no predefined LUA_FLOAT_* / LUA_INT_* satisfy your needs. =================================================================== / / @@ LUAI_UACNUMBER is the result of a 'default argument promotion' @@ over a floating number. @@ l_floatatt(x) corrects float attribute 'x' to the proper float type ** by prefixing it with one of FLT/DBL/LDBL. @@ LUA_NUMBER_FRMLEN is the length modifier for writing floats. @@ LUA_NUMBER_FMT is the format for writing floats. @@ lua_number2str converts a float to a string. @@ l_mathop allows the addition of an 'l' or 'f' to all math operations. @@ l_floor takes the floor of a float. @@ lua_str2number converts a decimal numeral to a number. / / The following definitions are good for most cases here / #define l_floor(x) (l_mathop(floor)(x)) #define lua_number2str(s,sz,n) \ l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n)) / @@ lua_numbertointeger converts a float number with an integral value to an integer, or returns 0 if float is not within the range of a lua_Integer. (The range comparisons are tricky because of rounding. The tests here assume a two-complement representation, where MININTEGER always has an exact representation as a float; MAXINTEGER may not have one, and therefore its conversion to float may have an ill-defined value.) / #define lua_numbertointeger(n,p) \ ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \ (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \ ((p) = (LUA_INTEGER)(n), 1)) /* now the variable definitions / #if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT / { single float / #define LUA_NUMBER float #define l_floatatt(n) (FLT_##n) #define LUAI_UACNUMBER double #define LUA_NUMBER_FRMLEN "" #define LUA_NUMBER_FMT "%.7g" #define l_mathop(op) op##f #define lua_str2number(s,p) strtof((s), (p)) #elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE / }{ long double / #define LUA_NUMBER long double #define l_floatatt(n) (LDBL_##n) #define LUAI_UACNUMBER long double #define LUA_NUMBER_FRMLEN "L" #define LUA_NUMBER_FMT "%.19Lg" #define l_mathop(op) op##l #define lua_str2number(s,p) strtold((s), (p)) #elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE / }{ double / #define LUA_NUMBER double #define l_floatatt(n) (DBL_##n) #define LUAI_UACNUMBER double #define LUA_NUMBER_FRMLEN "" #define LUA_NUMBER_FMT "%.14g" #define l_mathop(op) op #define lua_str2number(s,p) strtod((s), (p)) #else / }{ / #error "numeric float type not defined" #endif / } / / @@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER. @@ LUAI_UACINT is the result of a 'default argument promotion' @@ over a LUA_INTEGER. @@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers. @@ LUA_INTEGER_FMT is the format for writing integers. @@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER. @@ LUA_MININTEGER is the minimum value for a LUA_INTEGER. @@ LUA_MAXUNSIGNED is the maximum value for a LUA_UNSIGNED. @@ lua_integer2str converts an integer to a string. / / The following definitions are good for most cases here / #define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d" #define LUAI_UACINT LUA_INTEGER #define lua_integer2str(s,sz,n) \ l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n)) / use LUAI_UACINT here to avoid problems with promotions (which can turn a comparison between unsigneds into a signed comparison) / #define LUA_UNSIGNED unsigned LUAI_UACINT / now the variable definitions / #if LUA_INT_TYPE == LUA_INT_INT / { int / #define LUA_INTEGER int #define LUA_INTEGER_FRMLEN "" #define LUA_MAXINTEGER INT_MAX #define LUA_MININTEGER INT_MIN #define LUA_MAXUNSIGNED UINT_MAX #elif LUA_INT_TYPE == LUA_INT_LONG / }{ long / #define LUA_INTEGER long #define LUA_INTEGER_FRMLEN "l" #define LUA_MAXINTEGER LONG_MAX #define LUA_MININTEGER LONG_MIN #define LUA_MAXUNSIGNED ULONG_MAX #elif LUA_INT_TYPE == LUA_INT_LONGLONG / }{ long long / / use presence of macro LLONG_MAX as proxy for C99 compliance / #if defined(LLONG_MAX) / { / / use ISO C99 stuff / #define LUA_INTEGER long long #define LUA_INTEGER_FRMLEN "ll" #define LUA_MAXINTEGER LLONG_MAX #define LUA_MININTEGER LLONG_MIN #define LUA_MAXUNSIGNED ULLONG_MAX #elif defined(LUA_USE_WINDOWS) / }{ / / in Windows, can use specific Windows types / #define LUA_INTEGER __int64 #define LUA_INTEGER_FRMLEN "I64" #define LUA_MAXINTEGER _I64_MAX #define LUA_MININTEGER _I64_MIN #define LUA_MAXUNSIGNED _UI64_MAX #else / }{ / #error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \ or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)" #endif / } / #else / }{ / #error "numeric integer type not defined" #endif / } / / }================================================================== / / {================================================================== Dependencies with C99 and other C details ** =================================================================== / / @@ l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89. ** (All uses in Lua have only one format item.) / #if !defined(LUA_USE_C89) #define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) #else #define l_sprintf(s,sz,f,i) ((void)(sz), sprintf(s,f,i)) #endif / @@ lua_strx2number converts a hexadecimal numeral to a number. In C99, 'strtod' does that conversion. Otherwise, you can leave 'lua_strx2number' undefined and Lua will provide its own ** implementation. / #if !defined(LUA_USE_C89) #define lua_strx2number(s,p) lua_str2number(s,p) #endif / @@ lua_pointer2str converts a pointer to a readable string in a ** non-specified way. / #define lua_pointer2str(buff,sz,p) l_sprintf(buff,sz,"%p",p) / @@ lua_number2strx converts a float to a hexadecimal numeral. In C99, 'sprintf' (with format specifiers '%a'/'%A') does that. Otherwise, you can leave 'lua_number2strx' undefined and Lua will ** provide its own implementation. / #if !defined(LUA_USE_C89) #define lua_number2strx(L,b,sz,f,n) \ ((void)L, l_sprintf(b,sz,f,(LUAI_UACNUMBER)(n))) #endif / 'strtof' and 'opf' variants for math functions are not valid in C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the availability of these variants. ('math.h' is already included in all files that use these macros.) / #if defined(LUA_USE_C89) \|\| (defined(HUGE_VAL) && !defined(HUGE_VALF)) #undef l_mathop / variants not available / #undef lua_str2number #define l_mathop(op) (lua_Number)op / no variant / #define lua_str2number(s,p) ((lua_Number)strtod((s), (p))) #endif / @@ LUA_KCONTEXT is the type of the context ('ctx') for continuation functions. It must be a numerical type; Lua will use 'intptr_t' if available, otherwise it will use 'ptrdiff_t' (the nearest thing to ** 'intptr_t' in C89) / #define LUA_KCONTEXT ptrdiff_t #if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \ __STDC_VERSION__ >= 199901L #include <stdint.h> #if defined(INTPTR_MAX) / even in C99 this type is optional / #undef LUA_KCONTEXT #define LUA_KCONTEXT intptr_t #endif #endif / @@ lua_getlocaledecpoint gets the locale "radix character" (decimal point). Change that if you do not want to use C locales. (Code using this macro must include the header 'locale.h'.) / #if !defined(lua_getlocaledecpoint) #define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) #endif / macros to improve jump prediction, used mostly for error handling and debug facilities. (Some macros in the Lua API use these macros. Define LUA_NOBUILTIN if you do not want '__builtin_expect' in your code.) / #if !defined(luai_likely) #if defined(__GNUC__) && !defined(LUA_NOBUILTIN) #define luai_likely(x) (__builtin_expect(((x) != 0), 1)) #define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) #else #define luai_likely(x) (x) #define luai_unlikely(x) (x) #endif #endif #if defined(LUA_CORE) \|\| defined(LUA_LIB) / shorter names for Lua's own use / #define l_likely(x) luai_likely(x) #define l_unlikely(x) luai_unlikely(x) #endif / }================================================================== / / {================================================================== Language Variations ** ===================================================================== / / @@ LUA_NOCVTN2S/LUA_NOCVTS2N control how Lua performs some coercions. Define LUA_NOCVTN2S to turn off automatic coercion from numbers to strings. Define LUA_NOCVTS2N to turn off automatic ** coercion from strings to numbers. / / #define LUA_NOCVTN2S / / #define LUA_NOCVTS2N / / @@ LUA_USE_APICHECK turns on several consistency checks on the C API. ** Define it as a help when debugging C code. / #if defined(LUA_USE_APICHECK) #include <assert.h> #define luai_apicheck(l,e) assert(e) #endif / }================================================================== / / {================================================================== Macros that affect the API and must be stable (that is, must be the same when you compile Lua and when you compile code that links to Lua). ** ===================================================================== / / @@ LUAI_MAXSTACK limits the size of the Lua stack. CHANGE it if you need a different limit. This limit is arbitrary; its only purpose is to stop Lua from consuming unlimited stack space (and to reserve some numbers for pseudo-indices). (It must fit into max(size_t)/32.) / #if LUAI_IS32INT #define LUAI_MAXSTACK 1000000 #else #define LUAI_MAXSTACK 15000 #endif / @@ LUA_EXTRASPACE defines the size of a raw memory area associated with a Lua state with very fast access. CHANGE it if you need a different size. / #define LUA_EXTRASPACE (sizeof(void )) /* @@ LUA_IDSIZE gives the maximum size for the description of the source @@ of a function in debug information. ** CHANGE it if you want a different size. / #define LUA_IDSIZE 512 / @@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system. / #define LUAL_BUFFERSIZE ((int)(16 sizeof(void) sizeof(lua_Number))) /* @@ LUAI_MAXALIGN defines fields that, when used in a union, ensure ** maximum alignment for the other items in that union. / #define LUAI_MAXALIGN lua_Number n; double u; void s; lua_Integer i; long l /* }================================================================== / / =================================================================== / / Local configuration. You can use this space to add your redefinitions without modifying the main part of the file. */ #endif	21.01 KB	2023-09-26 18:28
📄 luaconf.h /* * This luaconf.h is a wrapper include file for the original luaconf.h, * which has been renamed to luaconf-<arch>.h. There are conflicts for the * original luaconf.h on multilib systems, which result from arch-specific * configuration options. Please do not use the arch-specific file directly. * * Copyright (C) 2015 Tom Callaway <spot@fedoraproject.org> / /* * \file luaconf.h */ #ifdef luaconf_wrapper_h #error "luaconf_wrapper_h should not be defined!" #endif #define luaconf_wrapper_h #if defined(__i386__) #include "luaconf-i386.h" #elif defined(__ia64__) #include "luaconf-ia64.h" #elif defined(__powerpc64__) # if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ #include "luaconf-ppc64.h" # else #include "luaconf-ppc64le.h" # endif #elif defined(__powerpc__) #include "luaconf-ppc.h" #elif defined(__s390x__) #include "luaconf-s390x.h" #elif defined(__s390__) #include "luaconf-s390.h" #elif defined(__x86_64__) #include "luaconf-x86_64.h" #elif defined(__arm__) #include "luaconf-arm.h" #elif defined(__alpha__) #include "luaconf-alpha.h" #elif defined(__sparc__) && defined (__arch64__) #include "luaconf-sparc64.h" #elif defined(__sparc__) #include "luaconf-sparc.h" #elif defined(__aarch64__) #include "luaconf-aarch64.h" #elif defined(__mips64) && defined(__MIPSEL__) #include "luaconf-mips64el.h" #elif defined(__mips64) #include "luaconf-mips64.h" #elif defined(__mips) && defined(__MIPSEL__) #include "luaconf-mipsel.h" #elif defined(__mips) #include "luaconf-mips.h" #elif defined(__riscv) #include "luaconf-riscv64.h" #else #error "The lua-devel package is not usable with the architecture." #endif #undef luaconf_wrapper_h	1.62 KB	2023-09-26 17:46
📄 lualib.h /* $Id: lualib.h $ Lua standard libraries ** See Copyright Notice in lua.h / #ifndef lualib_h #define lualib_h #include "lua.h" / version suffix for environment variable names / #define LUA_VERSUFFIX "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR LUAMOD_API int (luaopen_base) (lua_State L); #define LUA_COLIBNAME "coroutine" LUAMOD_API int (luaopen_coroutine) (lua_State L); #define LUA_TABLIBNAME "table" LUAMOD_API int (luaopen_table) (lua_State L); #define LUA_IOLIBNAME "io" LUAMOD_API int (luaopen_io) (lua_State L); #define LUA_OSLIBNAME "os" LUAMOD_API int (luaopen_os) (lua_State L); #define LUA_STRLIBNAME "string" LUAMOD_API int (luaopen_string) (lua_State L); #define LUA_UTF8LIBNAME "utf8" LUAMOD_API int (luaopen_utf8) (lua_State L); #define LUA_MATHLIBNAME "math" LUAMOD_API int (luaopen_math) (lua_State L); #define LUA_DBLIBNAME "debug" LUAMOD_API int (luaopen_debug) (lua_State L); #define LUA_LOADLIBNAME "package" LUAMOD_API int (luaopen_package) (lua_State L); / open all previous libraries / LUALIB_API void (luaL_openlibs) (lua_State L); #endif	1.09 KB	2023-09-26 18:28
📁 lzma	-	2025-05-25 12:36
📄 lzma.h /** * \file api/lzma.h * \brief The public API of liblzma data compression library * * liblzma is a public domain general-purpose data compression library with * a zlib-like API. The native file format is .xz, but also the old .lzma * format and raw (no headers) streams are supported. Multiple compression * algorithms (filters) are supported. Currently LZMA2 is the primary filter. * * liblzma is part of XZ Utils <http://tukaani.org/xz/>. XZ Utils includes * a gzip-like command line tool named xz and some other tools. XZ Utils * is developed and maintained by Lasse Collin. * * Major parts of liblzma are based on Igor Pavlov's public domain LZMA SDK * <http://7-zip.org/sdk.html>. * * The SHA-256 implementation is based on the public domain code found from * 7-Zip <http://7-zip.org/>, which has a modified version of the public * domain SHA-256 code found from Crypto++ <http://www.cryptopp.com/>. * The SHA-256 code in Crypto++ was written by Kevin Springle and Wei Dai. / / * Author: Lasse Collin * * This file has been put into the public domain. * You can do whatever you want with this file. / #ifndef LZMA_H #define LZMA_H /**************************** * Required standard headers * ****************************/ / * liblzma API headers need some standard types and macros. To allow * including lzma.h without requiring the application to include other * headers first, lzma.h includes the required standard headers unless * they already seem to be included already or if LZMA_MANUAL_HEADERS * has been defined. * * Here's what types and macros are needed and from which headers: * - stddef.h: size_t, NULL * - stdint.h: uint8_t, uint32_t, uint64_t, UINT32_C(n), uint64_C(n), * UINT32_MAX, UINT64_MAX * * However, inttypes.h is a little more portable than stdint.h, although * inttypes.h declares some unneeded things compared to plain stdint.h. * * The hacks below aren't perfect, specifically they assume that inttypes.h * exists and that it typedefs at least uint8_t, uint32_t, and uint64_t, * and that, in case of incomplete inttypes.h, unsigned int is 32-bit. * If the application already takes care of setting up all the types and * macros properly (for example by using gnulib's stdint.h or inttypes.h), * we try to detect that the macros are already defined and don't include * inttypes.h here again. However, you may define LZMA_MANUAL_HEADERS to * force this file to never include any system headers. * * Some could argue that liblzma API should provide all the required types, * for example lzma_uint64, LZMA_UINT64_C(n), and LZMA_UINT64_MAX. This was * seen as an unnecessary mess, since most systems already provide all the * necessary types and macros in the standard headers. * * Note that liblzma API still has lzma_bool, because using stdbool.h would * break C89 and C++ programs on many systems. sizeof(bool) in C99 isn't * necessarily the same as sizeof(bool) in C++. / #ifndef LZMA_MANUAL_HEADERS / * I suppose this works portably also in C++. Note that in C++, * we need to get size_t into the global namespace. / # include <stddef.h> / * Skip inttypes.h if we already have all the required macros. If we * have the macros, we assume that we have the matching typedefs too. / # if !defined(UINT32_C) \|\| !defined(UINT64_C) \ \|\| !defined(UINT32_MAX) \|\| !defined(UINT64_MAX) / * MSVC versions older than 2013 have no C99 support, and * thus they cannot be used to compile liblzma. Using an * existing liblzma.dll with old MSVC can work though(), but we need to define the required standard integer * types here in a MSVC-specific way. * * () If you do this, the existing liblzma.dll probably uses a different runtime library than your MSVC-built * application. Mixing runtimes is generally bad, but * in this case it should work as long as you avoid * the few rarely-needed liblzma functions that allocate * memory and expect the caller to free it using free(). / # if defined(_WIN32) && defined(_MSC_VER) && _MSC_VER < 1800 typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; typedef unsigned __int64 uint64_t; # else / Use the standard inttypes.h. / # ifdef __cplusplus / * C99 sections 7.18.2 and 7.18.4 specify * that C++ implementations define the limit * and constant macros only if specifically * requested. Note that if you want the * format macros (PRIu64 etc.) too, you need * to define __STDC_FORMAT_MACROS before * including lzma.h, since re-including * inttypes.h with __STDC_FORMAT_MACROS * defined doesn't necessarily work. / # ifndef __STDC_LIMIT_MACROS # define __STDC_LIMIT_MACROS 1 # endif # ifndef __STDC_CONSTANT_MACROS # define __STDC_CONSTANT_MACROS 1 # endif # endif # include <inttypes.h> # endif / * Some old systems have only the typedefs in inttypes.h, and * lack all the macros. For those systems, we need a few more * hacks. We assume that unsigned int is 32-bit and unsigned * long is either 32-bit or 64-bit. If these hacks aren't * enough, the application has to setup the types manually * before including lzma.h. / # ifndef UINT32_C # if defined(_WIN32) && defined(_MSC_VER) # define UINT32_C(n) n ## UI32 # else # define UINT32_C(n) n ## U # endif # endif # ifndef UINT64_C # if defined(_WIN32) && defined(_MSC_VER) # define UINT64_C(n) n ## UI64 # else / Get ULONG_MAX. / # include <limits.h> # if ULONG_MAX == 4294967295UL # define UINT64_C(n) n ## ULL # else # define UINT64_C(n) n ## UL # endif # endif # endif # ifndef UINT32_MAX # define UINT32_MAX (UINT32_C(4294967295)) # endif # ifndef UINT64_MAX # define UINT64_MAX (UINT64_C(18446744073709551615)) # endif # endif #endif / ifdef LZMA_MANUAL_HEADERS / /***************** * LZMA_API macro * *****************/ / * Some systems require that the functions and function pointers are * declared specially in the headers. LZMA_API_IMPORT is for importing * symbols and LZMA_API_CALL is to specify the calling convention. * * By default it is assumed that the application will link dynamically * against liblzma. #define LZMA_API_STATIC in your application if you * want to link against static liblzma. If you don't care about portability * to operating systems like Windows, or at least don't care about linking * against static liblzma on them, don't worry about LZMA_API_STATIC. That * is, most developers will never need to use LZMA_API_STATIC. * * The GCC variants are a special case on Windows (Cygwin and MinGW). * We rely on GCC doing the right thing with its auto-import feature, * and thus don't use __declspec(dllimport). This way developers don't * need to worry about LZMA_API_STATIC. Also the calling convention is * omitted on Cygwin but not on MinGW. / #ifndef LZMA_API_IMPORT # if !defined(LZMA_API_STATIC) && defined(_WIN32) && !defined(__GNUC__) # define LZMA_API_IMPORT __declspec(dllimport) # else # define LZMA_API_IMPORT # endif #endif #ifndef LZMA_API_CALL # if defined(_WIN32) && !defined(__CYGWIN__) # define LZMA_API_CALL __cdecl # else # define LZMA_API_CALL # endif #endif #ifndef LZMA_API # define LZMA_API(type) LZMA_API_IMPORT type LZMA_API_CALL #endif /********** * nothrow * **********/ / * None of the functions in liblzma may throw an exception. Even * the functions that use callback functions won't throw exceptions, * because liblzma would break if a callback function threw an exception. / #ifndef lzma_nothrow # if defined(__cplusplus) # if __cplusplus >= 201103L # define lzma_nothrow noexcept # else # define lzma_nothrow throw() # endif # elif defined(__GNUC__) && (__GNUC__ > 3 \ \|\| (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) # define lzma_nothrow __attribute__((__nothrow__)) # else # define lzma_nothrow # endif #endif /******************* * GNU C extensions * *******************/ / * GNU C extensions are used conditionally in the public API. It doesn't * break anything if these are sometimes enabled and sometimes not, only * affects warnings and optimizations. / #if defined(__GNUC__) && __GNUC__ >= 3 # ifndef lzma_attribute # define lzma_attribute(attr) __attribute__(attr) # endif / warn_unused_result was added in GCC 3.4. / # ifndef lzma_attr_warn_unused_result # if __GNUC__ == 3 && __GNUC_MINOR__ < 4 # define lzma_attr_warn_unused_result # endif # endif #else # ifndef lzma_attribute # define lzma_attribute(attr) # endif #endif #ifndef lzma_attr_pure # define lzma_attr_pure lzma_attribute((__pure__)) #endif #ifndef lzma_attr_const # define lzma_attr_const lzma_attribute((__const__)) #endif #ifndef lzma_attr_warn_unused_result # define lzma_attr_warn_unused_result \ lzma_attribute((__warn_unused_result__)) #endif /************* * Subheaders * *************/ #ifdef __cplusplus extern "C" { #endif / * Subheaders check that this is defined. It is to prevent including * them directly from applications. / #define LZMA_H_INTERNAL 1 / Basic features / #include "lzma/version.h" #include "lzma/base.h" #include "lzma/vli.h" #include "lzma/check.h" / Filters / #include "lzma/filter.h" #include "lzma/bcj.h" #include "lzma/delta.h" #include "lzma/lzma12.h" / Container formats / #include "lzma/container.h" / Advanced features / #include "lzma/stream_flags.h" #include "lzma/block.h" #include "lzma/index.h" #include "lzma/index_hash.h" / Hardware information / #include "lzma/hardware.h" / * All subheaders included. Undefine LZMA_H_INTERNAL to prevent applications * re-including the subheaders. / #undef LZMA_H_INTERNAL #ifdef __cplusplus } #endif #endif / ifndef LZMA_H */	9.63 KB	2020-03-17 14:28
📄 malloc.h /* Prototypes and definition for malloc implementation. Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _MALLOC_H #define _MALLOC_H 1 #include <features.h> #include <stddef.h> #include <stdio.h> #ifdef _LIBC # define __MALLOC_HOOK_VOLATILE # define __MALLOC_DEPRECATED #else # define __MALLOC_HOOK_VOLATILE volatile # define __MALLOC_DEPRECATED __attribute_deprecated__ #endif __BEGIN_DECLS / Allocate SIZE bytes of memory. / extern void malloc (size_t __size) __THROW __attribute_malloc__ __attribute_alloc_size__ ((1)) __wur; /* Allocate NMEMB elements of SIZE bytes each, all initialized to 0. / extern void calloc (size_t __nmemb, size_t __size) __THROW __attribute_malloc__ __attribute_alloc_size__ ((1, 2)) __wur; /* Re-allocate the previously allocated block in __ptr, making the new block SIZE bytes long. / / __attribute_malloc__ is not used, because if realloc returns the same pointer that was passed to it, aliasing needs to be allowed between objects pointed by the old and new pointers. / extern void realloc (void __ptr, size_t __size) __THROW __attribute_warn_unused_result__ __attribute_alloc_size__ ((2)); / Re-allocate the previously allocated block in PTR, making the new block large enough for NMEMB elements of SIZE bytes each. / / __attribute_malloc__ is not used, because if reallocarray returns the same pointer that was passed to it, aliasing needs to be allowed between objects pointed by the old and new pointers. / extern void reallocarray (void __ptr, size_t __nmemb, size_t __size) __THROW __attribute_warn_unused_result__ __attribute_alloc_size__ ((2, 3)) __attr_dealloc_free; / Free a block allocated by `malloc', `realloc' or `calloc'. / extern void free (void __ptr) __THROW; /* Allocate SIZE bytes allocated to ALIGNMENT bytes. / extern void memalign (size_t __alignment, size_t __size) __THROW __attribute_malloc__ __attribute_alloc_size__ ((2)) __wur __attr_dealloc_free; /* Allocate SIZE bytes on a page boundary. / extern void valloc (size_t __size) __THROW __attribute_malloc__ __attribute_alloc_size__ ((1)) __wur __attr_dealloc_free; /* Equivalent to valloc(minimum-page-that-holds(n)), that is, round up __size to nearest pagesize. / extern void pvalloc (size_t __size) __THROW __attribute_malloc__ __wur __attr_dealloc_free; /* SVID2/XPG mallinfo structure / struct mallinfo { int arena; / non-mmapped space allocated from system / int ordblks; / number of free chunks / int smblks; / number of fastbin blocks / int hblks; / number of mmapped regions / int hblkhd; / space in mmapped regions / int usmblks; / always 0, preserved for backwards compatibility / int fsmblks; / space available in freed fastbin blocks / int uordblks; / total allocated space / int fordblks; / total free space / int keepcost; / top-most, releasable (via malloc_trim) space / }; / SVID2/XPG mallinfo2 structure which can handle allocations bigger than 4GB. / struct mallinfo2 { size_t arena; / non-mmapped space allocated from system / size_t ordblks; / number of free chunks / size_t smblks; / number of fastbin blocks / size_t hblks; / number of mmapped regions / size_t hblkhd; / space in mmapped regions / size_t usmblks; / always 0, preserved for backwards compatibility / size_t fsmblks; / space available in freed fastbin blocks / size_t uordblks; / total allocated space / size_t fordblks; / total free space / size_t keepcost; / top-most, releasable (via malloc_trim) space / }; / Returns a copy of the updated current mallinfo. / extern struct mallinfo mallinfo (void) __THROW __MALLOC_DEPRECATED; / Returns a copy of the updated current mallinfo. / extern struct mallinfo2 mallinfo2 (void) __THROW; / SVID2/XPG mallopt options / #ifndef M_MXFAST # define M_MXFAST 1 / maximum request size for "fastbins" / #endif #ifndef M_NLBLKS # define M_NLBLKS 2 / UNUSED in this malloc / #endif #ifndef M_GRAIN # define M_GRAIN 3 / UNUSED in this malloc / #endif #ifndef M_KEEP # define M_KEEP 4 / UNUSED in this malloc / #endif / mallopt options that actually do something / #define M_TRIM_THRESHOLD -1 #define M_TOP_PAD -2 #define M_MMAP_THRESHOLD -3 #define M_MMAP_MAX -4 #define M_CHECK_ACTION -5 #define M_PERTURB -6 #define M_ARENA_TEST -7 #define M_ARENA_MAX -8 / General SVID/XPG interface to tunable parameters. / extern int mallopt (int __param, int __val) __THROW; / Release all but __pad bytes of freed top-most memory back to the system. Return 1 if successful, else 0. / extern int malloc_trim (size_t __pad) __THROW; / Report the number of usable allocated bytes associated with allocated chunk __ptr. / extern size_t malloc_usable_size (void __ptr) __THROW; /* Prints brief summary statistics on stderr. / extern void malloc_stats (void) __THROW; / Output information about state of allocator to stream FP. / extern int malloc_info (int __options, FILE __fp) __THROW; __END_DECLS #endif /* malloc.h */	5.77 KB	2026-02-17 11:01
📄 math.h /* Declarations for math functions. Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99 Standard: 7.12 Mathematics <math.h> / #ifndef _MATH_H #define _MATH_H 1 #define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION #include <bits/libc-header-start.h> #if defined log && defined __GNUC__ # warning A macro called log was already defined when <math.h> was included. # warning This will cause compilation problems. #endif __BEGIN_DECLS / Get definitions of __intmax_t and __uintmax_t. / #include <bits/types.h> / Get machine-dependent vector math functions declarations. / #include <bits/math-vector.h> / Gather machine dependent type support. / #include <bits/floatn.h> / Value returned on overflow. With IEEE 754 floating point, this is +Infinity, otherwise the largest representable positive value. / #if __GNUC_PREREQ (3, 3) # define HUGE_VAL (__builtin_huge_val ()) #else / This may provoke compiler warnings, and may not be rounded to +Infinity in all IEEE 754 rounding modes, but is the best that can be done in ISO C while remaining a constant expression. 10,000 is greater than the maximum (decimal) exponent for all supported floating-point formats and widths. / # define HUGE_VAL 1e10000 #endif #ifdef __USE_ISOC99 # if __GNUC_PREREQ (3, 3) # define HUGE_VALF (__builtin_huge_valf ()) # define HUGE_VALL (__builtin_huge_vall ()) # else # define HUGE_VALF 1e10000f # define HUGE_VALL 1e10000L # endif #endif #if __HAVE_FLOAT16 && __GLIBC_USE (IEC_60559_TYPES_EXT) # define HUGE_VAL_F16 (__builtin_huge_valf16 ()) #endif #if __HAVE_FLOAT32 && __GLIBC_USE (IEC_60559_TYPES_EXT) # define HUGE_VAL_F32 (__builtin_huge_valf32 ()) #endif #if __HAVE_FLOAT64 && __GLIBC_USE (IEC_60559_TYPES_EXT) # define HUGE_VAL_F64 (__builtin_huge_valf64 ()) #endif #if __HAVE_FLOAT128 && __GLIBC_USE (IEC_60559_TYPES_EXT) # define HUGE_VAL_F128 (__builtin_huge_valf128 ()) #endif #if __HAVE_FLOAT32X && __GLIBC_USE (IEC_60559_TYPES_EXT) # define HUGE_VAL_F32X (__builtin_huge_valf32x ()) #endif #if __HAVE_FLOAT64X && __GLIBC_USE (IEC_60559_TYPES_EXT) # define HUGE_VAL_F64X (__builtin_huge_valf64x ()) #endif #if __HAVE_FLOAT128X && __GLIBC_USE (IEC_60559_TYPES_EXT) # define HUGE_VAL_F128X (__builtin_huge_valf128x ()) #endif #ifdef __USE_ISOC99 / IEEE positive infinity. / # if __GNUC_PREREQ (3, 3) # define INFINITY (__builtin_inff ()) # else # define INFINITY HUGE_VALF # endif / IEEE Not A Number. / # if __GNUC_PREREQ (3, 3) # define NAN (__builtin_nanf ("")) # else / This will raise an "invalid" exception outside static initializers, but is the best that can be done in ISO C while remaining a constant expression. / # define NAN (0.0f / 0.0f) # endif #endif / __USE_ISOC99 / #if __GLIBC_USE (IEC_60559_BFP_EXT) / Signaling NaN macros, if supported. / # if __GNUC_PREREQ (3, 3) # define SNANF (__builtin_nansf ("")) # define SNAN (__builtin_nans ("")) # define SNANL (__builtin_nansl ("")) # endif #endif #if (__HAVE_FLOAT16 \ && __GLIBC_USE (IEC_60559_TYPES_EXT) \ && (defined __USE_GNU \|\| !__GLIBC_USE (ISOC2X))) # define SNANF16 (__builtin_nansf16 ("")) #endif #if (__HAVE_FLOAT32 \ && __GLIBC_USE (IEC_60559_TYPES_EXT) \ && (defined __USE_GNU \|\| !__GLIBC_USE (ISOC2X))) # define SNANF32 (__builtin_nansf32 ("")) #endif #if (__HAVE_FLOAT64 \ && __GLIBC_USE (IEC_60559_TYPES_EXT) \ && (defined __USE_GNU \|\| !__GLIBC_USE (ISOC2X))) # define SNANF64 (__builtin_nansf64 ("")) #endif #if (__HAVE_FLOAT128 \ && __GLIBC_USE (IEC_60559_TYPES_EXT) \ && (defined __USE_GNU \|\| !__GLIBC_USE (ISOC2X))) # define SNANF128 (__builtin_nansf128 ("")) #endif #if (__HAVE_FLOAT32X \ && __GLIBC_USE (IEC_60559_TYPES_EXT) \ && (defined __USE_GNU \|\| !__GLIBC_USE (ISOC2X))) # define SNANF32X (__builtin_nansf32x ("")) #endif #if (__HAVE_FLOAT64X \ && __GLIBC_USE (IEC_60559_TYPES_EXT) \ && (defined __USE_GNU \|\| !__GLIBC_USE (ISOC2X))) # define SNANF64X (__builtin_nansf64x ("")) #endif #if (__HAVE_FLOAT128X \ && __GLIBC_USE (IEC_60559_TYPES_EXT) \ && (defined __USE_GNU \|\| !__GLIBC_USE (ISOC2X))) # define SNANF128X (__builtin_nansf128x ("")) #endif / Get __GLIBC_FLT_EVAL_METHOD. / #include <bits/flt-eval-method.h> #ifdef __USE_ISOC99 / Define the following typedefs. float_t floating-point type at least as wide as `float' used to evaluate `float' expressions double_t floating-point type at least as wide as `double' used to evaluate `double' expressions / # if __GLIBC_FLT_EVAL_METHOD == 0 \|\| __GLIBC_FLT_EVAL_METHOD == 16 typedef float float_t; typedef double double_t; # elif __GLIBC_FLT_EVAL_METHOD == 1 typedef double float_t; typedef double double_t; # elif __GLIBC_FLT_EVAL_METHOD == 2 typedef long double float_t; typedef long double double_t; # elif __GLIBC_FLT_EVAL_METHOD == 32 typedef _Float32 float_t; typedef double double_t; # elif __GLIBC_FLT_EVAL_METHOD == 33 typedef _Float32x float_t; typedef _Float32x double_t; # elif __GLIBC_FLT_EVAL_METHOD == 64 typedef _Float64 float_t; typedef _Float64 double_t; # elif __GLIBC_FLT_EVAL_METHOD == 65 typedef _Float64x float_t; typedef _Float64x double_t; # elif __GLIBC_FLT_EVAL_METHOD == 128 typedef _Float128 float_t; typedef _Float128 double_t; # elif __GLIBC_FLT_EVAL_METHOD == 129 typedef _Float128x float_t; typedef _Float128x double_t; # else # error "Unknown __GLIBC_FLT_EVAL_METHOD" # endif #endif / Define macros for the return values of ilogb and llogb, based on __FP_LOGB0_IS_MIN and __FP_LOGBNAN_IS_MIN. FP_ILOGB0 Expands to a value returned by `ilogb (0.0)'. FP_ILOGBNAN Expands to a value returned by `ilogb (NAN)'. FP_LLOGB0 Expands to a value returned by `llogb (0.0)'. FP_LLOGBNAN Expands to a value returned by `llogb (NAN)'. / #include <bits/fp-logb.h> #ifdef __USE_ISOC99 # if __FP_LOGB0_IS_MIN # define FP_ILOGB0 (-2147483647 - 1) # else # define FP_ILOGB0 (-2147483647) # endif # if __FP_LOGBNAN_IS_MIN # define FP_ILOGBNAN (-2147483647 - 1) # else # define FP_ILOGBNAN 2147483647 # endif #endif #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) # if __WORDSIZE == 32 # define __FP_LONG_MAX 0x7fffffffL # else # define __FP_LONG_MAX 0x7fffffffffffffffL # endif # if __FP_LOGB0_IS_MIN # define FP_LLOGB0 (-__FP_LONG_MAX - 1) # else # define FP_LLOGB0 (-__FP_LONG_MAX) # endif # if __FP_LOGBNAN_IS_MIN # define FP_LLOGBNAN (-__FP_LONG_MAX - 1) # else # define FP_LLOGBNAN __FP_LONG_MAX # endif #endif / Get the architecture specific values describing the floating-point evaluation. The following symbols will get defined: FP_FAST_FMA FP_FAST_FMAF FP_FAST_FMAL If defined it indicates that the `fma' function generally executes about as fast as a multiply and an add. This macro is defined only iff the `fma' function is implemented directly with a hardware multiply-add instructions. / #include <bits/fp-fast.h> #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) / Rounding direction macros for fromfp functions. / enum { FP_INT_UPWARD = # define FP_INT_UPWARD 0 FP_INT_UPWARD, FP_INT_DOWNWARD = # define FP_INT_DOWNWARD 1 FP_INT_DOWNWARD, FP_INT_TOWARDZERO = # define FP_INT_TOWARDZERO 2 FP_INT_TOWARDZERO, FP_INT_TONEARESTFROMZERO = # define FP_INT_TONEARESTFROMZERO 3 FP_INT_TONEARESTFROMZERO, FP_INT_TONEAREST = # define FP_INT_TONEAREST 4 FP_INT_TONEAREST, }; #endif / The file <bits/mathcalls.h> contains the prototypes for all the actual math functions. These macros are used for those prototypes, so we can easily declare each function as both `name' and `__name', and can declare the float versions `namef' and `__namef'. / #define __SIMD_DECL(function) __CONCAT (__DECL_SIMD_, function) #define __MATHCALL_VEC(function, suffix, args) \ __SIMD_DECL (__MATH_PRECNAME (function, suffix)) \ __MATHCALL (function, suffix, args) #define __MATHDECL_VEC(type, function,suffix, args) \ __SIMD_DECL (__MATH_PRECNAME (function, suffix)) \ __MATHDECL(type, function,suffix, args) #define __MATHCALL(function,suffix, args) \ __MATHDECL (_Mdouble_,function,suffix, args) #define __MATHDECL(type, function,suffix, args) \ __MATHDECL_1(type, function,suffix, args); \ __MATHDECL_1(type, __CONCAT(__,function),suffix, args) #define __MATHCALLX(function,suffix, args, attrib) \ __MATHDECLX (_Mdouble_,function,suffix, args, attrib) #define __MATHDECLX(type, function,suffix, args, attrib) \ __MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); \ __MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib) #define __MATHDECL_1_IMPL(type, function, suffix, args) \ extern type __MATH_PRECNAME(function,suffix) args __THROW #define __MATHDECL_1(type, function, suffix, args) \ __MATHDECL_1_IMPL(type, function, suffix, args) / Ignore the alias by default. The alias is only useful with redirections. / #define __MATHDECL_ALIAS(type, function, suffix, args, alias) \ __MATHDECL_1(type, function, suffix, args) #define __MATHREDIR(type, function, suffix, args, to) \ extern type __REDIRECT_NTH (__MATH_PRECNAME (function, suffix), args, to) #define _Mdouble_ double #define __MATH_PRECNAME(name,r) __CONCAT(name,r) #define __MATH_DECLARING_DOUBLE 1 #define __MATH_DECLARING_FLOATN 0 #include <bits/mathcalls-helper-functions.h> #include <bits/mathcalls.h> #undef _Mdouble_ #undef __MATH_PRECNAME #undef __MATH_DECLARING_DOUBLE #undef __MATH_DECLARING_FLOATN #ifdef __USE_ISOC99 / Include the file of declarations again, this time using `float' instead of `double' and appending f to each function name. / # define _Mdouble_ float # define __MATH_PRECNAME(name,r) name##f##r # define __MATH_DECLARING_DOUBLE 0 # define __MATH_DECLARING_FLOATN 0 # include <bits/mathcalls-helper-functions.h> # include <bits/mathcalls.h> # undef _Mdouble_ # undef __MATH_PRECNAME # undef __MATH_DECLARING_DOUBLE # undef __MATH_DECLARING_FLOATN # if !(defined __NO_LONG_DOUBLE_MATH && defined _LIBC) \ \|\| defined __LDBL_COMPAT \ \|\| defined _LIBC_TEST # ifdef __LDBL_COMPAT # ifdef __USE_ISOC99 extern float __nldbl_nexttowardf (float __x, long double __y) __THROW __attribute__ ((__const__)); # ifdef __REDIRECT_NTH extern float __REDIRECT_NTH (nexttowardf, (float __x, long double __y), __nldbl_nexttowardf) __attribute__ ((__const__)); extern double __REDIRECT_NTH (nexttoward, (double __x, long double __y), nextafter) __attribute__ ((__const__)); extern long double __REDIRECT_NTH (nexttowardl, (long double __x, long double __y), nextafter) __attribute__ ((__const__)); # endif # endif # undef __MATHDECL_1 # define __MATHDECL_1(type, function,suffix, args) \ __MATHREDIR(type, function, suffix, args, __CONCAT(function,suffix)) # elif __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 # ifdef __REDIRECT_NTH # ifdef __USE_ISOC99 extern float __REDIRECT_NTH (nexttowardf, (float __x, long double __y), __nexttowardf_to_ieee128) __attribute__ ((__const__)); extern double __REDIRECT_NTH (nexttoward, (double __x, long double __y), __nexttoward_to_ieee128) __attribute__ ((__const__)); #define __dremieee128 __remainderieee128 #define __gammaieee128 __lgammaieee128 # endif # endif # undef __MATHDECL_1 # undef __MATHDECL_ALIAS # define __REDIRTO(function, suffix) \ __ ## function ## ieee128 ## suffix # define __REDIRTO_ALT(function, suffix) \ __ ## function ## f128 ## suffix # define __MATHDECL_1(type, function, suffix, args) \ __MATHREDIR (type, function, suffix, args, __REDIRTO (function, suffix)) # define __MATHDECL_ALIAS(type, function, suffix, args, alias) \ __MATHREDIR (type, function, suffix, args, __REDIRTO_ALT (alias, suffix)) # endif / Include the file of declarations again, this time using `long double' instead of `double' and appending l to each function name. / # define _Mdouble_ long double # define __MATH_PRECNAME(name,r) name##l##r # define __MATH_DECLARING_DOUBLE 0 # define __MATH_DECLARING_FLOATN 0 # define __MATH_DECLARE_LDOUBLE 1 # include <bits/mathcalls-helper-functions.h> # include <bits/mathcalls.h> # undef _Mdouble_ # undef __MATH_PRECNAME # undef __MATH_DECLARING_DOUBLE # undef __MATH_DECLARING_FLOATN # if defined __LDBL_COMPAT \ \|\| __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 # undef __REDIRTO # undef __REDIRTO_ALT # undef __MATHDECL_1 # undef __MATHDECL_ALIAS # define __MATHDECL_1(type, function, suffix, args) \ __MATHDECL_1_IMPL(type, function, suffix, args) # define __MATHDECL_ALIAS(type, function, suffix, args, alias) \ __MATHDECL_1(type, function, suffix, args) # endif # endif / !(__NO_LONG_DOUBLE_MATH && _LIBC) \|\| __LDBL_COMPAT / #endif / Use ISO C99. / / Include the file of declarations for _FloatN and _FloatNx types. / #if __HAVE_DISTINCT_FLOAT16 \|\| (__HAVE_FLOAT16 && !defined _LIBC) # define _Mdouble_ _Float16 # define __MATH_PRECNAME(name,r) name##f16##r # define __MATH_DECLARING_DOUBLE 0 # define __MATH_DECLARING_FLOATN 1 # if __HAVE_DISTINCT_FLOAT16 # include <bits/mathcalls-helper-functions.h> # endif # if __GLIBC_USE (IEC_60559_TYPES_EXT) # include <bits/mathcalls.h> # endif # undef _Mdouble_ # undef __MATH_PRECNAME # undef __MATH_DECLARING_DOUBLE # undef __MATH_DECLARING_FLOATN #endif / __HAVE_DISTINCT_FLOAT16 \|\| (__HAVE_FLOAT16 && !_LIBC). / #if __HAVE_DISTINCT_FLOAT32 \|\| (__HAVE_FLOAT32 && !defined _LIBC) # define _Mdouble_ _Float32 # define __MATH_PRECNAME(name,r) name##f32##r # define __MATH_DECLARING_DOUBLE 0 # define __MATH_DECLARING_FLOATN 1 # if __HAVE_DISTINCT_FLOAT32 # include <bits/mathcalls-helper-functions.h> # endif # if __GLIBC_USE (IEC_60559_TYPES_EXT) # include <bits/mathcalls.h> # endif # undef _Mdouble_ # undef __MATH_PRECNAME # undef __MATH_DECLARING_DOUBLE # undef __MATH_DECLARING_FLOATN #endif / __HAVE_DISTINCT_FLOAT32 \|\| (__HAVE_FLOAT32 && !_LIBC). / #if __HAVE_DISTINCT_FLOAT64 \|\| (__HAVE_FLOAT64 && !defined _LIBC) # define _Mdouble_ _Float64 # define __MATH_PRECNAME(name,r) name##f64##r # define __MATH_DECLARING_DOUBLE 0 # define __MATH_DECLARING_FLOATN 1 # if __HAVE_DISTINCT_FLOAT64 # include <bits/mathcalls-helper-functions.h> # endif # if __GLIBC_USE (IEC_60559_TYPES_EXT) # include <bits/mathcalls.h> # endif # undef _Mdouble_ # undef __MATH_PRECNAME # undef __MATH_DECLARING_DOUBLE # undef __MATH_DECLARING_FLOATN #endif / __HAVE_DISTINCT_FLOAT64 \|\| (__HAVE_FLOAT64 && !_LIBC). / #if __HAVE_DISTINCT_FLOAT128 \|\| (__HAVE_FLOAT128 && !defined _LIBC) # define _Mdouble_ _Float128 # define __MATH_PRECNAME(name,r) name##f128##r # define __MATH_DECLARING_DOUBLE 0 # define __MATH_DECLARING_FLOATN 1 # if __HAVE_DISTINCT_FLOAT128 # include <bits/mathcalls-helper-functions.h> # endif # if __GLIBC_USE (IEC_60559_TYPES_EXT) # include <bits/mathcalls.h> # endif # undef _Mdouble_ # undef __MATH_PRECNAME # undef __MATH_DECLARING_DOUBLE # undef __MATH_DECLARING_FLOATN #endif / __HAVE_DISTINCT_FLOAT128 \|\| (__HAVE_FLOAT128 && !_LIBC). / #if __HAVE_DISTINCT_FLOAT32X \|\| (__HAVE_FLOAT32X && !defined _LIBC) # define _Mdouble_ _Float32x # define __MATH_PRECNAME(name,r) name##f32x##r # define __MATH_DECLARING_DOUBLE 0 # define __MATH_DECLARING_FLOATN 1 # if __HAVE_DISTINCT_FLOAT32X # include <bits/mathcalls-helper-functions.h> # endif # if __GLIBC_USE (IEC_60559_TYPES_EXT) # include <bits/mathcalls.h> # endif # undef _Mdouble_ # undef __MATH_PRECNAME # undef __MATH_DECLARING_DOUBLE # undef __MATH_DECLARING_FLOATN #endif / __HAVE_DISTINCT_FLOAT32X \|\| (__HAVE_FLOAT32X && !_LIBC). / #if __HAVE_DISTINCT_FLOAT64X \|\| (__HAVE_FLOAT64X && !defined _LIBC) # define _Mdouble_ _Float64x # define __MATH_PRECNAME(name,r) name##f64x##r # define __MATH_DECLARING_DOUBLE 0 # define __MATH_DECLARING_FLOATN 1 # if __HAVE_DISTINCT_FLOAT64X # include <bits/mathcalls-helper-functions.h> # endif # if __GLIBC_USE (IEC_60559_TYPES_EXT) # include <bits/mathcalls.h> # endif # undef _Mdouble_ # undef __MATH_PRECNAME # undef __MATH_DECLARING_DOUBLE # undef __MATH_DECLARING_FLOATN #endif / __HAVE_DISTINCT_FLOAT64X \|\| (__HAVE_FLOAT64X && !_LIBC). / #if __HAVE_DISTINCT_FLOAT128X \|\| (__HAVE_FLOAT128X && !defined _LIBC) # define _Mdouble_ _Float128x # define __MATH_PRECNAME(name,r) name##f128x##r # define __MATH_DECLARING_DOUBLE 0 # define __MATH_DECLARING_FLOATN 1 # if __HAVE_DISTINCT_FLOAT128X # include <bits/mathcalls-helper-functions.h> # endif # if __GLIBC_USE (IEC_60559_TYPES_EXT) # include <bits/mathcalls.h> # endif # undef _Mdouble_ # undef __MATH_PRECNAME # undef __MATH_DECLARING_DOUBLE # undef __MATH_DECLARING_FLOATN #endif / __HAVE_DISTINCT_FLOAT128X \|\| (__HAVE_FLOAT128X && !_LIBC). / #undef __MATHDECL_1_IMPL #undef __MATHDECL_1 #undef __MATHDECL_ALIAS #undef __MATHDECL #undef __MATHCALL / Declare functions returning a narrower type. / #define __MATHCALL_NARROW_ARGS_1 (_Marg_ __x) #define __MATHCALL_NARROW_ARGS_2 (_Marg_ __x, _Marg_ __y) #define __MATHCALL_NARROW_ARGS_3 (_Marg_ __x, _Marg_ __y, _Marg_ __z) #define __MATHCALL_NARROW_NORMAL(func, nargs) \ extern _Mret_ func __MATHCALL_NARROW_ARGS_ ## nargs __THROW #define __MATHCALL_NARROW_REDIR(func, redir, nargs) \ extern _Mret_ __REDIRECT_NTH (func, __MATHCALL_NARROW_ARGS_ ## nargs, \ redir) #define __MATHCALL_NARROW(func, redir, nargs) \ __MATHCALL_NARROW_NORMAL (func, nargs) #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) # define _Mret_ float # define _Marg_ double # define __MATHCALL_NAME(name) f ## name # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # define _Mret_ float # define _Marg_ long double # define __MATHCALL_NAME(name) f ## name ## l # ifdef __LDBL_COMPAT # define __MATHCALL_REDIR_NAME(name) f ## name # undef __MATHCALL_NARROW # define __MATHCALL_NARROW(func, redir, nargs) \ __MATHCALL_NARROW_REDIR (func, redir, nargs) # elif __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 # define __MATHCALL_REDIR_NAME(name) __ ## f32 ## name ## ieee128 # undef __MATHCALL_NARROW # define __MATHCALL_NARROW(func, redir, nargs) \ __MATHCALL_NARROW_REDIR (func, redir, nargs) # endif # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # if defined __LDBL_COMPAT \ \|\| __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 # undef __MATHCALL_REDIR_NAME # undef __MATHCALL_NARROW # define __MATHCALL_NARROW(func, redir, nargs) \ __MATHCALL_NARROW_NORMAL (func, nargs) # endif # define _Mret_ double # define _Marg_ long double # define __MATHCALL_NAME(name) d ## name ## l # ifdef __LDBL_COMPAT # define __MATHCALL_REDIR_NAME(name) __nldbl_d ## name ## l # undef __MATHCALL_NARROW # define __MATHCALL_NARROW(func, redir, nargs) \ __MATHCALL_NARROW_REDIR (func, redir, nargs) # elif __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 # define __MATHCALL_REDIR_NAME(name) __ ## f64 ## name ## ieee128 # undef __MATHCALL_NARROW # define __MATHCALL_NARROW(func, redir, nargs) \ __MATHCALL_NARROW_REDIR (func, redir, nargs) # endif # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # if defined __LDBL_COMPAT \ \|\| __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 # undef __MATHCALL_REDIR_NAME # undef __MATHCALL_NARROW # define __MATHCALL_NARROW(func, redir, nargs) \ __MATHCALL_NARROW_NORMAL (func, nargs) # endif #endif #if __GLIBC_USE (IEC_60559_TYPES_EXT) # if __HAVE_FLOAT16 && __HAVE_FLOAT32 # define _Mret_ _Float16 # define _Marg_ _Float32 # define __MATHCALL_NAME(name) f16 ## name ## f32 # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT16 && __HAVE_FLOAT32X # define _Mret_ _Float16 # define _Marg_ _Float32x # define __MATHCALL_NAME(name) f16 ## name ## f32x # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT16 && __HAVE_FLOAT64 # define _Mret_ _Float16 # define _Marg_ _Float64 # define __MATHCALL_NAME(name) f16 ## name ## f64 # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT16 && __HAVE_FLOAT64X # define _Mret_ _Float16 # define _Marg_ _Float64x # define __MATHCALL_NAME(name) f16 ## name ## f64x # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT16 && __HAVE_FLOAT128 # define _Mret_ _Float16 # define _Marg_ _Float128 # define __MATHCALL_NAME(name) f16 ## name ## f128 # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT16 && __HAVE_FLOAT128X # define _Mret_ _Float16 # define _Marg_ _Float128x # define __MATHCALL_NAME(name) f16 ## name ## f128x # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT32 && __HAVE_FLOAT32X # define _Mret_ _Float32 # define _Marg_ _Float32x # define __MATHCALL_NAME(name) f32 ## name ## f32x # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT32 && __HAVE_FLOAT64 # define _Mret_ _Float32 # define _Marg_ _Float64 # define __MATHCALL_NAME(name) f32 ## name ## f64 # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT32 && __HAVE_FLOAT64X # define _Mret_ _Float32 # define _Marg_ _Float64x # define __MATHCALL_NAME(name) f32 ## name ## f64x # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT32 && __HAVE_FLOAT128 # define _Mret_ _Float32 # define _Marg_ _Float128 # define __MATHCALL_NAME(name) f32 ## name ## f128 # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT32 && __HAVE_FLOAT128X # define _Mret_ _Float32 # define _Marg_ _Float128x # define __MATHCALL_NAME(name) f32 ## name ## f128x # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT32X && __HAVE_FLOAT64 # define _Mret_ _Float32x # define _Marg_ _Float64 # define __MATHCALL_NAME(name) f32x ## name ## f64 # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT32X && __HAVE_FLOAT64X # define _Mret_ _Float32x # define _Marg_ _Float64x # define __MATHCALL_NAME(name) f32x ## name ## f64x # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT32X && __HAVE_FLOAT128 # define _Mret_ _Float32x # define _Marg_ _Float128 # define __MATHCALL_NAME(name) f32x ## name ## f128 # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT32X && __HAVE_FLOAT128X # define _Mret_ _Float32x # define _Marg_ _Float128x # define __MATHCALL_NAME(name) f32x ## name ## f128x # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT64 && __HAVE_FLOAT64X # define _Mret_ _Float64 # define _Marg_ _Float64x # define __MATHCALL_NAME(name) f64 ## name ## f64x # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT64 && __HAVE_FLOAT128 # define _Mret_ _Float64 # define _Marg_ _Float128 # define __MATHCALL_NAME(name) f64 ## name ## f128 # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT64 && __HAVE_FLOAT128X # define _Mret_ _Float64 # define _Marg_ _Float128x # define __MATHCALL_NAME(name) f64 ## name ## f128x # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT64X && __HAVE_FLOAT128 # define _Mret_ _Float64x # define _Marg_ _Float128 # define __MATHCALL_NAME(name) f64x ## name ## f128 # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT64X && __HAVE_FLOAT128X # define _Mret_ _Float64x # define _Marg_ _Float128x # define __MATHCALL_NAME(name) f64x ## name ## f128x # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif # if __HAVE_FLOAT128 && __HAVE_FLOAT128X # define _Mret_ _Float128 # define _Marg_ _Float128x # define __MATHCALL_NAME(name) f128 ## name ## f128x # include <bits/mathcalls-narrow.h> # undef _Mret_ # undef _Marg_ # undef __MATHCALL_NAME # endif #endif #undef __MATHCALL_NARROW_ARGS_1 #undef __MATHCALL_NARROW_ARGS_2 #undef __MATHCALL_NARROW_ARGS_3 #undef __MATHCALL_NARROW_NORMAL #undef __MATHCALL_NARROW_REDIR #undef __MATHCALL_NARROW #if defined __USE_MISC \|\| defined __USE_XOPEN / This variable is used by `gamma' and `lgamma'. / extern int signgam; #endif #if (__HAVE_DISTINCT_FLOAT16 \ \|\| __HAVE_DISTINCT_FLOAT32 \ \|\| __HAVE_DISTINCT_FLOAT64 \ \|\| __HAVE_DISTINCT_FLOAT32X \ \|\| __HAVE_DISTINCT_FLOAT64X \ \|\| __HAVE_DISTINCT_FLOAT128X) # error "Unsupported _FloatN or _FloatNx types for <math.h>." #endif / Depending on the type of TG_ARG, call an appropriately suffixed version of FUNC with arguments (including parentheses) ARGS. Suffixed functions may not exist for long double if it has the same format as double, or for other types with the same format as float, double or long double. The behavior is undefined if the argument does not have a real floating type. The definition may use a conditional expression, so all suffixed versions of FUNC must return the same type (FUNC may include a cast if necessary rather than being a single identifier). / #ifdef __NO_LONG_DOUBLE_MATH # if __HAVE_DISTINCT_FLOAT128 # error "Distinct _Float128 without distinct long double not supported." # endif # define __MATH_TG(TG_ARG, FUNC, ARGS) \ (sizeof (TG_ARG) == sizeof (float) ? FUNC ## f ARGS : FUNC ARGS) #elif __HAVE_DISTINCT_FLOAT128 # if __HAVE_GENERIC_SELECTION # if __HAVE_FLOATN_NOT_TYPEDEF && __HAVE_FLOAT32 # define __MATH_TG_F32(FUNC, ARGS) _Float32: FUNC ## f ARGS, # else # define __MATH_TG_F32(FUNC, ARGS) # endif # if __HAVE_FLOATN_NOT_TYPEDEF && __HAVE_FLOAT64X # if __HAVE_FLOAT64X_LONG_DOUBLE # define __MATH_TG_F64X(FUNC, ARGS) _Float64x: FUNC ## l ARGS, # else # define __MATH_TG_F64X(FUNC, ARGS) _Float64x: FUNC ## f128 ARGS, # endif # else # define __MATH_TG_F64X(FUNC, ARGS) # endif # define __MATH_TG(TG_ARG, FUNC, ARGS) \ _Generic ((TG_ARG), \ float: FUNC ## f ARGS, \ __MATH_TG_F32 (FUNC, ARGS) \ default: FUNC ARGS, \ long double: FUNC ## l ARGS, \ __MATH_TG_F64X (FUNC, ARGS) \ _Float128: FUNC ## f128 ARGS) # else # if __HAVE_FLOATN_NOT_TYPEDEF # error "Non-typedef _FloatN but no _Generic." # endif # define __MATH_TG(TG_ARG, FUNC, ARGS) \ __builtin_choose_expr \ (__builtin_types_compatible_p (__typeof (TG_ARG), float), \ FUNC ## f ARGS, \ __builtin_choose_expr \ (__builtin_types_compatible_p (__typeof (TG_ARG), double), \ FUNC ARGS, \ __builtin_choose_expr \ (__builtin_types_compatible_p (__typeof (TG_ARG), long double), \ FUNC ## l ARGS, \ FUNC ## f128 ARGS))) # endif #else # define __MATH_TG(TG_ARG, FUNC, ARGS) \ (sizeof (TG_ARG) == sizeof (float) \ ? FUNC ## f ARGS \ : sizeof (TG_ARG) == sizeof (double) \ ? FUNC ARGS \ : FUNC ## l ARGS) #endif / ISO C99 defines some generic macros which work on any data type. / #ifdef __USE_ISOC99 / All floating-point numbers can be put in one of these categories. / enum { FP_NAN = # define FP_NAN 0 FP_NAN, FP_INFINITE = # define FP_INFINITE 1 FP_INFINITE, FP_ZERO = # define FP_ZERO 2 FP_ZERO, FP_SUBNORMAL = # define FP_SUBNORMAL 3 FP_SUBNORMAL, FP_NORMAL = # define FP_NORMAL 4 FP_NORMAL }; / GCC bug 66462 means we cannot use the math builtins with -fsignaling-nan, so disable builtins if this is enabled. When fixed in a newer GCC, the __SUPPORT_SNAN__ check may be skipped for those versions. / / Return number of classification appropriate for X. / # if ((__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__) \ \|\| __glibc_clang_prereq (2,8)) \ && (!defined __OPTIMIZE_SIZE__ \|\| defined __cplusplus) / The check for __cplusplus allows the use of the builtin, even when optimization for size is on. This is provided for libstdc++, only to let its configure test work when it is built with -Os. No further use of this definition of fpclassify is expected in C++ mode, since libstdc++ provides its own version of fpclassify in cmath (which undefines fpclassify). / # define fpclassify(x) __builtin_fpclassify (FP_NAN, FP_INFINITE, \ FP_NORMAL, FP_SUBNORMAL, FP_ZERO, x) # else # define fpclassify(x) __MATH_TG ((x), __fpclassify, (x)) # endif / Return nonzero value if sign of X is negative. / # if __GNUC_PREREQ (6,0) \|\| __glibc_clang_prereq (3,3) # define signbit(x) __builtin_signbit (x) # elif defined __cplusplus / In C++ mode, __MATH_TG cannot be used, because it relies on __builtin_types_compatible_p, which is a C-only builtin. The check for __cplusplus allows the use of the builtin instead of __MATH_TG. This is provided for libstdc++, only to let its configure test work. No further use of this definition of signbit is expected in C++ mode, since libstdc++ provides its own version of signbit in cmath (which undefines signbit). / # define signbit(x) __builtin_signbitl (x) # elif __GNUC_PREREQ (4,0) # define signbit(x) __MATH_TG ((x), __builtin_signbit, (x)) # else # define signbit(x) __MATH_TG ((x), __signbit, (x)) # endif / Return nonzero value if X is not +-Inf or NaN. / # if (__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__) \ \|\| __glibc_clang_prereq (2,8) # define isfinite(x) __builtin_isfinite (x) # else # define isfinite(x) __MATH_TG ((x), __finite, (x)) # endif / Return nonzero value if X is neither zero, subnormal, Inf, nor NaN. / # if (__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__) \ \|\| __glibc_clang_prereq (2,8) # define isnormal(x) __builtin_isnormal (x) # else # define isnormal(x) (fpclassify (x) == FP_NORMAL) # endif / Return nonzero value if X is a NaN. We could use `fpclassify' but we already have this functions `__isnan' and it is faster. / # if (__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__) \ \|\| __glibc_clang_prereq (2,8) # define isnan(x) __builtin_isnan (x) # else # define isnan(x) __MATH_TG ((x), __isnan, (x)) # endif / Return nonzero value if X is positive or negative infinity. / # if __HAVE_DISTINCT_FLOAT128 && !__GNUC_PREREQ (7,0) \ && !defined __SUPPORT_SNAN__ && !defined __cplusplus / Since __builtin_isinf_sign is broken for float128 before GCC 7.0, use the helper function, __isinff128, with older compilers. This is only provided for C mode, because in C++ mode, GCC has no support for __builtin_types_compatible_p (and when in C++ mode, this macro is not used anyway, because libstdc++ headers undefine it). / # define isinf(x) \ (__builtin_types_compatible_p (__typeof (x), _Float128) \ ? __isinff128 (x) : __builtin_isinf_sign (x)) # elif (__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__) \ \|\| __glibc_clang_prereq (3,7) # define isinf(x) __builtin_isinf_sign (x) # else # define isinf(x) __MATH_TG ((x), __isinf, (x)) # endif / Bitmasks for the math_errhandling macro. / # define MATH_ERRNO 1 / errno set by math functions. / # define MATH_ERREXCEPT 2 / Exceptions raised by math functions. / / By default all math functions support both errno and exception handling (except for soft floating point implementations which may only support errno handling). If errno handling is disabled, exceptions are still supported by GLIBC. Set math_errhandling to 0 with -ffast-math (this is nonconforming but it is more useful than leaving it undefined). / # ifdef __FAST_MATH__ # define math_errhandling 0 # elif defined __NO_MATH_ERRNO__ # define math_errhandling (MATH_ERREXCEPT) # else # define math_errhandling (MATH_ERRNO \| MATH_ERREXCEPT) # endif #endif / Use ISO C99. / #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) # include <bits/iscanonical.h> / Return nonzero value if X is a signaling NaN. / # ifndef __cplusplus # define issignaling(x) __MATH_TG ((x), __issignaling, (x)) # else / In C++ mode, __MATH_TG cannot be used, because it relies on __builtin_types_compatible_p, which is a C-only builtin. On the other hand, overloading provides the means to distinguish between the floating-point types. The overloading resolution will match the correct parameter (regardless of type qualifiers (i.e.: const and volatile)). / extern "C++" { inline int issignaling (float __val) { return __issignalingf (__val); } inline int issignaling (double __val) { return __issignaling (__val); } inline int issignaling (long double __val) { # ifdef __NO_LONG_DOUBLE_MATH return __issignaling (__val); # else return __issignalingl (__val); # endif } # if __HAVE_FLOAT128_UNLIKE_LDBL / When using an IEEE 128-bit long double, _Float128 is defined as long double in C++. / inline int issignaling (_Float128 __val) { return __issignalingf128 (__val); } # endif } / extern C++ / # endif / Return nonzero value if X is subnormal. / # define issubnormal(x) (fpclassify (x) == FP_SUBNORMAL) / Return nonzero value if X is zero. / # ifndef __cplusplus # ifdef __SUPPORT_SNAN__ # define iszero(x) (fpclassify (x) == FP_ZERO) # else # define iszero(x) (((__typeof (x)) (x)) == 0) # endif # else / __cplusplus / extern "C++" { # ifdef __SUPPORT_SNAN__ inline int iszero (float __val) { return __fpclassifyf (__val) == FP_ZERO; } inline int iszero (double __val) { return __fpclassify (__val) == FP_ZERO; } inline int iszero (long double __val) { # ifdef __NO_LONG_DOUBLE_MATH return __fpclassify (__val) == FP_ZERO; # else return __fpclassifyl (__val) == FP_ZERO; # endif } # if __HAVE_FLOAT128_UNLIKE_LDBL / When using an IEEE 128-bit long double, _Float128 is defined as long double in C++. / inline int iszero (_Float128 __val) { return __fpclassifyf128 (__val) == FP_ZERO; } # endif # else template <class __T> inline bool iszero (__T __val) { return __val == 0; } # endif } / extern C++ / # endif / __cplusplus / #endif / Use IEC_60559_BFP_EXT. / #ifdef __USE_XOPEN / X/Open wants another strange constant. / # define MAXFLOAT 3.40282347e+38F #endif / Some useful constants. / #if defined __USE_MISC \|\| defined __USE_XOPEN # define M_E 2.7182818284590452354 / e / # define M_LOG2E 1.4426950408889634074 / log_2 e / # define M_LOG10E 0.43429448190325182765 / log_10 e / # define M_LN2 0.69314718055994530942 / log_e 2 / # define M_LN10 2.30258509299404568402 / log_e 10 / # 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) / #endif / The above constants are not adequate for computation using `long double's. Therefore we provide as an extension constants with similar names as a GNU extension. Provide enough digits for the 128-bit IEEE quad. / #ifdef __USE_GNU # define M_El 2.718281828459045235360287471352662498L / e / # define M_LOG2El 1.442695040888963407359924681001892137L / log_2 e / # define M_LOG10El 0.434294481903251827651128918916605082L / log_10 e / # define M_LN2l 0.693147180559945309417232121458176568L / log_e 2 / # define M_LN10l 2.302585092994045684017991454684364208L / log_e 10 / # 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) / #endif #if __HAVE_FLOAT16 && defined __USE_GNU # define M_Ef16 __f16 (2.718281828459045235360287471352662498) / e / # define M_LOG2Ef16 __f16 (1.442695040888963407359924681001892137) / log_2 e / # define M_LOG10Ef16 __f16 (0.434294481903251827651128918916605082) / log_10 e / # define M_LN2f16 __f16 (0.693147180559945309417232121458176568) / log_e 2 / # define M_LN10f16 __f16 (2.302585092994045684017991454684364208) / log_e 10 / # define M_PIf16 __f16 (3.141592653589793238462643383279502884) / pi / # define M_PI_2f16 __f16 (1.570796326794896619231321691639751442) / pi/2 / # define M_PI_4f16 __f16 (0.785398163397448309615660845819875721) / pi/4 / # define M_1_PIf16 __f16 (0.318309886183790671537767526745028724) / 1/pi / # define M_2_PIf16 __f16 (0.636619772367581343075535053490057448) / 2/pi / # define M_2_SQRTPIf16 __f16 (1.128379167095512573896158903121545172) / 2/sqrt(pi) / # define M_SQRT2f16 __f16 (1.414213562373095048801688724209698079) / sqrt(2) / # define M_SQRT1_2f16 __f16 (0.707106781186547524400844362104849039) / 1/sqrt(2) / #endif #if __HAVE_FLOAT32 && defined __USE_GNU # define M_Ef32 __f32 (2.718281828459045235360287471352662498) / e / # define M_LOG2Ef32 __f32 (1.442695040888963407359924681001892137) / log_2 e / # define M_LOG10Ef32 __f32 (0.434294481903251827651128918916605082) / log_10 e / # define M_LN2f32 __f32 (0.693147180559945309417232121458176568) / log_e 2 / # define M_LN10f32 __f32 (2.302585092994045684017991454684364208) / log_e 10 / # define M_PIf32 __f32 (3.141592653589793238462643383279502884) / pi / # define M_PI_2f32 __f32 (1.570796326794896619231321691639751442) / pi/2 / # define M_PI_4f32 __f32 (0.785398163397448309615660845819875721) / pi/4 / # define M_1_PIf32 __f32 (0.318309886183790671537767526745028724) / 1/pi / # define M_2_PIf32 __f32 (0.636619772367581343075535053490057448) / 2/pi / # define M_2_SQRTPIf32 __f32 (1.128379167095512573896158903121545172) / 2/sqrt(pi) / # define M_SQRT2f32 __f32 (1.414213562373095048801688724209698079) / sqrt(2) / # define M_SQRT1_2f32 __f32 (0.707106781186547524400844362104849039) / 1/sqrt(2) / #endif #if __HAVE_FLOAT64 && defined __USE_GNU # define M_Ef64 __f64 (2.718281828459045235360287471352662498) / e / # define M_LOG2Ef64 __f64 (1.442695040888963407359924681001892137) / log_2 e / # define M_LOG10Ef64 __f64 (0.434294481903251827651128918916605082) / log_10 e / # define M_LN2f64 __f64 (0.693147180559945309417232121458176568) / log_e 2 / # define M_LN10f64 __f64 (2.302585092994045684017991454684364208) / log_e 10 / # define M_PIf64 __f64 (3.141592653589793238462643383279502884) / pi / # define M_PI_2f64 __f64 (1.570796326794896619231321691639751442) / pi/2 / # define M_PI_4f64 __f64 (0.785398163397448309615660845819875721) / pi/4 / # define M_1_PIf64 __f64 (0.318309886183790671537767526745028724) / 1/pi / # define M_2_PIf64 __f64 (0.636619772367581343075535053490057448) / 2/pi / # define M_2_SQRTPIf64 __f64 (1.128379167095512573896158903121545172) / 2/sqrt(pi) / # define M_SQRT2f64 __f64 (1.414213562373095048801688724209698079) / sqrt(2) / # define M_SQRT1_2f64 __f64 (0.707106781186547524400844362104849039) / 1/sqrt(2) / #endif #if __HAVE_FLOAT128 && defined __USE_GNU # define M_Ef128 __f128 (2.718281828459045235360287471352662498) / e / # define M_LOG2Ef128 __f128 (1.442695040888963407359924681001892137) / log_2 e / # define M_LOG10Ef128 __f128 (0.434294481903251827651128918916605082) / log_10 e / # define M_LN2f128 __f128 (0.693147180559945309417232121458176568) / log_e 2 / # define M_LN10f128 __f128 (2.302585092994045684017991454684364208) / log_e 10 / # define M_PIf128 __f128 (3.141592653589793238462643383279502884) / pi / # define M_PI_2f128 __f128 (1.570796326794896619231321691639751442) / pi/2 / # define M_PI_4f128 __f128 (0.785398163397448309615660845819875721) / pi/4 / # define M_1_PIf128 __f128 (0.318309886183790671537767526745028724) / 1/pi / # define M_2_PIf128 __f128 (0.636619772367581343075535053490057448) / 2/pi / # define M_2_SQRTPIf128 __f128 (1.128379167095512573896158903121545172) / 2/sqrt(pi) / # define M_SQRT2f128 __f128 (1.414213562373095048801688724209698079) / sqrt(2) / # define M_SQRT1_2f128 __f128 (0.707106781186547524400844362104849039) / 1/sqrt(2) / #endif #if __HAVE_FLOAT32X && defined __USE_GNU # define M_Ef32x __f32x (2.718281828459045235360287471352662498) / e / # define M_LOG2Ef32x __f32x (1.442695040888963407359924681001892137) / log_2 e / # define M_LOG10Ef32x __f32x (0.434294481903251827651128918916605082) / log_10 e / # define M_LN2f32x __f32x (0.693147180559945309417232121458176568) / log_e 2 / # define M_LN10f32x __f32x (2.302585092994045684017991454684364208) / log_e 10 / # define M_PIf32x __f32x (3.141592653589793238462643383279502884) / pi / # define M_PI_2f32x __f32x (1.570796326794896619231321691639751442) / pi/2 / # define M_PI_4f32x __f32x (0.785398163397448309615660845819875721) / pi/4 / # define M_1_PIf32x __f32x (0.318309886183790671537767526745028724) / 1/pi / # define M_2_PIf32x __f32x (0.636619772367581343075535053490057448) / 2/pi / # define M_2_SQRTPIf32x __f32x (1.128379167095512573896158903121545172) / 2/sqrt(pi) / # define M_SQRT2f32x __f32x (1.414213562373095048801688724209698079) / sqrt(2) / # define M_SQRT1_2f32x __f32x (0.707106781186547524400844362104849039) / 1/sqrt(2) / #endif #if __HAVE_FLOAT64X && defined __USE_GNU # define M_Ef64x __f64x (2.718281828459045235360287471352662498) / e / # define M_LOG2Ef64x __f64x (1.442695040888963407359924681001892137) / log_2 e / # define M_LOG10Ef64x __f64x (0.434294481903251827651128918916605082) / log_10 e / # define M_LN2f64x __f64x (0.693147180559945309417232121458176568) / log_e 2 / # define M_LN10f64x __f64x (2.302585092994045684017991454684364208) / log_e 10 / # define M_PIf64x __f64x (3.141592653589793238462643383279502884) / pi / # define M_PI_2f64x __f64x (1.570796326794896619231321691639751442) / pi/2 / # define M_PI_4f64x __f64x (0.785398163397448309615660845819875721) / pi/4 / # define M_1_PIf64x __f64x (0.318309886183790671537767526745028724) / 1/pi / # define M_2_PIf64x __f64x (0.636619772367581343075535053490057448) / 2/pi / # define M_2_SQRTPIf64x __f64x (1.128379167095512573896158903121545172) / 2/sqrt(pi) / # define M_SQRT2f64x __f64x (1.414213562373095048801688724209698079) / sqrt(2) / # define M_SQRT1_2f64x __f64x (0.707106781186547524400844362104849039) / 1/sqrt(2) / #endif #if __HAVE_FLOAT128X && defined __USE_GNU # error "M_ values needed for _Float128x" #endif #ifdef __USE_ISOC99 # if __GNUC_PREREQ (3, 1) /* ISO C99 defines some macros to compare number while taking care for unordered numbers. Many FPUs provide special instructions to support these operations. Generic support in GCC for these as builtins went in 2.97, but not all cpus added their patterns until 3.1. Therefore we enable the builtins from 3.1 onwards and use a generic implementation othwerwise. / # 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) # else # define isgreater(x, y) \ (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \ !isunordered (__x, __y) && __x > __y; })) # define isgreaterequal(x, y) \ (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \ !isunordered (__x, __y) && __x >= __y; })) # define isless(x, y) \ (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \ !isunordered (__x, __y) && __x < __y; })) # define islessequal(x, y) \ (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \ !isunordered (__x, __y) && __x <= __y; })) # define islessgreater(x, y) \ (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \ !isunordered (__x, __y) && __x != __y; })) / isunordered must always check both operands first for signaling NaNs. / # define isunordered(x, y) \ (__extension__ ({ __typeof__ (x) __u = (x); __typeof__ (y) __v = (y); \ __u != __v && (__u != __u \|\| __v != __v); })) # endif #endif #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) / An expression whose type has the widest of the evaluation formats of X and Y (which are of floating-point types). / # if __FLT_EVAL_METHOD__ == 2 \|\| __FLT_EVAL_METHOD__ > 64 # define __MATH_EVAL_FMT2(x, y) ((x) + (y) + 0.0L) # elif __FLT_EVAL_METHOD__ == 1 \|\| __FLT_EVAL_METHOD__ > 32 # define __MATH_EVAL_FMT2(x, y) ((x) + (y) + 0.0) # elif __FLT_EVAL_METHOD__ == 0 \|\| __FLT_EVAL_METHOD__ == 32 # define __MATH_EVAL_FMT2(x, y) ((x) + (y) + 0.0f) # else # define __MATH_EVAL_FMT2(x, y) ((x) + (y)) # endif / Return X == Y but raising "invalid" and setting errno if X or Y is a NaN. / # if !defined __cplusplus \|\| (__cplusplus < 201103L && !defined __GNUC__) # define iseqsig(x, y) \ __MATH_TG (__MATH_EVAL_FMT2 (x, y), __iseqsig, ((x), (y))) # else / In C++ mode, __MATH_TG cannot be used, because it relies on __builtin_types_compatible_p, which is a C-only builtin. Moreover, the comparison macros from ISO C take two floating-point arguments, which need not have the same type. Choosing what underlying function to call requires evaluating the formats of the arguments, then selecting which is wider. The macro __MATH_EVAL_FMT2 provides this information, however, only the type of the macro expansion is relevant (actually evaluating the expression would be incorrect). Thus, the type is used as a template parameter for __iseqsig_type, which calls the appropriate underlying function. / extern "C++" { template<typename> struct __iseqsig_type; template<> struct __iseqsig_type<float> { static int __call (float __x, float __y) throw () { return __iseqsigf (__x, __y); } }; template<> struct __iseqsig_type<double> { static int __call (double __x, double __y) throw () { return __iseqsig (__x, __y); } }; template<> struct __iseqsig_type<long double> { static int __call (long double __x, long double __y) throw () { # ifndef __NO_LONG_DOUBLE_MATH return __iseqsigl (__x, __y); # else return __iseqsig (__x, __y); # endif } }; # if __HAVE_FLOAT128_UNLIKE_LDBL / When using an IEEE 128-bit long double, _Float128 is defined as long double in C++. / template<> struct __iseqsig_type<_Float128> { static int __call (_Float128 __x, _Float128 __y) throw () { return __iseqsigf128 (__x, __y); } }; # endif template<typename _T1, typename _T2> inline int iseqsig (_T1 __x, _T2 __y) throw () { # if __cplusplus >= 201103L typedef decltype (__MATH_EVAL_FMT2 (__x, __y)) _T3; # else typedef __typeof (__MATH_EVAL_FMT2 (__x, __y)) _T3; # endif return __iseqsig_type<_T3>::__call (__x, __y); } } / extern "C++" / # endif / __cplusplus / #endif __END_DECLS #endif / math.h */	47.63 KB	2026-02-17 11:01
📄 mcheck.h /* Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _MCHECK_H #define _MCHECK_H 1 #include <features.h> __BEGIN_DECLS / Return values for `mprobe': these are the kinds of inconsistencies that `mcheck' enables detection of. / enum mcheck_status { MCHECK_DISABLED = -1, / Consistency checking is not turned on. / MCHECK_OK, / Block is fine. / MCHECK_FREE, / Block freed twice. / MCHECK_HEAD, / Memory before the block was clobbered. / MCHECK_TAIL / Memory after the block was clobbered. / }; / Activate a standard collection of debugging hooks. This must be called before `malloc' is ever called. ABORTFUNC is called with an error code (see enum above) when an inconsistency is detected. If ABORTFUNC is null, the standard function prints on stderr and then calls `abort'. / extern int mcheck (void (__abortfunc)(enum mcheck_status)) __THROW; /* Similar to `mcheck' but performs checks for all block whenever one of the memory handling functions is called. This can be very slow. / extern int mcheck_pedantic (void (__abortfunc)(enum mcheck_status)) __THROW; /* Force check of all blocks now. / extern void mcheck_check_all (void); / Check for aberrations in a particular malloc'd block. You must have called `mcheck' already. These are the same checks that `mcheck' does when you free or reallocate a block. / extern enum mcheck_status mprobe (void __ptr) __THROW; /* Activate a standard collection of tracing hooks. / extern void mtrace (void) __THROW; extern void muntrace (void) __THROW; __END_DECLS #endif / mcheck.h */	2.38 KB	2026-02-17 11:01
📄 memory.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * SVID / #ifndef _MEMORY_H #define _MEMORY_H 1 #include <features.h> #ifndef _STRING_H # include <string.h> #endif / string.h / #endif / memory.h */	956 B	2026-02-17 11:01
📁 misc	-	2026-03-27 02:43
📄 mntent.h /* Utilities for reading/writing fstab, mtab, etc. Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _MNTENT_H #define _MNTENT_H 1 #include <features.h> #include <paths.h> #include <bits/types/FILE.h> / File listing canonical interesting mount points. / #define MNTTAB _PATH_MNTTAB / Deprecated alias. / / File listing currently active mount points. / #define MOUNTED _PATH_MOUNTED / Deprecated alias. / / General filesystem types. / #define MNTTYPE_IGNORE "ignore" / Ignore this entry. / #define MNTTYPE_NFS "nfs" / Network file system. / #define MNTTYPE_SWAP "swap" / Swap device. / / Generic mount options. / #define MNTOPT_DEFAULTS "defaults" / Use all default options. / #define MNTOPT_RO "ro" / Read only. / #define MNTOPT_RW "rw" / Read/write. / #define MNTOPT_SUID "suid" / Set uid allowed. / #define MNTOPT_NOSUID "nosuid" / No set uid allowed. / #define MNTOPT_NOAUTO "noauto" / Do not auto mount. / __BEGIN_DECLS / Structure describing a mount table entry. / struct mntent { char mnt_fsname; /* Device or server for filesystem. / char mnt_dir; /* Directory mounted on. / char mnt_type; /* Type of filesystem: ufs, nfs, etc. / char mnt_opts; /* Comma-separated options for fs. / int mnt_freq; / Dump frequency (in days). / int mnt_passno; / Pass number for `fsck'. / }; / Prepare to begin reading and/or writing mount table entries from the beginning of FILE. MODE is as for `fopen'. / extern FILE setmntent (const char __file, const char __mode) __THROW; /* Read one mount table entry from STREAM. Returns a pointer to storage reused on the next call, or null for EOF or error (use feof/ferror to check). / extern struct mntent getmntent (FILE __stream) __THROW; #ifdef __USE_MISC / Reentrant version of the above function. / extern struct mntent getmntent_r (FILE __restrict __stream, struct mntent __restrict __result, char __restrict __buffer, int __bufsize) __THROW; #endif / Write the mount table entry described by MNT to STREAM. Return zero on success, nonzero on failure. / extern int addmntent (FILE __restrict __stream, const struct mntent __restrict __mnt) __THROW; / Close a stream opened with `setmntent'. / extern int endmntent (FILE __stream) __THROW; /* Search MNT->mnt_opts for an option matching OPT. Returns the address of the substring, or null if none found. / extern char hasmntopt (const struct mntent __mnt, const char __opt) __THROW; __END_DECLS #endif /* mntent.h */	3.28 KB	2026-02-17 11:01
📄 monetary.h /* Header file for monetary value formatting functions. Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _MONETARY_H #define _MONETARY_H 1 #include <features.h> / Get needed types. / #define __need_size_t #include <stddef.h> #include <bits/types.h> #ifndef __ssize_t_defined typedef __ssize_t ssize_t; # define __ssize_t_defined #endif __BEGIN_DECLS / Formatting a monetary value according to the current locale. / extern ssize_t strfmon (char __restrict __s, size_t __maxsize, const char __restrict __format, ...) __THROW __attribute_format_strfmon__ (3, 4) __attr_access ((__write_only__, 1, 2)); #ifdef __USE_XOPEN2K8 / POSIX.1-2008 extended locale interface (see locale.h). / # include <bits/types/locale_t.h> / Formatting a monetary value according to the given locale. / extern ssize_t strfmon_l (char __restrict __s, size_t __maxsize, locale_t __loc, const char __restrict __format, ...) __THROW __attribute_format_strfmon__ (4, 5) __attr_access ((__write_only__, 1, 2)); #endif #include <bits/floatn.h> #if defined __LDBL_COMPAT \|\| __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 # include <bits/monetary-ldbl.h> #endif __END_DECLS #endif / monetary.h */	1.92 KB	2026-02-17 11:01
📄 mqueue.h /* Copyright (C) 2004-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _MQUEUE_H #define _MQUEUE_H 1 #include <features.h> #include <sys/types.h> #include <fcntl.h> #include <bits/types/sigevent_t.h> #include <bits/types/struct_timespec.h> / Get the definition of mqd_t and struct mq_attr. / #include <bits/mqueue.h> __BEGIN_DECLS / Establish connection between a process and a message queue NAME and return message queue descriptor or (mqd_t) -1 on error. OFLAG determines the type of access used. If O_CREAT is on OFLAG, the third argument is taken as a `mode_t', the mode of the created message queue, and the fourth argument is taken as `struct mq_attr ', pointer to message queue attributes. If the fourth argument is NULL, default attributes are used. / extern mqd_t mq_open (const char __name, int __oflag, ...) __THROW __nonnull ((1)); / Removes the association between message queue descriptor MQDES and its message queue. / extern int mq_close (mqd_t __mqdes) __THROW; / Query status and attributes of message queue MQDES. / extern int mq_getattr (mqd_t __mqdes, struct mq_attr __mqstat) __THROW __nonnull ((2)); /* Set attributes associated with message queue MQDES and if OMQSTAT is not NULL also query its old attributes. / extern int mq_setattr (mqd_t __mqdes, const struct mq_attr __restrict __mqstat, struct mq_attr __restrict __omqstat) __THROW __nonnull ((2)); / Remove message queue named NAME. / extern int mq_unlink (const char __name) __THROW __nonnull ((1)); /* Register notification issued upon message arrival to an empty message queue MQDES. / extern int mq_notify (mqd_t __mqdes, const struct sigevent __notification) __THROW; /* Receive the oldest from highest priority messages in message queue MQDES. / extern ssize_t mq_receive (mqd_t __mqdes, char __msg_ptr, size_t __msg_len, unsigned int __msg_prio) __nonnull ((2)); / Add message pointed by MSG_PTR to message queue MQDES. / extern int mq_send (mqd_t __mqdes, const char __msg_ptr, size_t __msg_len, unsigned int __msg_prio) __nonnull ((2)); #ifdef __USE_XOPEN2K # ifndef __USE_TIME_BITS64 /* Receive the oldest from highest priority messages in message queue MQDES, stop waiting if ABS_TIMEOUT expires. / extern ssize_t mq_timedreceive (mqd_t __mqdes, char __restrict __msg_ptr, size_t __msg_len, unsigned int __restrict __msg_prio, const struct timespec __restrict __abs_timeout) __nonnull ((2, 5)); /* Add message pointed by MSG_PTR to message queue MQDES, stop blocking on full message queue if ABS_TIMEOUT expires. / extern int mq_timedsend (mqd_t __mqdes, const char __msg_ptr, size_t __msg_len, unsigned int __msg_prio, const struct timespec __abs_timeout) __nonnull ((2, 5)); # else # ifdef __REDIRECT extern int __REDIRECT (mq_timedreceive, (mqd_t __mqdes, char __restrict __msg_ptr, size_t __msg_len, unsigned int __restrict __msg_prio, const struct timespec __restrict __abs_timeout), __mq_timedreceive_time64) __nonnull ((2, 5)); extern int __REDIRECT (mq_timedsend, (mqd_t __mqdes, const char __msg_ptr, size_t __msg_len, unsigned int __msg_prio, const struct timespec __abs_timeout), __mq_timedsend_time64) __nonnull ((2, 5)); # else # define mq_timedreceive __mq_timedreceive_time64 # define mq_timedsend __mq_timedsend_time64 # endif # endif #endif /* Define some inlines helping to catch common problems. / #if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function \ && defined __va_arg_pack_len # include <bits/mqueue2.h> #endif __END_DECLS #endif / mqueue.h */	4.5 KB	2026-02-17 11:01
📁 mtd	-	2026-03-27 02:43
📄 mysql	0 B	1970-01-01 00:00
📁 net	-	2026-03-21 15:44
📁 netash	-	2026-03-21 15:44
📁 netatalk	-	2026-03-21 15:44
📁 netax25	-	2026-03-21 15:44
📄 netdb.h /* Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / All data returned by the network data base library are supplied in host order and returned in network order (suitable for use in system calls). / #ifndef _NETDB_H #define _NETDB_H 1 #include <features.h> #include <netinet/in.h> #include <bits/stdint-uintn.h> #ifdef __USE_MISC / This is necessary to make this include file properly replace the Sun version. / # include <rpc/netdb.h> #endif #ifdef __USE_GNU # include <bits/types/sigevent_t.h> # include <bits/types/struct_timespec.h> #endif #include <bits/netdb.h> / Absolute file name for network data base files. / #define _PATH_HEQUIV "/etc/hosts.equiv" #define _PATH_HOSTS "/etc/hosts" #define _PATH_NETWORKS "/etc/networks" #define _PATH_NSSWITCH_CONF "/etc/nsswitch.conf" #define _PATH_PROTOCOLS "/etc/protocols" #define _PATH_SERVICES "/etc/services" __BEGIN_DECLS #if defined __USE_MISC \|\| !defined __USE_XOPEN2K8 / Error status for non-reentrant lookup functions. We use a macro to access always the thread-specific `h_errno' variable. / # define h_errno (__h_errno_location ()) /* Function to get address of global `h_errno' variable. / extern int __h_errno_location (void) __THROW __attribute__ ((__const__)); /* Possible values left in `h_errno'. / # 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. / #endif #ifdef __USE_MISC # define NETDB_INTERNAL -1 / See errno. / # define NETDB_SUCCESS 0 / No problem. / # define NO_ADDRESS NO_DATA / No address, look for MX record. / #endif #if defined __USE_XOPEN2K \|\| defined __USE_XOPEN_EXTENDED / Highest reserved Internet port number. / # define IPPORT_RESERVED 1024 #endif #ifdef __USE_GNU / Scope delimiter for getaddrinfo(), getnameinfo(). / # define SCOPE_DELIMITER '%' #endif #ifdef __USE_MISC / Print error indicated by `h_errno' variable on standard error. STR if non-null is printed before the error string. / extern void herror (const char __str) __THROW; /* Return string associated with error ERR_NUM. / extern const char hstrerror (int __err_num) __THROW; #endif /* Description of data base entry for a single host. / 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. / #ifdef __USE_MISC # define h_addr h_addr_list[0] / Address, for backward compatibility./ #endif }; / Open host data base files and mark them as staying open even after a later search if STAY_OPEN is non-zero. This function is a possible cancellation point and therefore not marked with __THROW. / extern void sethostent (int __stay_open); / Close host data base files and clear `stay open' flag. This function is a possible cancellation point and therefore not marked with __THROW. / extern void endhostent (void); / Get next entry from host data base file. Open data base if necessary. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct hostent gethostent (void); /* Return entry from host data base which address match ADDR with length LEN and type TYPE. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct hostent gethostbyaddr (const void __addr, __socklen_t __len, int __type); / Return entry from host data base for host with NAME. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct hostent gethostbyname (const char __name); #ifdef __USE_MISC / Return entry from host data base for host with NAME. AF must be set to the address type which is `AF_INET' for IPv4 or `AF_INET6' for IPv6. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern struct hostent gethostbyname2 (const char __name, int __af); / Reentrant versions of the functions above. The additional arguments specify a buffer of BUFLEN starting at BUF. The last argument is a pointer to a variable which gets the value which would be stored in the global variable `herrno' by the non-reentrant functions. These functions are not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation they are cancellation points and therefore not marked with __THROW. / extern int gethostent_r (struct hostent __restrict __result_buf, char __restrict __buf, size_t __buflen, struct hostent __restrict __result, int __restrict __h_errnop); extern int gethostbyaddr_r (const void __restrict __addr, __socklen_t __len, int __type, struct hostent __restrict __result_buf, char __restrict __buf, size_t __buflen, struct hostent __restrict __result, int __restrict __h_errnop); extern int gethostbyname_r (const char __restrict __name, struct hostent __restrict __result_buf, char __restrict __buf, size_t __buflen, struct hostent __restrict __result, int __restrict __h_errnop); extern int gethostbyname2_r (const char __restrict __name, int __af, struct hostent __restrict __result_buf, char __restrict __buf, size_t __buflen, struct hostent __restrict __result, int __restrict __h_errnop); #endif /* misc / / Open network data base files and mark them as staying open even after a later search if STAY_OPEN is non-zero. This function is a possible cancellation point and therefore not marked with __THROW. / extern void setnetent (int __stay_open); / Close network data base files and clear `stay open' flag. This function is a possible cancellation point and therefore not marked with __THROW. / extern void endnetent (void); / Get next entry from network data base file. Open data base if necessary. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct netent getnetent (void); /* Return entry from network data base which address match NET and type TYPE. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct netent getnetbyaddr (uint32_t __net, int __type); /* Return entry from network data base for network with NAME. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct netent getnetbyname (const char __name); #ifdef __USE_MISC / Reentrant versions of the functions above. The additional arguments specify a buffer of BUFLEN starting at BUF. The last argument is a pointer to a variable which gets the value which would be stored in the global variable `herrno' by the non-reentrant functions. These functions are not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation they are cancellation points and therefore not marked with __THROW. / extern int getnetent_r (struct netent __restrict __result_buf, char __restrict __buf, size_t __buflen, struct netent __restrict __result, int __restrict __h_errnop); extern int getnetbyaddr_r (uint32_t __net, int __type, struct netent __restrict __result_buf, char __restrict __buf, size_t __buflen, struct netent *__restrict __result, int __restrict __h_errnop); extern int getnetbyname_r (const char __restrict __name, struct netent __restrict __result_buf, char __restrict __buf, size_t __buflen, struct netent __restrict __result, int __restrict __h_errnop); #endif /* misc / / Description of data base entry for a single service. / struct servent { char s_name; /* Official service name. / char s_aliases; / Alias list. / int s_port; / Port number. / char s_proto; /* Protocol to use. / }; / Open service data base files and mark them as staying open even after a later search if STAY_OPEN is non-zero. This function is a possible cancellation point and therefore not marked with __THROW. / extern void setservent (int __stay_open); / Close service data base files and clear `stay open' flag. This function is a possible cancellation point and therefore not marked with __THROW. / extern void endservent (void); / Get next entry from service data base file. Open data base if necessary. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct servent getservent (void); /* Return entry from network data base for network with NAME and protocol PROTO. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct servent getservbyname (const char __name, const char __proto); /* Return entry from service data base which matches port PORT and protocol PROTO. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct servent getservbyport (int __port, const char __proto); #ifdef __USE_MISC / Reentrant versions of the functions above. The additional arguments specify a buffer of BUFLEN starting at BUF. These functions are not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation they are cancellation points and therefore not marked with __THROW. / extern int getservent_r (struct servent __restrict __result_buf, char __restrict __buf, size_t __buflen, struct servent __restrict __result); extern int getservbyname_r (const char __restrict __name, const char __restrict __proto, struct servent __restrict __result_buf, char __restrict __buf, size_t __buflen, struct servent __restrict __result); extern int getservbyport_r (int __port, const char __restrict __proto, struct servent __restrict __result_buf, char __restrict __buf, size_t __buflen, struct servent *__restrict __result); #endif / misc / / Description of data base entry for a single service. / struct protoent { char p_name; /* Official protocol name. / char p_aliases; / Alias list. / int p_proto; / Protocol number. / }; / Open protocol data base files and mark them as staying open even after a later search if STAY_OPEN is non-zero. This function is a possible cancellation point and therefore not marked with __THROW. / extern void setprotoent (int __stay_open); / Close protocol data base files and clear `stay open' flag. This function is a possible cancellation point and therefore not marked with __THROW. / extern void endprotoent (void); / Get next entry from protocol data base file. Open data base if necessary. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct protoent getprotoent (void); /* Return entry from protocol data base for network with NAME. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct protoent getprotobyname (const char __name); / Return entry from protocol data base which number is PROTO. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct protoent getprotobynumber (int __proto); #ifdef __USE_MISC /* Reentrant versions of the functions above. The additional arguments specify a buffer of BUFLEN starting at BUF. These functions are not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation they are cancellation points and therefore not marked with __THROW. / extern int getprotoent_r (struct protoent __restrict __result_buf, char __restrict __buf, size_t __buflen, struct protoent __restrict __result); extern int getprotobyname_r (const char __restrict __name, struct protoent __restrict __result_buf, char __restrict __buf, size_t __buflen, struct protoent *__restrict __result); extern int getprotobynumber_r (int __proto, struct protoent __restrict __result_buf, char __restrict __buf, size_t __buflen, struct protoent __restrict __result); / Establish network group NETGROUP for enumeration. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int setnetgrent (const char __netgroup); /* Free all space allocated by previous `setnetgrent' call. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern void endnetgrent (void); / Get next member of netgroup established by last `setnetgrent' call and return pointers to elements in HOSTP, USERP, and DOMAINP. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int getnetgrent (char __restrict __hostp, char __restrict __userp, char __restrict __domainp); / Test whether NETGROUP contains the triple (HOST,USER,DOMAIN). This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int innetgr (const char __netgroup, const char __host, const char __user, const char __domain); / Reentrant version of `getnetgrent' where result is placed in BUFFER. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int getnetgrent_r (char __restrict __hostp, char __restrict __userp, char __restrict __domainp, char __restrict __buffer, size_t __buflen); #endif /* misc / #ifdef __USE_MISC / Call `rshd' at port RPORT on remote machine AHOST to execute CMD. The local user is LOCUSER, on the remote machine the command is executed as REMUSER. In FD2P the descriptor to the socket for the connection is returned. The caller must have the right to use a reserved port. When the function returns AHOST contains the official host name. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int rcmd (char *__restrict __ahost, unsigned short int __rport, const char __restrict __locuser, const char __restrict __remuser, const char __restrict __cmd, int __restrict __fd2p); / This is the equivalent function where the protocol can be selected and which therefore can be used for IPv6. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int rcmd_af (char __restrict __ahost, unsigned short int __rport, const char __restrict __locuser, const char __restrict __remuser, const char __restrict __cmd, int __restrict __fd2p, sa_family_t __af); / Call `rexecd' at port RPORT on remote machine AHOST to execute CMD. The process runs at the remote machine using the ID of user NAME whose cleartext password is PASSWD. In FD2P the descriptor to the socket for the connection is returned. When the function returns AHOST contains the official host name. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int rexec (char *__restrict __ahost, int __rport, const char __restrict __name, const char __restrict __pass, const char __restrict __cmd, int __restrict __fd2p); / This is the equivalent function where the protocol can be selected and which therefore can be used for IPv6. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int rexec_af (char __restrict __ahost, int __rport, const char __restrict __name, const char __restrict __pass, const char __restrict __cmd, int __restrict __fd2p, sa_family_t __af); / Check whether user REMUSER on system RHOST is allowed to login as LOCUSER. If SUSER is not zero the user tries to become superuser. Return 0 if it is possible. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int ruserok (const char __rhost, int __suser, const char __remuser, const char __locuser); /* This is the equivalent function where the protocol can be selected and which therefore can be used for IPv6. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int ruserok_af (const char __rhost, int __suser, const char __remuser, const char __locuser, sa_family_t __af); /* Check whether user REMUSER on system indicated by IPv4 address RADDR is allowed to login as LOCUSER. Non-IPv4 (e.g., IPv6) are not supported. If SUSER is not zero the user tries to become superuser. Return 0 if it is possible. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int iruserok (uint32_t __raddr, int __suser, const char __remuser, const char __locuser); / This is the equivalent function where the pfamiliy if the address pointed to by RADDR is determined by the value of AF. It therefore can be used for IPv6 This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int iruserok_af (const void __raddr, int __suser, const char __remuser, const char __locuser, sa_family_t __af); /* Try to allocate reserved port, returning a descriptor for a socket opened at this port or -1 if unsuccessful. The search for an available port will start at ALPORT and continues with lower numbers. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int rresvport (int __alport); /* This is the equivalent function where the protocol can be selected and which therefore can be used for IPv6. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int rresvport_af (int __alport, sa_family_t __af); #endif /* Extension from POSIX.1:2001. / #ifdef __USE_XOPEN2K / Structure to contain information about address of a service provider. / struct addrinfo { int ai_flags; / Input flags. / int ai_family; / Protocol family for socket. / int ai_socktype; / Socket type. / int ai_protocol; / Protocol for socket. / socklen_t ai_addrlen; / Length of socket address. / struct sockaddr ai_addr; /* Socket address for socket. / char ai_canonname; /* Canonical name for service location. / struct addrinfo ai_next; /* Pointer to next in list. / }; # ifdef __USE_GNU / Structure used as control block for asynchronous lookup. / struct gaicb { const char ar_name; /* Name to look up. / const char ar_service; /* Service name. / const struct addrinfo ar_request; /* Additional request specification. / struct addrinfo ar_result; /* Pointer to result. / / The following are internal elements. / int __return; int __glibc_reserved[5]; }; / Lookup mode. / # define GAI_WAIT 0 # define GAI_NOWAIT 1 # endif / Possible values for `ai_flags' field in `addrinfo' structure. / # define AI_PASSIVE 0x0001 / Socket address is intended for `bind'. / # define AI_CANONNAME 0x0002 / Request for canonical name. / # define AI_NUMERICHOST 0x0004 / Don't use name resolution. / # define AI_V4MAPPED 0x0008 / IPv4 mapped addresses are acceptable. / # define AI_ALL 0x0010 / Return IPv4 mapped and IPv6 addresses. / # define AI_ADDRCONFIG 0x0020 / Use configuration of this host to choose returned address type.. / # ifdef __USE_GNU # define AI_IDN 0x0040 / IDN encode input (assuming it is encoded in the current locale's character set) before looking it up. / # define AI_CANONIDN 0x0080 / Translate canonical name from IDN format. / # define AI_IDN_ALLOW_UNASSIGNED \ __glibc_macro_warning ("AI_IDN_ALLOW_UNASSIGNED is deprecated") 0x0100 # define AI_IDN_USE_STD3_ASCII_RULES \ __glibc_macro_warning ("AI_IDN_USE_STD3_ASCII_RULES is deprecated") 0x0200 # endif # define AI_NUMERICSERV 0x0400 / Don't use name resolution. / / Error values for `getaddrinfo' function. / # define EAI_BADFLAGS -1 / Invalid value for `ai_flags' field. / # define EAI_NONAME -2 / NAME or SERVICE is unknown. / # define EAI_AGAIN -3 / Temporary failure in name resolution. / # define EAI_FAIL -4 / Non-recoverable failure in name res. / # define EAI_FAMILY -6 / `ai_family' not supported. / # define EAI_SOCKTYPE -7 / `ai_socktype' not supported. / # define EAI_SERVICE -8 / SERVICE not supported for `ai_socktype'. / # define EAI_MEMORY -10 / Memory allocation failure. / # define EAI_SYSTEM -11 / System error returned in `errno'. / # define EAI_OVERFLOW -12 / Argument buffer overflow. / # ifdef __USE_GNU # define EAI_NODATA -5 / No address associated with NAME. / # define EAI_ADDRFAMILY -9 / Address family for NAME not supported. / # define EAI_INPROGRESS -100 / Processing request in progress. / # define EAI_CANCELED -101 / Request canceled. / # define EAI_NOTCANCELED -102 / Request not canceled. / # define EAI_ALLDONE -103 / All requests done. / # define EAI_INTR -104 / Interrupted by a signal. / # define EAI_IDN_ENCODE -105 / IDN encoding failed. / # endif # ifdef __USE_MISC # define NI_MAXHOST 1025 # define NI_MAXSERV 32 # endif # define NI_NUMERICHOST 1 / Don't try to look up hostname. / # define NI_NUMERICSERV 2 / Don't convert port number to name. / # define NI_NOFQDN 4 / Only return nodename portion. / # define NI_NAMEREQD 8 / Don't return numeric addresses. / # define NI_DGRAM 16 / Look up UDP service rather than TCP. / # ifdef __USE_GNU # define NI_IDN 32 / Convert name from IDN format. / # define NI_IDN_ALLOW_UNASSIGNED \ __glibc_macro_warning ("NI_IDN_ALLOW_UNASSIGNED is deprecated") 64 # define NI_IDN_USE_STD3_ASCII_RULES \ __glibc_macro_warning ("NI_IDN_USE_STD3_ASCII_RULES is deprecated") 128 # endif / Translate name of a service location and/or a service name to set of socket addresses. This function is a possible cancellation point and therefore not marked with __THROW. / extern int getaddrinfo (const char __restrict __name, const char __restrict __service, const struct addrinfo __restrict __req, struct addrinfo *__restrict __pai); / Free `addrinfo' structure AI including associated storage. / extern void freeaddrinfo (struct addrinfo __ai) __THROW; /* Convert error return from getaddrinfo() to a string. / extern const char gai_strerror (int __ecode) __THROW; /* Translate a socket address to a location and service name. This function is a possible cancellation point and therefore not marked with __THROW. / extern int getnameinfo (const struct sockaddr __restrict __sa, socklen_t __salen, char __restrict __host, socklen_t __hostlen, char __restrict __serv, socklen_t __servlen, int __flags); #endif /* POSIX / #ifdef __USE_GNU / Enqueue ENT requests from the LIST. If MODE is GAI_WAIT wait until all requests are handled. If WAIT is GAI_NOWAIT return immediately after queueing the requests and signal completion according to SIG. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int getaddrinfo_a (int __mode, struct gaicb __list[__restrict_arr], int __ent, struct sigevent __restrict __sig); / Suspend execution of the thread until at least one of the ENT requests in LIST is handled. If TIMEOUT is not a null pointer it specifies the longest time the function keeps waiting before returning with an error. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int gai_suspend (const struct gaicb const __list[], int __ent, const struct timespec __timeout); # ifdef __USE_TIME_BITS64 # if defined(__REDIRECT) extern int __REDIRECT (gai_suspend, (const struct gaicb const __list[], int __ent, const struct timespec __timeout), __gai_suspend_time64); # else # define gai_suspend __gai_suspend_time64 # endif # endif / Get the error status of the request REQ. / extern int gai_error (struct gaicb __req) __THROW; /* Cancel the requests associated with GAICBP. / extern int gai_cancel (struct gaicb __gaicbp) __THROW; #endif /* GNU / __END_DECLS #endif / netdb.h */	27.79 KB	2026-02-17 11:02
📁 neteconet	-	2026-03-21 15:44
📁 netinet	-	2026-03-21 15:44
📁 netipx	-	2026-03-21 15:44
📁 netiucv	-	2026-03-21 15:44
📁 netpacket	-	2026-03-21 15:44
📁 netrom	-	2026-03-21 15:44
📁 netrose	-	2026-03-21 15:44
📁 nfs	-	2026-03-21 15:44
📁 nghttp2	-	2026-03-31 19:08
📄 nl_types.h /* Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _NL_TYPES_H #define _NL_TYPES_H 1 #include <features.h> / The default message set used by the gencat program. / #define NL_SETD 1 / Value for FLAG parameter of `catgets' to say we want XPG4 compliance. / #define NL_CAT_LOCALE 1 __BEGIN_DECLS / Message catalog descriptor type. / typedef void nl_catd; /* Type used by `nl_langinfo'. / typedef int nl_item; / Open message catalog for later use, returning descriptor. This function is a possible cancellation point and therefore not marked with __THROW. / extern nl_catd catopen (const char __cat_name, int __flag) __nonnull ((1)); /* Return translation with NUMBER in SET of CATALOG; if not found return STRING. / extern char catgets (nl_catd __catalog, int __set, int __number, const char __string) __THROW __nonnull ((1)); / Close message CATALOG. / extern int catclose (nl_catd __catalog) __THROW __nonnull ((1)); __END_DECLS #endif / nl_types.h */	1.71 KB	2026-02-17 11:01
📄 nlist.h /* Interface for nlist. Copyright (C) 1998, 1999, 2000, 2002 Red Hat, Inc. This file is part of elfutils. This file is free software; you can redistribute it and/or modify it under the terms of either * the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version or * the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version or both in parallel, as here. elfutils is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received copies of the GNU General Public License and the GNU Lesser General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. / #ifndef _NLIST_H #define _NLIST_H 1 / Symbol list type. / struct nlist { char n_name; /* Symbol name. / long int n_value; / Value of symbol. / short int n_scnum; / Section number found in. / unsigned short int n_type; / Type of symbol. / char n_sclass; / Storage class. / char n_numaux; / Number of auxiliary entries. / }; #ifdef __cplusplus extern "C" { #endif / Get specified entries from file. / extern int nlist (__const char __filename, struct nlist __nl); #ifdef __cplusplus } #endif #endif / nlist.h */	1.56 KB	2025-04-25 20:16
📄 nss.h /* Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / Define interface to NSS. This is meant for the interface functions and for implementors of new services. / #ifndef _NSS_H #define _NSS_H 1 #include <features.h> #include <stddef.h> #include <stdint.h> #include <sys/types.h> __BEGIN_DECLS / Possible results of lookup using a nss_* function. / enum nss_status { NSS_STATUS_TRYAGAIN = -2, NSS_STATUS_UNAVAIL, NSS_STATUS_NOTFOUND, NSS_STATUS_SUCCESS, NSS_STATUS_RETURN }; / Data structure used for the 'gethostbyname4_r' function. / struct gaih_addrtuple { struct gaih_addrtuple next; char name; int family; uint32_t addr[4]; uint32_t scopeid; }; / Overwrite service selection for database DBNAME using specification in STRING. This function should only be used by system programs which have to work around non-existing services (e.e., while booting). Attention: Using this function repeatedly will slowly eat up the whole memory since previous selection data cannot be freed. / extern int __nss_configure_lookup (const char __dbname, const char __string) __THROW; / NSS-related types. / struct __netgrent; struct aliasent; struct ether_addr; struct etherent; struct group; struct hostent; struct netent; struct passwd; struct protoent; struct rpcent; struct servent; struct sgrp; struct spwd; struct traced_file; / Types of functions exported from NSS service modules. / typedef enum nss_status nss_endaliasent (void); typedef enum nss_status nss_endetherent (void); typedef enum nss_status nss_endgrent (void); typedef enum nss_status nss_endhostent (void); typedef enum nss_status nss_endnetent (void); typedef enum nss_status nss_endnetgrent (struct __netgrent ); typedef enum nss_status nss_endprotoent (void); typedef enum nss_status nss_endpwent (void); typedef enum nss_status nss_endrpcent (void); typedef enum nss_status nss_endservent (void); typedef enum nss_status nss_endsgent (void); typedef enum nss_status nss_endspent (void); typedef enum nss_status nss_getaliasbyname_r (const char , struct aliasent , char , size_t, int ); typedef enum nss_status nss_getaliasent_r (struct aliasent , char , size_t, int ); typedef enum nss_status nss_getcanonname_r (const char , char , size_t, char , int , int ); typedef enum nss_status nss_getetherent_r (struct etherent , char , size_t, int ); typedef enum nss_status nss_getgrent_r (struct group , char , size_t, int ); typedef enum nss_status nss_getgrgid_r (__gid_t, struct group , char , size_t, int ); typedef enum nss_status nss_getgrnam_r (const char , struct group , char , size_t, int ); typedef enum nss_status nss_gethostbyaddr2_r (const void , __socklen_t, int, struct hostent , char , size_t, int , int , int32_t ); typedef enum nss_status nss_gethostbyaddr_r (const void , __socklen_t, int, struct hostent , char , size_t, int , int ); typedef enum nss_status nss_gethostbyname2_r (const char , int, struct hostent , char , size_t, int , int ); typedef enum nss_status nss_gethostbyname3_r (const char , int, struct hostent , char , size_t, int , int , int32_t , char *); typedef enum nss_status nss_gethostbyname4_r (const char , struct gaih_addrtuple *, char , size_t, int , int , int32_t ); typedef enum nss_status nss_gethostbyname_r (const char , struct hostent , char , size_t, int , int ); typedef enum nss_status nss_gethostent_r (struct hostent , char , size_t, int , int ); typedef enum nss_status nss_gethostton_r (const char , struct etherent , char , size_t, int ); typedef enum nss_status nss_getnetbyaddr_r (uint32_t, int, struct netent , char , size_t, int , int ); typedef enum nss_status nss_getnetbyname_r (const char , struct netent , char , size_t, int , int ); typedef enum nss_status nss_getnetent_r (struct netent , char , size_t, int , int ); typedef enum nss_status nss_getnetgrent_r (struct __netgrent , char , size_t, int ); typedef enum nss_status nss_getntohost_r (const struct ether_addr , struct etherent , char , size_t, int ); typedef enum nss_status nss_getprotobyname_r (const char , struct protoent , char , size_t, int ); typedef enum nss_status nss_getprotobynumber_r (int, struct protoent , char , size_t, int ); typedef enum nss_status nss_getprotoent_r (struct protoent , char , size_t, int ); typedef enum nss_status nss_getpublickey (const char , char , int ); typedef enum nss_status nss_getpwent_r (struct passwd , char , size_t, int ); typedef enum nss_status nss_getpwnam_r (const char , struct passwd , char , size_t, int ); typedef enum nss_status nss_getpwuid_r (__uid_t, struct passwd , char , size_t, int ); typedef enum nss_status nss_getrpcbyname_r (const char , struct rpcent , char , size_t, int ); typedef enum nss_status nss_getrpcbynumber_r (int, struct rpcent , char , size_t, int ); typedef enum nss_status nss_getrpcent_r (struct rpcent , char , size_t, int ); typedef enum nss_status nss_getsecretkey (const char , char , char , int ); typedef enum nss_status nss_getservbyname_r (const char , const char , struct servent , char , size_t, int ); typedef enum nss_status nss_getservbyport_r (int, const char , struct servent , char , size_t, int ); typedef enum nss_status nss_getservent_r (struct servent , char , size_t, int ); typedef enum nss_status nss_getsgent_r (struct sgrp , char , size_t, int ); typedef enum nss_status nss_getsgnam_r (const char , struct sgrp , char , size_t, int ); typedef enum nss_status nss_getspent_r (struct spwd , char , size_t, int ); typedef enum nss_status nss_getspnam_r (const char , struct spwd , char , size_t, int ); typedef void nss_init (void () (size_t, struct traced_file )); typedef enum nss_status nss_initgroups_dyn (const char , __gid_t, long int , long int , __gid_t *, long int, int ); typedef enum nss_status nss_netname2user (char [], __uid_t , __gid_t , int , __gid_t , int ); typedef enum nss_status nss_setaliasent (void); typedef enum nss_status nss_setetherent (int); typedef enum nss_status nss_setgrent (int); typedef enum nss_status nss_sethostent (int); typedef enum nss_status nss_setnetent (int); typedef enum nss_status nss_setnetgrent (const char , struct __netgrent ); typedef enum nss_status nss_setprotoent (int); typedef enum nss_status nss_setpwent (int); typedef enum nss_status nss_setrpcent (int); typedef enum nss_status nss_setservent (int); typedef enum nss_status nss_setsgent (int); typedef enum nss_status nss_setspent (int); / Declare all NSS functions for MODULE. / #define NSS_DECLARE_MODULE_FUNCTIONS(module) \ extern nss_endaliasent _nss_##module##_endaliasent; \ extern nss_endetherent _nss_##module##_endetherent; \ extern nss_endgrent _nss_##module##_endgrent; \ extern nss_endhostent _nss_##module##_endhostent; \ extern nss_endnetent _nss_##module##_endnetent; \ extern nss_endnetgrent _nss_##module##_endnetgrent; \ extern nss_endprotoent _nss_##module##_endprotoent; \ extern nss_endpwent _nss_##module##_endpwent; \ extern nss_endrpcent _nss_##module##_endrpcent; \ extern nss_endservent _nss_##module##_endservent; \ extern nss_endsgent _nss_##module##_endsgent; \ extern nss_endspent _nss_##module##_endspent; \ extern nss_getaliasbyname_r _nss_##module##_getaliasbyname_r; \ extern nss_getaliasent_r _nss_##module##_getaliasent_r; \ extern nss_getcanonname_r _nss_##module##_getcanonname_r; \ extern nss_getetherent_r _nss_##module##_getetherent_r; \ extern nss_getgrent_r _nss_##module##_getgrent_r; \ extern nss_getgrgid_r _nss_##module##_getgrgid_r; \ extern nss_getgrnam_r _nss_##module##_getgrnam_r; \ extern nss_gethostbyaddr2_r _nss_##module##_gethostbyaddr2_r; \ extern nss_gethostbyaddr_r _nss_##module##_gethostbyaddr_r; \ extern nss_gethostbyname2_r _nss_##module##_gethostbyname2_r; \ extern nss_gethostbyname3_r _nss_##module##_gethostbyname3_r; \ extern nss_gethostbyname4_r _nss_##module##_gethostbyname4_r; \ extern nss_gethostbyname_r _nss_##module##_gethostbyname_r; \ extern nss_gethostent_r _nss_##module##_gethostent_r; \ extern nss_gethostton_r _nss_##module##_gethostton_r; \ extern nss_getnetbyaddr_r _nss_##module##_getnetbyaddr_r; \ extern nss_getnetbyname_r _nss_##module##_getnetbyname_r; \ extern nss_getnetent_r _nss_##module##_getnetent_r; \ extern nss_getnetgrent_r _nss_##module##_getnetgrent_r; \ extern nss_getntohost_r _nss_##module##_getntohost_r; \ extern nss_getprotobyname_r _nss_##module##_getprotobyname_r; \ extern nss_getprotobynumber_r _nss_##module##_getprotobynumber_r; \ extern nss_getprotoent_r _nss_##module##_getprotoent_r; \ extern nss_getpublickey _nss_##module##_getpublickey; \ extern nss_getpwent_r _nss_##module##_getpwent_r; \ extern nss_getpwnam_r _nss_##module##_getpwnam_r; \ extern nss_getpwuid_r _nss_##module##_getpwuid_r; \ extern nss_getrpcbyname_r _nss_##module##_getrpcbyname_r; \ extern nss_getrpcbynumber_r _nss_##module##_getrpcbynumber_r; \ extern nss_getrpcent_r _nss_##module##_getrpcent_r; \ extern nss_getsecretkey _nss_##module##_getsecretkey; \ extern nss_getservbyname_r _nss_##module##_getservbyname_r; \ extern nss_getservbyport_r _nss_##module##_getservbyport_r; \ extern nss_getservent_r _nss_##module##_getservent_r; \ extern nss_getsgent_r _nss_##module##_getsgent_r; \ extern nss_getsgnam_r _nss_##module##_getsgnam_r; \ extern nss_getspent_r _nss_##module##_getspent_r; \ extern nss_getspnam_r _nss_##module##_getspnam_r; \ extern nss_init _nss_##module##_init; \ extern nss_initgroups_dyn _nss_##module##_initgroups_dyn; \ extern nss_netname2user _nss_##module##_netname2user; \ extern nss_setaliasent _nss_##module##_setaliasent; \ extern nss_setetherent _nss_##module##_setetherent; \ extern nss_setgrent _nss_##module##_setgrent; \ extern nss_sethostent _nss_##module##_sethostent; \ extern nss_setnetent _nss_##module##_setnetent; \ extern nss_setnetgrent _nss_##module##_setnetgrent; \ extern nss_setprotoent _nss_##module##_setprotoent; \ extern nss_setpwent _nss_##module##_setpwent; \ extern nss_setrpcent _nss_##module##_setrpcent; \ extern nss_setservent _nss_##module##_setservent; \ extern nss_setsgent _nss_##module##_setsgent; \ extern nss_setspent _nss_##module##_setspent; \ __END_DECLS #endif / nss.h */	14.07 KB	2026-02-17 11:02
📄 obstack.h /* obstack.h - object stack macros Copyright (C) 1988-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / Summary: All the apparent functions defined here are macros. The idea is that you would use these pre-tested macros to solve a very specific set of problems, and they would run fast. Caution: no side-effects in arguments please!! They may be evaluated MANY times!! These macros operate a stack of objects. Each object starts life small, and may grow to maturity. (Consider building a word syllable by syllable.) An object can move while it is growing. Once it has been "finished" it never changes address again. So the "top of the stack" is typically an immature growing object, while the rest of the stack is of mature, fixed size and fixed address objects. These routines grab large chunks of memory, using a function you supply, called 'obstack_chunk_alloc'. On occasion, they free chunks, by calling 'obstack_chunk_free'. You must define them and declare them before using any obstack macros. Each independent stack is represented by a 'struct obstack'. Each of the obstack macros expects a pointer to such a structure as the first argument. One motivation for this package is the problem of growing char strings in symbol tables. Unless you are "fascist pig with a read-only mind" --Gosper's immortal quote from HAKMEM item 154, out of context--you would not like to put any arbitrary upper limit on the length of your symbols. In practice this often means you will build many short symbols and a few long symbols. At the time you are reading a symbol you don't know how long it is. One traditional method is to read a symbol into a buffer, realloc()ating the buffer every time you try to read a symbol that is longer than the buffer. This is beaut, but you still will want to copy the symbol from the buffer to a more permanent symbol-table entry say about half the time. With obstacks, you can work differently. Use one obstack for all symbol names. As you read a symbol, grow the name in the obstack gradually. When the name is complete, finalize it. Then, if the symbol exists already, free the newly read name. The way we do this is to take a large chunk, allocating memory from low addresses. When you want to build a symbol in the chunk you just add chars above the current "high water mark" in the chunk. When you have finished adding chars, because you got to the end of the symbol, you know how long the chars are, and you can create a new object. Mostly the chars will not burst over the highest address of the chunk, because you would typically expect a chunk to be (say) 100 times as long as an average object. In case that isn't clear, when we have enough chars to make up the object, THEY ARE ALREADY CONTIGUOUS IN THE CHUNK (guaranteed) so we just point to it where it lies. No moving of chars is needed and this is the second win: potentially long strings need never be explicitly shuffled. Once an object is formed, it does not change its address during its lifetime. When the chars burst over a chunk boundary, we allocate a larger chunk, and then copy the partly formed object from the end of the old chunk to the beginning of the new larger chunk. We then carry on accreting characters to the end of the object as we normally would. A special macro is provided to add a single char at a time to a growing object. This allows the use of register variables, which break the ordinary 'growth' macro. Summary: We allocate large chunks. We carve out one object at a time from the current chunk. Once carved, an object never moves. We are free to append data of any size to the currently growing object. Exactly one object is growing in an obstack at any one time. You can run one obstack per control block. You may have as many control blocks as you dare. Because of the way we do it, you can "unwind" an obstack back to a previous state. (You may remove objects much as you would with a stack.) / / Don't do the contents of this file more than once. / #ifndef _OBSTACK_H #define _OBSTACK_H 1 / We need the type of a pointer subtraction. If __PTRDIFF_TYPE__ is defined, as with GNU C, use that; that way we don't pollute the namespace with <stddef.h>'s symbols. Otherwise, include <stddef.h> and use ptrdiff_t. / #ifdef __PTRDIFF_TYPE__ # define PTR_INT_TYPE __PTRDIFF_TYPE__ #else # include <stddef.h> # define PTR_INT_TYPE ptrdiff_t #endif / If B is the base of an object addressed by P, return the result of aligning P to the next multiple of A + 1. B and P must be of type char . A + 1 must be a power of 2. / #define __BPTR_ALIGN(B, P, A) ((B) + (((P) - (B) + (A)) & ~(A))) /* Similar to _BPTR_ALIGN (B, P, A), except optimize the common case where pointers can be converted to integers, aligned as integers, and converted back again. If PTR_INT_TYPE is narrower than a pointer (e.g., the AS/400), play it safe and compute the alignment relative to B. Otherwise, use the faster strategy of computing the alignment relative to 0. / #define __PTR_ALIGN(B, P, A) \ __BPTR_ALIGN (sizeof (PTR_INT_TYPE) < sizeof (void ) ? (B) : (char ) 0, \ P, A) #include <string.h> #ifndef __attribute_pure__ # define __attribute_pure__ _GL_ATTRIBUTE_PURE #endif #ifdef __cplusplus extern "C" { #endif struct _obstack_chunk / Lives at front of each chunk. / { char limit; /* 1 past end of this chunk / struct _obstack_chunk prev; /* address of prior chunk or NULL / char contents[4]; / objects begin here / }; struct obstack / control current object in current chunk / { long chunk_size; / preferred size to allocate chunks in / struct _obstack_chunk chunk; /* address of current struct obstack_chunk / char object_base; /* address of object we are building / char next_free; /* where to add next char to current object / char chunk_limit; /* address of char after current chunk / union { PTR_INT_TYPE tempint; void tempptr; } temp; /* Temporary for some macros. / int alignment_mask; / Mask of alignment for each object. / / These prototypes vary based on 'use_extra_arg', and we use casts to the prototypeless function type in all assignments, but having prototypes here quiets -Wstrict-prototypes. / struct _obstack_chunk (chunkfun) (void , long); void (freefun) (void , struct _obstack_chunk ); void extra_arg; /* first arg for chunk alloc/dealloc funcs / unsigned use_extra_arg : 1; / chunk alloc/dealloc funcs take extra arg / unsigned maybe_empty_object : 1; / There is a possibility that the current chunk contains a zero-length object. This prevents freeing the chunk if we allocate a bigger chunk to replace it. / unsigned alloc_failed : 1; / No longer used, as we now call the failed handler on error, but retained for binary compatibility. / }; / Declare the external functions we use; they are in obstack.c. / extern void _obstack_newchunk (struct obstack , int); extern int _obstack_begin (struct obstack , int, int, void ()(long), void ()(void )); extern int _obstack_begin_1 (struct obstack , int, int, void ()(void , long), void ()(void , void ), void ); extern int _obstack_memory_used (struct obstack ) __attribute_pure__; /* The default name of the function for freeing a chunk is 'obstack_free', but gnulib users can override this by defining '__obstack_free'. / #ifndef __obstack_free # define __obstack_free obstack_free #endif extern void __obstack_free (struct obstack , void ); / Error handler called when 'obstack_chunk_alloc' failed to allocate more memory. This can be set to a user defined function which should either abort gracefully or use longjump - but shouldn't return. The default action is to print a message and abort. / extern void (obstack_alloc_failed_handler) (void); /* Exit value used when 'print_and_abort' is used. / extern int obstack_exit_failure; / Pointer to beginning of object being allocated or to be allocated next. Note that this might not be the final address of the object because a new chunk might be needed to hold the final size. / #define obstack_base(h) ((void ) (h)->object_base) /* Size for allocating ordinary chunks. / #define obstack_chunk_size(h) ((h)->chunk_size) / Pointer to next byte not yet allocated in current chunk. / #define obstack_next_free(h) ((h)->next_free) / Mask specifying low bits that should be clear in address of an object. / #define obstack_alignment_mask(h) ((h)->alignment_mask) / To prevent prototype warnings provide complete argument list. / #define obstack_init(h) \ _obstack_begin ((h), 0, 0, \ (void ()(long))obstack_chunk_alloc, \ (void ()(void ))obstack_chunk_free) #define obstack_begin(h, size) \ _obstack_begin ((h), (size), 0, \ (void ()(long))obstack_chunk_alloc, \ (void ()(void ))obstack_chunk_free) #define obstack_specify_allocation(h, size, alignment, chunkfun, freefun) \ _obstack_begin ((h), (size), (alignment), \ (void ()(long))(chunkfun), \ (void ()(void ))(freefun)) #define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \ _obstack_begin_1 ((h), (size), (alignment), \ (void ()(void , long))(chunkfun), \ (void ()(void , void ))(freefun), (arg)) #define obstack_chunkfun(h, newchunkfun) \ ((h)->chunkfun = (struct _obstack_chunk ()(void , long))(newchunkfun)) #define obstack_freefun(h, newfreefun) \ ((h)->freefun = (void ()(void , struct _obstack_chunk ))(newfreefun)) #define obstack_1grow_fast(h, achar) (((h)->next_free)++ = (achar)) #define obstack_blank_fast(h, n) ((h)->next_free += (n)) #define obstack_memory_used(h) _obstack_memory_used (h) #if defined __GNUC__ # if ! (2 < __GNUC__ + (8 <= __GNUC_MINOR__)) # define __extension__ # endif /* For GNU C, if not -traditional, we can define these macros to compute all args only once without using a global variable. Also, we can avoid using the 'temp' slot, to make faster code. / # define obstack_object_size(OBSTACK) \ __extension__ \ ({ struct obstack const __o = (OBSTACK); \ (unsigned) (__o->next_free - __o->object_base); }) # define obstack_room(OBSTACK) \ __extension__ \ ({ struct obstack const __o = (OBSTACK); \ (unsigned) (__o->chunk_limit - __o->next_free); }) # define obstack_make_room(OBSTACK, length) \ __extension__ \ ({ struct obstack __o = (OBSTACK); \ int __len = (length); \ if (__o->chunk_limit - __o->next_free < __len) \ _obstack_newchunk (__o, __len); \ (void) 0; }) # define obstack_empty_p(OBSTACK) \ __extension__ \ ({ struct obstack const __o = (OBSTACK); \ (__o->chunk->prev == 0 \ && __o->next_free == __PTR_ALIGN ((char ) __o->chunk, \ __o->chunk->contents, \ __o->alignment_mask)); }) # define obstack_grow(OBSTACK, where, length) \ __extension__ \ ({ struct obstack __o = (OBSTACK); \ int __len = (length); \ if (__o->next_free + __len > __o->chunk_limit) \ _obstack_newchunk (__o, __len); \ memcpy (__o->next_free, where, __len); \ __o->next_free += __len; \ (void) 0; }) # define obstack_grow0(OBSTACK, where, length) \ __extension__ \ ({ struct obstack __o = (OBSTACK); \ int __len = (length); \ if (__o->next_free + __len + 1 > __o->chunk_limit) \ _obstack_newchunk (__o, __len + 1); \ memcpy (__o->next_free, where, __len); \ __o->next_free += __len; \ (__o->next_free)++ = 0; \ (void) 0; }) # define obstack_1grow(OBSTACK, datum) \ __extension__ \ ({ struct obstack __o = (OBSTACK); \ if (__o->next_free + 1 > __o->chunk_limit) \ _obstack_newchunk (__o, 1); \ obstack_1grow_fast (__o, datum); \ (void) 0; }) /* These assume that the obstack alignment is good enough for pointers or ints, and that the data added so far to the current object shares that much alignment. / # define obstack_ptr_grow(OBSTACK, datum) \ __extension__ \ ({ struct obstack __o = (OBSTACK); \ if (__o->next_free + sizeof (void ) > __o->chunk_limit) \ _obstack_newchunk (__o, sizeof (void )); \ obstack_ptr_grow_fast (__o, datum); }) \ # define obstack_int_grow(OBSTACK, datum) \ __extension__ \ ({ struct obstack __o = (OBSTACK); \ if (__o->next_free + sizeof (int) > __o->chunk_limit) \ _obstack_newchunk (__o, sizeof (int)); \ obstack_int_grow_fast (__o, datum); }) # define obstack_ptr_grow_fast(OBSTACK, aptr) \ __extension__ \ ({ struct obstack __o1 = (OBSTACK); \ void __p1 = __o1->next_free; \ (const void *) __p1 = (aptr); \ __o1->next_free += sizeof (const void ); \ (void) 0; }) # define obstack_int_grow_fast(OBSTACK, aint) \ __extension__ \ ({ struct obstack __o1 = (OBSTACK); \ void __p1 = __o1->next_free; \ (int ) __p1 = (aint); \ __o1->next_free += sizeof (int); \ (void) 0; }) # define obstack_blank(OBSTACK, length) \ __extension__ \ ({ struct obstack __o = (OBSTACK); \ int __len = (length); \ if (__o->chunk_limit - __o->next_free < __len) \ _obstack_newchunk (__o, __len); \ obstack_blank_fast (__o, __len); \ (void) 0; }) # define obstack_alloc(OBSTACK, length) \ __extension__ \ ({ struct obstack __h = (OBSTACK); \ obstack_blank (__h, (length)); \ obstack_finish (__h); }) # define obstack_copy(OBSTACK, where, length) \ __extension__ \ ({ struct obstack __h = (OBSTACK); \ obstack_grow (__h, (where), (length)); \ obstack_finish (__h); }) # define obstack_copy0(OBSTACK, where, length) \ __extension__ \ ({ struct obstack __h = (OBSTACK); \ obstack_grow0 (__h, (where), (length)); \ obstack_finish (__h); }) /* The local variable is named __o1 to avoid a name conflict when obstack_blank is called. / # define obstack_finish(OBSTACK) \ __extension__ \ ({ struct obstack __o1 = (OBSTACK); \ void __value = (void ) __o1->object_base; \ if (__o1->next_free == __value) \ __o1->maybe_empty_object = 1; \ __o1->next_free \ = __PTR_ALIGN (__o1->object_base, __o1->next_free, \ __o1->alignment_mask); \ if (__o1->next_free - (char ) __o1->chunk \ > __o1->chunk_limit - (char ) __o1->chunk) \ __o1->next_free = __o1->chunk_limit; \ __o1->object_base = __o1->next_free; \ __value; }) # define obstack_free(OBSTACK, OBJ) \ __extension__ \ ({ struct obstack __o = (OBSTACK); \ void __obj = (OBJ); \ if (__obj > (void ) __o->chunk && __obj < (void ) __o->chunk_limit) \ __o->next_free = __o->object_base = (char ) __obj; \ else (__obstack_free) (__o, __obj); }) #else / not __GNUC__ / # define obstack_object_size(h) \ (unsigned) ((h)->next_free - (h)->object_base) # define obstack_room(h) \ (unsigned) ((h)->chunk_limit - (h)->next_free) # define obstack_empty_p(h) \ ((h)->chunk->prev == 0 \ && (h)->next_free == __PTR_ALIGN ((char ) (h)->chunk, \ (h)->chunk->contents, \ (h)->alignment_mask)) /* Note that the call to _obstack_newchunk is enclosed in (..., 0) so that we can avoid having void expressions in the arms of the conditional expression. Casting the third operand to void was tried before, but some compilers won't accept it. / # define obstack_make_room(h, length) \ ((h)->temp.tempint = (length), \ (((h)->next_free + (h)->temp.tempint > (h)->chunk_limit) \ ? (_obstack_newchunk ((h), (h)->temp.tempint), 0) : 0)) # define obstack_grow(h, where, length) \ ((h)->temp.tempint = (length), \ (((h)->next_free + (h)->temp.tempint > (h)->chunk_limit) \ ? (_obstack_newchunk ((h), (h)->temp.tempint), 0) : 0), \ memcpy ((h)->next_free, where, (h)->temp.tempint), \ (h)->next_free += (h)->temp.tempint) # define obstack_grow0(h, where, length) \ ((h)->temp.tempint = (length), \ (((h)->next_free + (h)->temp.tempint + 1 > (h)->chunk_limit) \ ? (_obstack_newchunk ((h), (h)->temp.tempint + 1), 0) : 0), \ memcpy ((h)->next_free, where, (h)->temp.tempint), \ (h)->next_free += (h)->temp.tempint, \ ((h)->next_free)++ = 0) # define obstack_1grow(h, datum) \ ((((h)->next_free + 1 > (h)->chunk_limit) \ ? (_obstack_newchunk ((h), 1), 0) : 0), \ obstack_1grow_fast (h, datum)) # define obstack_ptr_grow(h, datum) \ ((((h)->next_free + sizeof (char ) > (h)->chunk_limit) \ ? (_obstack_newchunk ((h), sizeof (char )), 0) : 0), \ obstack_ptr_grow_fast (h, datum)) # define obstack_int_grow(h, datum) \ ((((h)->next_free + sizeof (int) > (h)->chunk_limit) \ ? (_obstack_newchunk ((h), sizeof (int)), 0) : 0), \ obstack_int_grow_fast (h, datum)) # define obstack_ptr_grow_fast(h, aptr) \ (((const void *) ((h)->next_free += sizeof (void )))[-1] = (aptr)) # define obstack_int_grow_fast(h, aint) \ (((int ) ((h)->next_free += sizeof (int)))[-1] = (aint)) # define obstack_blank(h, length) \ ((h)->temp.tempint = (length), \ (((h)->chunk_limit - (h)->next_free < (h)->temp.tempint) \ ? (_obstack_newchunk ((h), (h)->temp.tempint), 0) : 0), \ obstack_blank_fast (h, (h)->temp.tempint)) # define obstack_alloc(h, length) \ (obstack_blank ((h), (length)), obstack_finish ((h))) # define obstack_copy(h, where, length) \ (obstack_grow ((h), (where), (length)), obstack_finish ((h))) # define obstack_copy0(h, where, length) \ (obstack_grow0 ((h), (where), (length)), obstack_finish ((h))) # define obstack_finish(h) \ (((h)->next_free == (h)->object_base \ ? (((h)->maybe_empty_object = 1), 0) \ : 0), \ (h)->temp.tempptr = (h)->object_base, \ (h)->next_free \ = __PTR_ALIGN ((h)->object_base, (h)->next_free, \ (h)->alignment_mask), \ (((h)->next_free - (char ) (h)->chunk \ > (h)->chunk_limit - (char ) (h)->chunk) \ ? ((h)->next_free = (h)->chunk_limit) : 0), \ (h)->object_base = (h)->next_free, \ (h)->temp.tempptr) # define obstack_free(h, obj) \ ((h)->temp.tempint = (char ) (obj) - (char ) (h)->chunk, \ ((((h)->temp.tempint > 0 \ && (h)->temp.tempint < (h)->chunk_limit - (char ) (h)->chunk)) \ ? (void) ((h)->next_free = (h)->object_base \ = (h)->temp.tempint + (char ) (h)->chunk) \ : (__obstack_free) (h, (h)->temp.tempint + (char ) (h)->chunk))) #endif /* not __GNUC__ / #ifdef __cplusplus } / C++ / #endif #endif / obstack.h */	20.81 KB	2026-02-17 11:01
📄 openldap.h /* $OpenLDAP$ / / This work is part of OpenLDAP Software <http://www.openldap.org/>. * * Copyright 2019-2024 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted only as authorized by the OpenLDAP * Public License. * * A copy of this license is available in file LICENSE in the * top-level directory of the distribution or, alternatively, at * <http://www.OpenLDAP.org/license.html>. / / openldap.h - Header for openldap specific interfaces. / #ifndef _OPENLDAP_H #define _OPENLDAP_H 1 #include <ldap.h> LDAP_BEGIN_DECL #define LDAP_PROTO_TCP 1 / ldap:// / #define LDAP_PROTO_UDP 2 / reserved / #define LDAP_PROTO_IPC 3 / ldapi:// / #define LDAP_PROTO_EXT 4 / user-defined socket/sockbuf / LDAP_F( int ) ldap_init_fd LDAP_P(( ber_socket_t fd, int proto, LDAP_CONST char url, LDAP *ldp )); LDAP_END_DECL #endif / _OPENLDAP_H */	964 B	2024-05-21 17:19
📁 openssl	-	2026-03-21 15:55
📄 paths.h /* * 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_ / Default search path. / #define _PATH_DEFPATH "/usr/bin:/bin" / All standard utilities path. / #define _PATH_STDPATH \ "/usr/bin:/bin:/usr/sbin:/sbin" #define _PATH_BSHELL "/bin/sh" #define _PATH_CONSOLE "/dev/console" #define _PATH_CSHELL "/bin/csh" #define _PATH_DEVDB "/var/run/dev.db" #define _PATH_DEVNULL "/dev/null" #define _PATH_DRUM "/dev/drum" #define _PATH_GSHADOW "/etc/gshadow" #define _PATH_KLOG "/proc/kmsg" #define _PATH_KMEM "/dev/kmem" #define _PATH_LASTLOG "/var/log/lastlog" #define _PATH_MAILDIR "/var/mail" #define _PATH_MAN "/usr/share/man" #define _PATH_MEM "/dev/mem" #define _PATH_MNTTAB "/etc/fstab" #define _PATH_MOUNTED "/etc/mtab" #define _PATH_NOLOGIN "/etc/nologin" #define _PATH_PRESERVE "/var/lib" #define _PATH_RWHODIR "/var/spool/rwho" #define _PATH_SENDMAIL "/usr/sbin/sendmail" #define _PATH_SHADOW "/etc/shadow" #define _PATH_SHELLS "/etc/shells" #define _PATH_TTY "/dev/tty" #define _PATH_UNIX "/boot/vmlinux" #define _PATH_UTMP "/var/run/utmp" #define _PATH_VI "/usr/bin/vi" #define _PATH_WTMP "/var/log/wtmp" / Provide trailing slash, since mostly used for building pathnames. / #define _PATH_DEV "/dev/" #define _PATH_TMP "/tmp/" #define _PATH_VARDB "/var/db/" #define _PATH_VARRUN "/var/run/" #define _PATH_VARTMP "/var/tmp/" #endif / !_PATHS_H_ */	2.91 KB	2026-02-17 11:01
📁 pcp	-	2026-03-21 15:48
📄 pcre2.h /************************************************* * Perl-Compatible Regular Expressions * ************************************************/ / This is the public header file for the PCRE library, second API, to be #included by applications that call PCRE2 functions. Copyright (c) 2016-2021 University of Cambridge ----------------------------------------------------------------------------- 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. * Neither the name of the University of Cambridge 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 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 PCRE2_H_IDEMPOTENT_GUARD #define PCRE2_H_IDEMPOTENT_GUARD / The current PCRE version information. / #define PCRE2_MAJOR 10 #define PCRE2_MINOR 40 #define PCRE2_PRERELEASE #define PCRE2_DATE 2022-04-14 / When an application links to a PCRE DLL in Windows, the symbols that are imported have to be identified as such. When building PCRE2, the appropriate export setting is defined in pcre2_internal.h, which includes this file. So we don't change existing definitions of PCRE2_EXP_DECL. / #if defined(_WIN32) && !defined(PCRE2_STATIC) # ifndef PCRE2_EXP_DECL # define PCRE2_EXP_DECL extern __declspec(dllimport) # endif #endif / By default, we use the standard "extern" declarations. / #ifndef PCRE2_EXP_DECL # ifdef __cplusplus # define PCRE2_EXP_DECL extern "C" # else # define PCRE2_EXP_DECL extern # endif #endif / When compiling with the MSVC compiler, it is sometimes necessary to include a "calling convention" before exported function names. (This is secondhand information; I know nothing about MSVC myself). For example, something like void __cdecl function(....) might be needed. In order so make this easy, all the exported functions have PCRE2_CALL_CONVENTION just before their names. It is rarely needed; if not set, we ensure here that it has no effect. / #ifndef PCRE2_CALL_CONVENTION #define PCRE2_CALL_CONVENTION #endif / Have to include limits.h, stdlib.h, and inttypes.h to ensure that size_t and uint8_t, UCHAR_MAX, etc are defined. Some systems that do have inttypes.h do not have stdint.h, which is why we use inttypes.h, which according to the C standard is a superset of stdint.h. If inttypes.h is not available the build will break and the relevant values must be provided by some other means. / #include <limits.h> #include <stdlib.h> #include <inttypes.h> / Allow for C++ users compiling this directly. / #ifdef __cplusplus extern "C" { #endif / The following option bits can be passed to pcre2_compile(), pcre2_match(), or pcre2_dfa_match(). PCRE2_NO_UTF_CHECK affects only the function to which it is passed. Put these bits at the most significant end of the options word so others can be added next to them / #define PCRE2_ANCHORED 0x80000000u #define PCRE2_NO_UTF_CHECK 0x40000000u #define PCRE2_ENDANCHORED 0x20000000u / The following option bits can be passed only to pcre2_compile(). However, they may affect compilation, JIT compilation, and/or interpretive execution. The following tags indicate which: C alters what is compiled by pcre2_compile() J alters what is compiled by pcre2_jit_compile() M is inspected during pcre2_match() execution D is inspected during pcre2_dfa_match() execution / #define PCRE2_ALLOW_EMPTY_CLASS 0x00000001u / C / #define PCRE2_ALT_BSUX 0x00000002u / C / #define PCRE2_AUTO_CALLOUT 0x00000004u / C / #define PCRE2_CASELESS 0x00000008u / C / #define PCRE2_DOLLAR_ENDONLY 0x00000010u / J M D / #define PCRE2_DOTALL 0x00000020u / C / #define PCRE2_DUPNAMES 0x00000040u / C / #define PCRE2_EXTENDED 0x00000080u / C / #define PCRE2_FIRSTLINE 0x00000100u / J M D / #define PCRE2_MATCH_UNSET_BACKREF 0x00000200u / C J M / #define PCRE2_MULTILINE 0x00000400u / C / #define PCRE2_NEVER_UCP 0x00000800u / C / #define PCRE2_NEVER_UTF 0x00001000u / C / #define PCRE2_NO_AUTO_CAPTURE 0x00002000u / C / #define PCRE2_NO_AUTO_POSSESS 0x00004000u / C / #define PCRE2_NO_DOTSTAR_ANCHOR 0x00008000u / C / #define PCRE2_NO_START_OPTIMIZE 0x00010000u / J M D / #define PCRE2_UCP 0x00020000u / C J M D / #define PCRE2_UNGREEDY 0x00040000u / C / #define PCRE2_UTF 0x00080000u / C J M D / #define PCRE2_NEVER_BACKSLASH_C 0x00100000u / C / #define PCRE2_ALT_CIRCUMFLEX 0x00200000u / J M D / #define PCRE2_ALT_VERBNAMES 0x00400000u / C / #define PCRE2_USE_OFFSET_LIMIT 0x00800000u / J M D / #define PCRE2_EXTENDED_MORE 0x01000000u / C / #define PCRE2_LITERAL 0x02000000u / C / #define PCRE2_MATCH_INVALID_UTF 0x04000000u / J M D / / An additional compile options word is available in the compile context. / #define PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES 0x00000001u / C / #define PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL 0x00000002u / C / #define PCRE2_EXTRA_MATCH_WORD 0x00000004u / C / #define PCRE2_EXTRA_MATCH_LINE 0x00000008u / C / #define PCRE2_EXTRA_ESCAPED_CR_IS_LF 0x00000010u / C / #define PCRE2_EXTRA_ALT_BSUX 0x00000020u / C / #define PCRE2_EXTRA_ALLOW_LOOKAROUND_BSK 0x00000040u / C / / These are for pcre2_jit_compile(). / #define PCRE2_JIT_COMPLETE 0x00000001u / For full matching / #define PCRE2_JIT_PARTIAL_SOFT 0x00000002u #define PCRE2_JIT_PARTIAL_HARD 0x00000004u #define PCRE2_JIT_INVALID_UTF 0x00000100u / These are for pcre2_match(), pcre2_dfa_match(), pcre2_jit_match(), and pcre2_substitute(). Some are allowed only for one of the functions, and in these cases it is noted below. Note that PCRE2_ANCHORED, PCRE2_ENDANCHORED and PCRE2_NO_UTF_CHECK can also be passed to these functions (though pcre2_jit_match() ignores the latter since it bypasses all sanity checks). / #define PCRE2_NOTBOL 0x00000001u #define PCRE2_NOTEOL 0x00000002u #define PCRE2_NOTEMPTY 0x00000004u / ) These two must be kept / #define PCRE2_NOTEMPTY_ATSTART 0x00000008u / ) adjacent to each other. / #define PCRE2_PARTIAL_SOFT 0x00000010u #define PCRE2_PARTIAL_HARD 0x00000020u #define PCRE2_DFA_RESTART 0x00000040u / pcre2_dfa_match() only / #define PCRE2_DFA_SHORTEST 0x00000080u / pcre2_dfa_match() only / #define PCRE2_SUBSTITUTE_GLOBAL 0x00000100u / pcre2_substitute() only / #define PCRE2_SUBSTITUTE_EXTENDED 0x00000200u / pcre2_substitute() only / #define PCRE2_SUBSTITUTE_UNSET_EMPTY 0x00000400u / pcre2_substitute() only / #define PCRE2_SUBSTITUTE_UNKNOWN_UNSET 0x00000800u / pcre2_substitute() only / #define PCRE2_SUBSTITUTE_OVERFLOW_LENGTH 0x00001000u / pcre2_substitute() only / #define PCRE2_NO_JIT 0x00002000u / Not for pcre2_dfa_match() / #define PCRE2_COPY_MATCHED_SUBJECT 0x00004000u #define PCRE2_SUBSTITUTE_LITERAL 0x00008000u / pcre2_substitute() only / #define PCRE2_SUBSTITUTE_MATCHED 0x00010000u / pcre2_substitute() only / #define PCRE2_SUBSTITUTE_REPLACEMENT_ONLY 0x00020000u / pcre2_substitute() only / / Options for pcre2_pattern_convert(). / #define PCRE2_CONVERT_UTF 0x00000001u #define PCRE2_CONVERT_NO_UTF_CHECK 0x00000002u #define PCRE2_CONVERT_POSIX_BASIC 0x00000004u #define PCRE2_CONVERT_POSIX_EXTENDED 0x00000008u #define PCRE2_CONVERT_GLOB 0x00000010u #define PCRE2_CONVERT_GLOB_NO_WILD_SEPARATOR 0x00000030u #define PCRE2_CONVERT_GLOB_NO_STARSTAR 0x00000050u / Newline and \R settings, for use in compile contexts. The newline values must be kept in step with values set in config.h and both sets must all be greater than zero. / #define PCRE2_NEWLINE_CR 1 #define PCRE2_NEWLINE_LF 2 #define PCRE2_NEWLINE_CRLF 3 #define PCRE2_NEWLINE_ANY 4 #define PCRE2_NEWLINE_ANYCRLF 5 #define PCRE2_NEWLINE_NUL 6 #define PCRE2_BSR_UNICODE 1 #define PCRE2_BSR_ANYCRLF 2 / Error codes for pcre2_compile(). Some of these are also used by pcre2_pattern_convert(). / #define PCRE2_ERROR_END_BACKSLASH 101 #define PCRE2_ERROR_END_BACKSLASH_C 102 #define PCRE2_ERROR_UNKNOWN_ESCAPE 103 #define PCRE2_ERROR_QUANTIFIER_OUT_OF_ORDER 104 #define PCRE2_ERROR_QUANTIFIER_TOO_BIG 105 #define PCRE2_ERROR_MISSING_SQUARE_BRACKET 106 #define PCRE2_ERROR_ESCAPE_INVALID_IN_CLASS 107 #define PCRE2_ERROR_CLASS_RANGE_ORDER 108 #define PCRE2_ERROR_QUANTIFIER_INVALID 109 #define PCRE2_ERROR_INTERNAL_UNEXPECTED_REPEAT 110 #define PCRE2_ERROR_INVALID_AFTER_PARENS_QUERY 111 #define PCRE2_ERROR_POSIX_CLASS_NOT_IN_CLASS 112 #define PCRE2_ERROR_POSIX_NO_SUPPORT_COLLATING 113 #define PCRE2_ERROR_MISSING_CLOSING_PARENTHESIS 114 #define PCRE2_ERROR_BAD_SUBPATTERN_REFERENCE 115 #define PCRE2_ERROR_NULL_PATTERN 116 #define PCRE2_ERROR_BAD_OPTIONS 117 #define PCRE2_ERROR_MISSING_COMMENT_CLOSING 118 #define PCRE2_ERROR_PARENTHESES_NEST_TOO_DEEP 119 #define PCRE2_ERROR_PATTERN_TOO_LARGE 120 #define PCRE2_ERROR_HEAP_FAILED 121 #define PCRE2_ERROR_UNMATCHED_CLOSING_PARENTHESIS 122 #define PCRE2_ERROR_INTERNAL_CODE_OVERFLOW 123 #define PCRE2_ERROR_MISSING_CONDITION_CLOSING 124 #define PCRE2_ERROR_LOOKBEHIND_NOT_FIXED_LENGTH 125 #define PCRE2_ERROR_ZERO_RELATIVE_REFERENCE 126 #define PCRE2_ERROR_TOO_MANY_CONDITION_BRANCHES 127 #define PCRE2_ERROR_CONDITION_ASSERTION_EXPECTED 128 #define PCRE2_ERROR_BAD_RELATIVE_REFERENCE 129 #define PCRE2_ERROR_UNKNOWN_POSIX_CLASS 130 #define PCRE2_ERROR_INTERNAL_STUDY_ERROR 131 #define PCRE2_ERROR_UNICODE_NOT_SUPPORTED 132 #define PCRE2_ERROR_PARENTHESES_STACK_CHECK 133 #define PCRE2_ERROR_CODE_POINT_TOO_BIG 134 #define PCRE2_ERROR_LOOKBEHIND_TOO_COMPLICATED 135 #define PCRE2_ERROR_LOOKBEHIND_INVALID_BACKSLASH_C 136 #define PCRE2_ERROR_UNSUPPORTED_ESCAPE_SEQUENCE 137 #define PCRE2_ERROR_CALLOUT_NUMBER_TOO_BIG 138 #define PCRE2_ERROR_MISSING_CALLOUT_CLOSING 139 #define PCRE2_ERROR_ESCAPE_INVALID_IN_VERB 140 #define PCRE2_ERROR_UNRECOGNIZED_AFTER_QUERY_P 141 #define PCRE2_ERROR_MISSING_NAME_TERMINATOR 142 #define PCRE2_ERROR_DUPLICATE_SUBPATTERN_NAME 143 #define PCRE2_ERROR_INVALID_SUBPATTERN_NAME 144 #define PCRE2_ERROR_UNICODE_PROPERTIES_UNAVAILABLE 145 #define PCRE2_ERROR_MALFORMED_UNICODE_PROPERTY 146 #define PCRE2_ERROR_UNKNOWN_UNICODE_PROPERTY 147 #define PCRE2_ERROR_SUBPATTERN_NAME_TOO_LONG 148 #define PCRE2_ERROR_TOO_MANY_NAMED_SUBPATTERNS 149 #define PCRE2_ERROR_CLASS_INVALID_RANGE 150 #define PCRE2_ERROR_OCTAL_BYTE_TOO_BIG 151 #define PCRE2_ERROR_INTERNAL_OVERRAN_WORKSPACE 152 #define PCRE2_ERROR_INTERNAL_MISSING_SUBPATTERN 153 #define PCRE2_ERROR_DEFINE_TOO_MANY_BRANCHES 154 #define PCRE2_ERROR_BACKSLASH_O_MISSING_BRACE 155 #define PCRE2_ERROR_INTERNAL_UNKNOWN_NEWLINE 156 #define PCRE2_ERROR_BACKSLASH_G_SYNTAX 157 #define PCRE2_ERROR_PARENS_QUERY_R_MISSING_CLOSING 158 / Error 159 is obsolete and should now never occur / #define PCRE2_ERROR_VERB_ARGUMENT_NOT_ALLOWED 159 #define PCRE2_ERROR_VERB_UNKNOWN 160 #define PCRE2_ERROR_SUBPATTERN_NUMBER_TOO_BIG 161 #define PCRE2_ERROR_SUBPATTERN_NAME_EXPECTED 162 #define PCRE2_ERROR_INTERNAL_PARSED_OVERFLOW 163 #define PCRE2_ERROR_INVALID_OCTAL 164 #define PCRE2_ERROR_SUBPATTERN_NAMES_MISMATCH 165 #define PCRE2_ERROR_MARK_MISSING_ARGUMENT 166 #define PCRE2_ERROR_INVALID_HEXADECIMAL 167 #define PCRE2_ERROR_BACKSLASH_C_SYNTAX 168 #define PCRE2_ERROR_BACKSLASH_K_SYNTAX 169 #define PCRE2_ERROR_INTERNAL_BAD_CODE_LOOKBEHINDS 170 #define PCRE2_ERROR_BACKSLASH_N_IN_CLASS 171 #define PCRE2_ERROR_CALLOUT_STRING_TOO_LONG 172 #define PCRE2_ERROR_UNICODE_DISALLOWED_CODE_POINT 173 #define PCRE2_ERROR_UTF_IS_DISABLED 174 #define PCRE2_ERROR_UCP_IS_DISABLED 175 #define PCRE2_ERROR_VERB_NAME_TOO_LONG 176 #define PCRE2_ERROR_BACKSLASH_U_CODE_POINT_TOO_BIG 177 #define PCRE2_ERROR_MISSING_OCTAL_OR_HEX_DIGITS 178 #define PCRE2_ERROR_VERSION_CONDITION_SYNTAX 179 #define PCRE2_ERROR_INTERNAL_BAD_CODE_AUTO_POSSESS 180 #define PCRE2_ERROR_CALLOUT_NO_STRING_DELIMITER 181 #define PCRE2_ERROR_CALLOUT_BAD_STRING_DELIMITER 182 #define PCRE2_ERROR_BACKSLASH_C_CALLER_DISABLED 183 #define PCRE2_ERROR_QUERY_BARJX_NEST_TOO_DEEP 184 #define PCRE2_ERROR_BACKSLASH_C_LIBRARY_DISABLED 185 #define PCRE2_ERROR_PATTERN_TOO_COMPLICATED 186 #define PCRE2_ERROR_LOOKBEHIND_TOO_LONG 187 #define PCRE2_ERROR_PATTERN_STRING_TOO_LONG 188 #define PCRE2_ERROR_INTERNAL_BAD_CODE 189 #define PCRE2_ERROR_INTERNAL_BAD_CODE_IN_SKIP 190 #define PCRE2_ERROR_NO_SURROGATES_IN_UTF16 191 #define PCRE2_ERROR_BAD_LITERAL_OPTIONS 192 #define PCRE2_ERROR_SUPPORTED_ONLY_IN_UNICODE 193 #define PCRE2_ERROR_INVALID_HYPHEN_IN_OPTIONS 194 #define PCRE2_ERROR_ALPHA_ASSERTION_UNKNOWN 195 #define PCRE2_ERROR_SCRIPT_RUN_NOT_AVAILABLE 196 #define PCRE2_ERROR_TOO_MANY_CAPTURES 197 #define PCRE2_ERROR_CONDITION_ATOMIC_ASSERTION_EXPECTED 198 #define PCRE2_ERROR_BACKSLASH_K_IN_LOOKAROUND 199 / "Expected" matching error codes: no match and partial match. / #define PCRE2_ERROR_NOMATCH (-1) #define PCRE2_ERROR_PARTIAL (-2) / Error codes for UTF-8 validity checks / #define PCRE2_ERROR_UTF8_ERR1 (-3) #define PCRE2_ERROR_UTF8_ERR2 (-4) #define PCRE2_ERROR_UTF8_ERR3 (-5) #define PCRE2_ERROR_UTF8_ERR4 (-6) #define PCRE2_ERROR_UTF8_ERR5 (-7) #define PCRE2_ERROR_UTF8_ERR6 (-8) #define PCRE2_ERROR_UTF8_ERR7 (-9) #define PCRE2_ERROR_UTF8_ERR8 (-10) #define PCRE2_ERROR_UTF8_ERR9 (-11) #define PCRE2_ERROR_UTF8_ERR10 (-12) #define PCRE2_ERROR_UTF8_ERR11 (-13) #define PCRE2_ERROR_UTF8_ERR12 (-14) #define PCRE2_ERROR_UTF8_ERR13 (-15) #define PCRE2_ERROR_UTF8_ERR14 (-16) #define PCRE2_ERROR_UTF8_ERR15 (-17) #define PCRE2_ERROR_UTF8_ERR16 (-18) #define PCRE2_ERROR_UTF8_ERR17 (-19) #define PCRE2_ERROR_UTF8_ERR18 (-20) #define PCRE2_ERROR_UTF8_ERR19 (-21) #define PCRE2_ERROR_UTF8_ERR20 (-22) #define PCRE2_ERROR_UTF8_ERR21 (-23) / Error codes for UTF-16 validity checks / #define PCRE2_ERROR_UTF16_ERR1 (-24) #define PCRE2_ERROR_UTF16_ERR2 (-25) #define PCRE2_ERROR_UTF16_ERR3 (-26) / Error codes for UTF-32 validity checks / #define PCRE2_ERROR_UTF32_ERR1 (-27) #define PCRE2_ERROR_UTF32_ERR2 (-28) / Miscellaneous error codes for pcre2[_dfa]_match(), substring extraction functions, context functions, and serializing functions. They are in numerical order. Originally they were in alphabetical order too, but now that PCRE2 is released, the numbers must not be changed. / #define PCRE2_ERROR_BADDATA (-29) #define PCRE2_ERROR_MIXEDTABLES (-30) / Name was changed / #define PCRE2_ERROR_BADMAGIC (-31) #define PCRE2_ERROR_BADMODE (-32) #define PCRE2_ERROR_BADOFFSET (-33) #define PCRE2_ERROR_BADOPTION (-34) #define PCRE2_ERROR_BADREPLACEMENT (-35) #define PCRE2_ERROR_BADUTFOFFSET (-36) #define PCRE2_ERROR_CALLOUT (-37) / Never used by PCRE2 itself / #define PCRE2_ERROR_DFA_BADRESTART (-38) #define PCRE2_ERROR_DFA_RECURSE (-39) #define PCRE2_ERROR_DFA_UCOND (-40) #define PCRE2_ERROR_DFA_UFUNC (-41) #define PCRE2_ERROR_DFA_UITEM (-42) #define PCRE2_ERROR_DFA_WSSIZE (-43) #define PCRE2_ERROR_INTERNAL (-44) #define PCRE2_ERROR_JIT_BADOPTION (-45) #define PCRE2_ERROR_JIT_STACKLIMIT (-46) #define PCRE2_ERROR_MATCHLIMIT (-47) #define PCRE2_ERROR_NOMEMORY (-48) #define PCRE2_ERROR_NOSUBSTRING (-49) #define PCRE2_ERROR_NOUNIQUESUBSTRING (-50) #define PCRE2_ERROR_NULL (-51) #define PCRE2_ERROR_RECURSELOOP (-52) #define PCRE2_ERROR_DEPTHLIMIT (-53) #define PCRE2_ERROR_RECURSIONLIMIT (-53) / Obsolete synonym / #define PCRE2_ERROR_UNAVAILABLE (-54) #define PCRE2_ERROR_UNSET (-55) #define PCRE2_ERROR_BADOFFSETLIMIT (-56) #define PCRE2_ERROR_BADREPESCAPE (-57) #define PCRE2_ERROR_REPMISSINGBRACE (-58) #define PCRE2_ERROR_BADSUBSTITUTION (-59) #define PCRE2_ERROR_BADSUBSPATTERN (-60) #define PCRE2_ERROR_TOOMANYREPLACE (-61) #define PCRE2_ERROR_BADSERIALIZEDDATA (-62) #define PCRE2_ERROR_HEAPLIMIT (-63) #define PCRE2_ERROR_CONVERT_SYNTAX (-64) #define PCRE2_ERROR_INTERNAL_DUPMATCH (-65) #define PCRE2_ERROR_DFA_UINVALID_UTF (-66) / Request types for pcre2_pattern_info() / #define PCRE2_INFO_ALLOPTIONS 0 #define PCRE2_INFO_ARGOPTIONS 1 #define PCRE2_INFO_BACKREFMAX 2 #define PCRE2_INFO_BSR 3 #define PCRE2_INFO_CAPTURECOUNT 4 #define PCRE2_INFO_FIRSTCODEUNIT 5 #define PCRE2_INFO_FIRSTCODETYPE 6 #define PCRE2_INFO_FIRSTBITMAP 7 #define PCRE2_INFO_HASCRORLF 8 #define PCRE2_INFO_JCHANGED 9 #define PCRE2_INFO_JITSIZE 10 #define PCRE2_INFO_LASTCODEUNIT 11 #define PCRE2_INFO_LASTCODETYPE 12 #define PCRE2_INFO_MATCHEMPTY 13 #define PCRE2_INFO_MATCHLIMIT 14 #define PCRE2_INFO_MAXLOOKBEHIND 15 #define PCRE2_INFO_MINLENGTH 16 #define PCRE2_INFO_NAMECOUNT 17 #define PCRE2_INFO_NAMEENTRYSIZE 18 #define PCRE2_INFO_NAMETABLE 19 #define PCRE2_INFO_NEWLINE 20 #define PCRE2_INFO_DEPTHLIMIT 21 #define PCRE2_INFO_RECURSIONLIMIT 21 / Obsolete synonym / #define PCRE2_INFO_SIZE 22 #define PCRE2_INFO_HASBACKSLASHC 23 #define PCRE2_INFO_FRAMESIZE 24 #define PCRE2_INFO_HEAPLIMIT 25 #define PCRE2_INFO_EXTRAOPTIONS 26 / Request types for pcre2_config(). / #define PCRE2_CONFIG_BSR 0 #define PCRE2_CONFIG_JIT 1 #define PCRE2_CONFIG_JITTARGET 2 #define PCRE2_CONFIG_LINKSIZE 3 #define PCRE2_CONFIG_MATCHLIMIT 4 #define PCRE2_CONFIG_NEWLINE 5 #define PCRE2_CONFIG_PARENSLIMIT 6 #define PCRE2_CONFIG_DEPTHLIMIT 7 #define PCRE2_CONFIG_RECURSIONLIMIT 7 / Obsolete synonym / #define PCRE2_CONFIG_STACKRECURSE 8 / Obsolete / #define PCRE2_CONFIG_UNICODE 9 #define PCRE2_CONFIG_UNICODE_VERSION 10 #define PCRE2_CONFIG_VERSION 11 #define PCRE2_CONFIG_HEAPLIMIT 12 #define PCRE2_CONFIG_NEVER_BACKSLASH_C 13 #define PCRE2_CONFIG_COMPILED_WIDTHS 14 #define PCRE2_CONFIG_TABLES_LENGTH 15 / Types for code units in patterns and subject strings. / typedef uint8_t PCRE2_UCHAR8; typedef uint16_t PCRE2_UCHAR16; typedef uint32_t PCRE2_UCHAR32; typedef const PCRE2_UCHAR8 PCRE2_SPTR8; typedef const PCRE2_UCHAR16 PCRE2_SPTR16; typedef const PCRE2_UCHAR32 PCRE2_SPTR32; /* The PCRE2_SIZE type is used for all string lengths and offsets in PCRE2, including pattern offsets for errors and subject offsets after a match. We define special values to indicate zero-terminated strings and unset offsets in the offset vector (ovector). / #define PCRE2_SIZE size_t #define PCRE2_SIZE_MAX SIZE_MAX #define PCRE2_ZERO_TERMINATED (~(PCRE2_SIZE)0) #define PCRE2_UNSET (~(PCRE2_SIZE)0) / Generic types for opaque structures and JIT callback functions. These declarations are defined in a macro that is expanded for each width later. / #define PCRE2_TYPES_LIST \ struct pcre2_real_general_context; \ typedef struct pcre2_real_general_context pcre2_general_context; \ \ struct pcre2_real_compile_context; \ typedef struct pcre2_real_compile_context pcre2_compile_context; \ \ struct pcre2_real_match_context; \ typedef struct pcre2_real_match_context pcre2_match_context; \ \ struct pcre2_real_convert_context; \ typedef struct pcre2_real_convert_context pcre2_convert_context; \ \ struct pcre2_real_code; \ typedef struct pcre2_real_code pcre2_code; \ \ struct pcre2_real_match_data; \ typedef struct pcre2_real_match_data pcre2_match_data; \ \ struct pcre2_real_jit_stack; \ typedef struct pcre2_real_jit_stack pcre2_jit_stack; \ \ typedef pcre2_jit_stack (pcre2_jit_callback)(void ); /* The structures for passing out data via callout functions. We use structures so that new fields can be added on the end in future versions, without changing the API of the function, thereby allowing old clients to work without modification. Define the generic versions in a macro; the width-specific versions are generated from this macro below. / / Flags for the callout_flags field. These are cleared after a callout. / #define PCRE2_CALLOUT_STARTMATCH 0x00000001u / Set for each bumpalong / #define PCRE2_CALLOUT_BACKTRACK 0x00000002u / Set after a backtrack / #define PCRE2_STRUCTURE_LIST \ typedef struct pcre2_callout_block { \ uint32_t version; / Identifies version of block / \ / ------------------------ Version 0 ------------------------------- / \ uint32_t callout_number; / Number compiled into pattern / \ uint32_t capture_top; / Max current capture / \ uint32_t capture_last; / Most recently closed capture / \ PCRE2_SIZE offset_vector; /* The offset vector / \ PCRE2_SPTR mark; / Pointer to current mark or NULL / \ PCRE2_SPTR subject; / The subject being matched / \ PCRE2_SIZE subject_length; / The length of the subject / \ PCRE2_SIZE start_match; / Offset to start of this match attempt / \ PCRE2_SIZE current_position; / Where we currently are in the subject / \ PCRE2_SIZE pattern_position; / Offset to next item in the pattern / \ PCRE2_SIZE next_item_length; / Length of next item in the pattern / \ / ------------------- Added for Version 1 -------------------------- / \ PCRE2_SIZE callout_string_offset; / Offset to string within pattern / \ PCRE2_SIZE callout_string_length; / Length of string compiled into pattern / \ PCRE2_SPTR callout_string; / String compiled into pattern / \ / ------------------- Added for Version 2 -------------------------- / \ uint32_t callout_flags; / See above for list / \ / ------------------------------------------------------------------ / \ } pcre2_callout_block; \ \ typedef struct pcre2_callout_enumerate_block { \ uint32_t version; / Identifies version of block / \ / ------------------------ Version 0 ------------------------------- / \ PCRE2_SIZE pattern_position; / Offset to next item in the pattern / \ PCRE2_SIZE next_item_length; / Length of next item in the pattern / \ uint32_t callout_number; / Number compiled into pattern / \ PCRE2_SIZE callout_string_offset; / Offset to string within pattern / \ PCRE2_SIZE callout_string_length; / Length of string compiled into pattern / \ PCRE2_SPTR callout_string; / String compiled into pattern / \ / ------------------------------------------------------------------ / \ } pcre2_callout_enumerate_block; \ \ typedef struct pcre2_substitute_callout_block { \ uint32_t version; / Identifies version of block / \ / ------------------------ Version 0 ------------------------------- / \ PCRE2_SPTR input; / Pointer to input subject string / \ PCRE2_SPTR output; / Pointer to output buffer / \ PCRE2_SIZE output_offsets[2]; / Changed portion of the output / \ PCRE2_SIZE ovector; /* Pointer to current ovector / \ uint32_t oveccount; / Count of pairs set in ovector / \ uint32_t subscount; / Substitution number / \ / ------------------------------------------------------------------ / \ } pcre2_substitute_callout_block; / List the generic forms of all other functions in macros, which will be expanded for each width below. Start with functions that give general information. / #define PCRE2_GENERAL_INFO_FUNCTIONS \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION pcre2_config(uint32_t, void ); /* Functions for manipulating contexts. / #define PCRE2_GENERAL_CONTEXT_FUNCTIONS \ PCRE2_EXP_DECL pcre2_general_context PCRE2_CALL_CONVENTION \ pcre2_general_context_copy(pcre2_general_context ); \ PCRE2_EXP_DECL pcre2_general_context PCRE2_CALL_CONVENTION \ pcre2_general_context_create(void ()(PCRE2_SIZE, void ), \ void ()(void , void ), void ); \ PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \ pcre2_general_context_free(pcre2_general_context ); #define PCRE2_COMPILE_CONTEXT_FUNCTIONS \ PCRE2_EXP_DECL pcre2_compile_context PCRE2_CALL_CONVENTION \ pcre2_compile_context_copy(pcre2_compile_context ); \ PCRE2_EXP_DECL pcre2_compile_context PCRE2_CALL_CONVENTION \ pcre2_compile_context_create(pcre2_general_context );\ PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \ pcre2_compile_context_free(pcre2_compile_context ); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_set_bsr(pcre2_compile_context , uint32_t); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_set_character_tables(pcre2_compile_context , const uint8_t ); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_set_compile_extra_options(pcre2_compile_context , uint32_t); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_set_max_pattern_length(pcre2_compile_context , PCRE2_SIZE); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_set_newline(pcre2_compile_context , uint32_t); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_set_parens_nest_limit(pcre2_compile_context , uint32_t); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_set_compile_recursion_guard(pcre2_compile_context , \ int ()(uint32_t, void ), void ); #define PCRE2_MATCH_CONTEXT_FUNCTIONS \ PCRE2_EXP_DECL pcre2_match_context PCRE2_CALL_CONVENTION \ pcre2_match_context_copy(pcre2_match_context ); \ PCRE2_EXP_DECL pcre2_match_context PCRE2_CALL_CONVENTION \ pcre2_match_context_create(pcre2_general_context ); \ PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \ pcre2_match_context_free(pcre2_match_context ); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_set_callout(pcre2_match_context , \ int ()(pcre2_callout_block , void ), void ); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_set_substitute_callout(pcre2_match_context , \ int ()(pcre2_substitute_callout_block , void ), void ); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_set_depth_limit(pcre2_match_context , uint32_t); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_set_heap_limit(pcre2_match_context , uint32_t); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_set_match_limit(pcre2_match_context , uint32_t); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_set_offset_limit(pcre2_match_context , PCRE2_SIZE); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_set_recursion_limit(pcre2_match_context , uint32_t); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_set_recursion_memory_management(pcre2_match_context , \ void ()(PCRE2_SIZE, void ), void ()(void , void ), void ); #define PCRE2_CONVERT_CONTEXT_FUNCTIONS \ PCRE2_EXP_DECL pcre2_convert_context PCRE2_CALL_CONVENTION \ pcre2_convert_context_copy(pcre2_convert_context ); \ PCRE2_EXP_DECL pcre2_convert_context PCRE2_CALL_CONVENTION \ pcre2_convert_context_create(pcre2_general_context ); \ PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \ pcre2_convert_context_free(pcre2_convert_context ); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_set_glob_escape(pcre2_convert_context , uint32_t); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_set_glob_separator(pcre2_convert_context , uint32_t); / Functions concerned with compiling a pattern to PCRE internal code. / #define PCRE2_COMPILE_FUNCTIONS \ PCRE2_EXP_DECL pcre2_code PCRE2_CALL_CONVENTION \ pcre2_compile(PCRE2_SPTR, PCRE2_SIZE, uint32_t, int , PCRE2_SIZE , \ pcre2_compile_context ); \ PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \ pcre2_code_free(pcre2_code ); \ PCRE2_EXP_DECL pcre2_code PCRE2_CALL_CONVENTION \ pcre2_code_copy(const pcre2_code ); \ PCRE2_EXP_DECL pcre2_code PCRE2_CALL_CONVENTION \ pcre2_code_copy_with_tables(const pcre2_code ); /* Functions that give information about a compiled pattern. / #define PCRE2_PATTERN_INFO_FUNCTIONS \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_pattern_info(const pcre2_code , uint32_t, void ); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_callout_enumerate(const pcre2_code , \ int ()(pcre2_callout_enumerate_block , void ), void ); /* Functions for running a match and inspecting the result. / #define PCRE2_MATCH_FUNCTIONS \ PCRE2_EXP_DECL pcre2_match_data PCRE2_CALL_CONVENTION \ pcre2_match_data_create(uint32_t, pcre2_general_context ); \ PCRE2_EXP_DECL pcre2_match_data PCRE2_CALL_CONVENTION \ pcre2_match_data_create_from_pattern(const pcre2_code , \ pcre2_general_context ); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_dfa_match(const pcre2_code , PCRE2_SPTR, PCRE2_SIZE, PCRE2_SIZE, \ uint32_t, pcre2_match_data , pcre2_match_context , int , PCRE2_SIZE); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_match(const pcre2_code , PCRE2_SPTR, PCRE2_SIZE, PCRE2_SIZE, \ uint32_t, pcre2_match_data , pcre2_match_context ); \ PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \ pcre2_match_data_free(pcre2_match_data ); \ PCRE2_EXP_DECL PCRE2_SPTR PCRE2_CALL_CONVENTION \ pcre2_get_mark(pcre2_match_data ); \ PCRE2_EXP_DECL PCRE2_SIZE PCRE2_CALL_CONVENTION \ pcre2_get_match_data_size(pcre2_match_data ); \ PCRE2_EXP_DECL uint32_t PCRE2_CALL_CONVENTION \ pcre2_get_ovector_count(pcre2_match_data ); \ PCRE2_EXP_DECL PCRE2_SIZE PCRE2_CALL_CONVENTION \ pcre2_get_ovector_pointer(pcre2_match_data ); \ PCRE2_EXP_DECL PCRE2_SIZE PCRE2_CALL_CONVENTION \ pcre2_get_startchar(pcre2_match_data ); /* Convenience functions for handling matched substrings. / #define PCRE2_SUBSTRING_FUNCTIONS \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_substring_copy_byname(pcre2_match_data , PCRE2_SPTR, PCRE2_UCHAR , \ PCRE2_SIZE ); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_substring_copy_bynumber(pcre2_match_data , uint32_t, PCRE2_UCHAR , \ PCRE2_SIZE ); \ PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \ pcre2_substring_free(PCRE2_UCHAR ); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_substring_get_byname(pcre2_match_data , PCRE2_SPTR, PCRE2_UCHAR , \ PCRE2_SIZE ); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_substring_get_bynumber(pcre2_match_data , uint32_t, PCRE2_UCHAR , \ PCRE2_SIZE ); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_substring_length_byname(pcre2_match_data , PCRE2_SPTR, PCRE2_SIZE ); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_substring_length_bynumber(pcre2_match_data , uint32_t, PCRE2_SIZE ); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_substring_nametable_scan(const pcre2_code , PCRE2_SPTR, PCRE2_SPTR , \ PCRE2_SPTR ); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_substring_number_from_name(const pcre2_code , PCRE2_SPTR); \ PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \ pcre2_substring_list_free(PCRE2_SPTR ); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_substring_list_get(pcre2_match_data , PCRE2_UCHAR *, PCRE2_SIZE ); /* Functions for serializing / deserializing compiled patterns. / #define PCRE2_SERIALIZE_FUNCTIONS \ PCRE2_EXP_DECL int32_t PCRE2_CALL_CONVENTION \ pcre2_serialize_encode(const pcre2_code , int32_t, uint8_t , \ PCRE2_SIZE , pcre2_general_context ); \ PCRE2_EXP_DECL int32_t PCRE2_CALL_CONVENTION \ pcre2_serialize_decode(pcre2_code , int32_t, const uint8_t , \ pcre2_general_context ); \ PCRE2_EXP_DECL int32_t PCRE2_CALL_CONVENTION \ pcre2_serialize_get_number_of_codes(const uint8_t ); \ PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \ pcre2_serialize_free(uint8_t ); / Convenience function for match + substitute. / #define PCRE2_SUBSTITUTE_FUNCTION \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_substitute(const pcre2_code , PCRE2_SPTR, PCRE2_SIZE, PCRE2_SIZE, \ uint32_t, pcre2_match_data , pcre2_match_context , PCRE2_SPTR, \ PCRE2_SIZE, PCRE2_UCHAR , PCRE2_SIZE ); /* Functions for converting pattern source strings. / #define PCRE2_CONVERT_FUNCTIONS \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_pattern_convert(PCRE2_SPTR, PCRE2_SIZE, uint32_t, PCRE2_UCHAR , \ PCRE2_SIZE , pcre2_convert_context ); \ PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \ pcre2_converted_pattern_free(PCRE2_UCHAR ); /* Functions for JIT processing / #define PCRE2_JIT_FUNCTIONS \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_jit_compile(pcre2_code , uint32_t); \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_jit_match(const pcre2_code , PCRE2_SPTR, PCRE2_SIZE, PCRE2_SIZE, \ uint32_t, pcre2_match_data , pcre2_match_context ); \ PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \ pcre2_jit_free_unused_memory(pcre2_general_context ); \ PCRE2_EXP_DECL pcre2_jit_stack PCRE2_CALL_CONVENTION \ pcre2_jit_stack_create(PCRE2_SIZE, PCRE2_SIZE, pcre2_general_context ); \ PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \ pcre2_jit_stack_assign(pcre2_match_context , pcre2_jit_callback, void ); \ PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \ pcre2_jit_stack_free(pcre2_jit_stack ); / Other miscellaneous functions. / #define PCRE2_OTHER_FUNCTIONS \ PCRE2_EXP_DECL int PCRE2_CALL_CONVENTION \ pcre2_get_error_message(int, PCRE2_UCHAR , PCRE2_SIZE); \ PCRE2_EXP_DECL const uint8_t PCRE2_CALL_CONVENTION \ pcre2_maketables(pcre2_general_context ); \ PCRE2_EXP_DECL void PCRE2_CALL_CONVENTION \ pcre2_maketables_free(pcre2_general_context , const uint8_t ); /* Define macros that generate width-specific names from generic versions. The three-level macro scheme is necessary to get the macros expanded when we want them to be. First we get the width from PCRE2_LOCAL_WIDTH, which is used for generating three versions of everything below. After that, PCRE2_SUFFIX will be re-defined to use PCRE2_CODE_UNIT_WIDTH, for use when macros such as pcre2_compile are called by application code. / #define PCRE2_JOIN(a,b) a ## b #define PCRE2_GLUE(a,b) PCRE2_JOIN(a,b) #define PCRE2_SUFFIX(a) PCRE2_GLUE(a,PCRE2_LOCAL_WIDTH) / Data types / #define PCRE2_UCHAR PCRE2_SUFFIX(PCRE2_UCHAR) #define PCRE2_SPTR PCRE2_SUFFIX(PCRE2_SPTR) #define pcre2_code PCRE2_SUFFIX(pcre2_code_) #define pcre2_jit_callback PCRE2_SUFFIX(pcre2_jit_callback_) #define pcre2_jit_stack PCRE2_SUFFIX(pcre2_jit_stack_) #define pcre2_real_code PCRE2_SUFFIX(pcre2_real_code_) #define pcre2_real_general_context PCRE2_SUFFIX(pcre2_real_general_context_) #define pcre2_real_compile_context PCRE2_SUFFIX(pcre2_real_compile_context_) #define pcre2_real_convert_context PCRE2_SUFFIX(pcre2_real_convert_context_) #define pcre2_real_match_context PCRE2_SUFFIX(pcre2_real_match_context_) #define pcre2_real_jit_stack PCRE2_SUFFIX(pcre2_real_jit_stack_) #define pcre2_real_match_data PCRE2_SUFFIX(pcre2_real_match_data_) / Data blocks / #define pcre2_callout_block PCRE2_SUFFIX(pcre2_callout_block_) #define pcre2_callout_enumerate_block PCRE2_SUFFIX(pcre2_callout_enumerate_block_) #define pcre2_substitute_callout_block PCRE2_SUFFIX(pcre2_substitute_callout_block_) #define pcre2_general_context PCRE2_SUFFIX(pcre2_general_context_) #define pcre2_compile_context PCRE2_SUFFIX(pcre2_compile_context_) #define pcre2_convert_context PCRE2_SUFFIX(pcre2_convert_context_) #define pcre2_match_context PCRE2_SUFFIX(pcre2_match_context_) #define pcre2_match_data PCRE2_SUFFIX(pcre2_match_data_) / Functions: the complete list in alphabetical order / #define pcre2_callout_enumerate PCRE2_SUFFIX(pcre2_callout_enumerate_) #define pcre2_code_copy PCRE2_SUFFIX(pcre2_code_copy_) #define pcre2_code_copy_with_tables PCRE2_SUFFIX(pcre2_code_copy_with_tables_) #define pcre2_code_free PCRE2_SUFFIX(pcre2_code_free_) #define pcre2_compile PCRE2_SUFFIX(pcre2_compile_) #define pcre2_compile_context_copy PCRE2_SUFFIX(pcre2_compile_context_copy_) #define pcre2_compile_context_create PCRE2_SUFFIX(pcre2_compile_context_create_) #define pcre2_compile_context_free PCRE2_SUFFIX(pcre2_compile_context_free_) #define pcre2_config PCRE2_SUFFIX(pcre2_config_) #define pcre2_convert_context_copy PCRE2_SUFFIX(pcre2_convert_context_copy_) #define pcre2_convert_context_create PCRE2_SUFFIX(pcre2_convert_context_create_) #define pcre2_convert_context_free PCRE2_SUFFIX(pcre2_convert_context_free_) #define pcre2_converted_pattern_free PCRE2_SUFFIX(pcre2_converted_pattern_free_) #define pcre2_dfa_match PCRE2_SUFFIX(pcre2_dfa_match_) #define pcre2_general_context_copy PCRE2_SUFFIX(pcre2_general_context_copy_) #define pcre2_general_context_create PCRE2_SUFFIX(pcre2_general_context_create_) #define pcre2_general_context_free PCRE2_SUFFIX(pcre2_general_context_free_) #define pcre2_get_error_message PCRE2_SUFFIX(pcre2_get_error_message_) #define pcre2_get_mark PCRE2_SUFFIX(pcre2_get_mark_) #define pcre2_get_match_data_size PCRE2_SUFFIX(pcre2_get_match_data_size_) #define pcre2_get_ovector_pointer PCRE2_SUFFIX(pcre2_get_ovector_pointer_) #define pcre2_get_ovector_count PCRE2_SUFFIX(pcre2_get_ovector_count_) #define pcre2_get_startchar PCRE2_SUFFIX(pcre2_get_startchar_) #define pcre2_jit_compile PCRE2_SUFFIX(pcre2_jit_compile_) #define pcre2_jit_match PCRE2_SUFFIX(pcre2_jit_match_) #define pcre2_jit_free_unused_memory PCRE2_SUFFIX(pcre2_jit_free_unused_memory_) #define pcre2_jit_stack_assign PCRE2_SUFFIX(pcre2_jit_stack_assign_) #define pcre2_jit_stack_create PCRE2_SUFFIX(pcre2_jit_stack_create_) #define pcre2_jit_stack_free PCRE2_SUFFIX(pcre2_jit_stack_free_) #define pcre2_maketables PCRE2_SUFFIX(pcre2_maketables_) #define pcre2_maketables_free PCRE2_SUFFIX(pcre2_maketables_free_) #define pcre2_match PCRE2_SUFFIX(pcre2_match_) #define pcre2_match_context_copy PCRE2_SUFFIX(pcre2_match_context_copy_) #define pcre2_match_context_create PCRE2_SUFFIX(pcre2_match_context_create_) #define pcre2_match_context_free PCRE2_SUFFIX(pcre2_match_context_free_) #define pcre2_match_data_create PCRE2_SUFFIX(pcre2_match_data_create_) #define pcre2_match_data_create_from_pattern PCRE2_SUFFIX(pcre2_match_data_create_from_pattern_) #define pcre2_match_data_free PCRE2_SUFFIX(pcre2_match_data_free_) #define pcre2_pattern_convert PCRE2_SUFFIX(pcre2_pattern_convert_) #define pcre2_pattern_info PCRE2_SUFFIX(pcre2_pattern_info_) #define pcre2_serialize_decode PCRE2_SUFFIX(pcre2_serialize_decode_) #define pcre2_serialize_encode PCRE2_SUFFIX(pcre2_serialize_encode_) #define pcre2_serialize_free PCRE2_SUFFIX(pcre2_serialize_free_) #define pcre2_serialize_get_number_of_codes PCRE2_SUFFIX(pcre2_serialize_get_number_of_codes_) #define pcre2_set_bsr PCRE2_SUFFIX(pcre2_set_bsr_) #define pcre2_set_callout PCRE2_SUFFIX(pcre2_set_callout_) #define pcre2_set_character_tables PCRE2_SUFFIX(pcre2_set_character_tables_) #define pcre2_set_compile_extra_options PCRE2_SUFFIX(pcre2_set_compile_extra_options_) #define pcre2_set_compile_recursion_guard PCRE2_SUFFIX(pcre2_set_compile_recursion_guard_) #define pcre2_set_depth_limit PCRE2_SUFFIX(pcre2_set_depth_limit_) #define pcre2_set_glob_escape PCRE2_SUFFIX(pcre2_set_glob_escape_) #define pcre2_set_glob_separator PCRE2_SUFFIX(pcre2_set_glob_separator_) #define pcre2_set_heap_limit PCRE2_SUFFIX(pcre2_set_heap_limit_) #define pcre2_set_match_limit PCRE2_SUFFIX(pcre2_set_match_limit_) #define pcre2_set_max_pattern_length PCRE2_SUFFIX(pcre2_set_max_pattern_length_) #define pcre2_set_newline PCRE2_SUFFIX(pcre2_set_newline_) #define pcre2_set_parens_nest_limit PCRE2_SUFFIX(pcre2_set_parens_nest_limit_) #define pcre2_set_offset_limit PCRE2_SUFFIX(pcre2_set_offset_limit_) #define pcre2_set_substitute_callout PCRE2_SUFFIX(pcre2_set_substitute_callout_) #define pcre2_substitute PCRE2_SUFFIX(pcre2_substitute_) #define pcre2_substring_copy_byname PCRE2_SUFFIX(pcre2_substring_copy_byname_) #define pcre2_substring_copy_bynumber PCRE2_SUFFIX(pcre2_substring_copy_bynumber_) #define pcre2_substring_free PCRE2_SUFFIX(pcre2_substring_free_) #define pcre2_substring_get_byname PCRE2_SUFFIX(pcre2_substring_get_byname_) #define pcre2_substring_get_bynumber PCRE2_SUFFIX(pcre2_substring_get_bynumber_) #define pcre2_substring_length_byname PCRE2_SUFFIX(pcre2_substring_length_byname_) #define pcre2_substring_length_bynumber PCRE2_SUFFIX(pcre2_substring_length_bynumber_) #define pcre2_substring_list_get PCRE2_SUFFIX(pcre2_substring_list_get_) #define pcre2_substring_list_free PCRE2_SUFFIX(pcre2_substring_list_free_) #define pcre2_substring_nametable_scan PCRE2_SUFFIX(pcre2_substring_nametable_scan_) #define pcre2_substring_number_from_name PCRE2_SUFFIX(pcre2_substring_number_from_name_) / Keep this old function name for backwards compatibility / #define pcre2_set_recursion_limit PCRE2_SUFFIX(pcre2_set_recursion_limit_) / Keep this obsolete function for backwards compatibility: it is now a noop. / #define pcre2_set_recursion_memory_management PCRE2_SUFFIX(pcre2_set_recursion_memory_management_) / Now generate all three sets of width-specific structures and function prototypes. / #define PCRE2_TYPES_STRUCTURES_AND_FUNCTIONS \ PCRE2_TYPES_LIST \ PCRE2_STRUCTURE_LIST \ PCRE2_GENERAL_INFO_FUNCTIONS \ PCRE2_GENERAL_CONTEXT_FUNCTIONS \ PCRE2_COMPILE_CONTEXT_FUNCTIONS \ PCRE2_CONVERT_CONTEXT_FUNCTIONS \ PCRE2_CONVERT_FUNCTIONS \ PCRE2_MATCH_CONTEXT_FUNCTIONS \ PCRE2_COMPILE_FUNCTIONS \ PCRE2_PATTERN_INFO_FUNCTIONS \ PCRE2_MATCH_FUNCTIONS \ PCRE2_SUBSTRING_FUNCTIONS \ PCRE2_SERIALIZE_FUNCTIONS \ PCRE2_SUBSTITUTE_FUNCTION \ PCRE2_JIT_FUNCTIONS \ PCRE2_OTHER_FUNCTIONS #define PCRE2_LOCAL_WIDTH 8 PCRE2_TYPES_STRUCTURES_AND_FUNCTIONS #undef PCRE2_LOCAL_WIDTH #define PCRE2_LOCAL_WIDTH 16 PCRE2_TYPES_STRUCTURES_AND_FUNCTIONS #undef PCRE2_LOCAL_WIDTH #define PCRE2_LOCAL_WIDTH 32 PCRE2_TYPES_STRUCTURES_AND_FUNCTIONS #undef PCRE2_LOCAL_WIDTH / Undefine the list macros; they are no longer needed. / #undef PCRE2_TYPES_LIST #undef PCRE2_STRUCTURE_LIST #undef PCRE2_GENERAL_INFO_FUNCTIONS #undef PCRE2_GENERAL_CONTEXT_FUNCTIONS #undef PCRE2_COMPILE_CONTEXT_FUNCTIONS #undef PCRE2_CONVERT_CONTEXT_FUNCTIONS #undef PCRE2_MATCH_CONTEXT_FUNCTIONS #undef PCRE2_COMPILE_FUNCTIONS #undef PCRE2_PATTERN_INFO_FUNCTIONS #undef PCRE2_MATCH_FUNCTIONS #undef PCRE2_SUBSTRING_FUNCTIONS #undef PCRE2_SERIALIZE_FUNCTIONS #undef PCRE2_SUBSTITUTE_FUNCTION #undef PCRE2_JIT_FUNCTIONS #undef PCRE2_OTHER_FUNCTIONS #undef PCRE2_TYPES_STRUCTURES_AND_FUNCTIONS / PCRE2_CODE_UNIT_WIDTH must be defined. If it is 8, 16, or 32, redefine PCRE2_SUFFIX to use it. If it is 0, undefine the other macros and make PCRE2_SUFFIX a no-op. Otherwise, generate an error. / #undef PCRE2_SUFFIX #ifndef PCRE2_CODE_UNIT_WIDTH #error PCRE2_CODE_UNIT_WIDTH must be defined before including pcre2.h. #error Use 8, 16, or 32; or 0 for a multi-width application. #else / PCRE2_CODE_UNIT_WIDTH is defined / #if PCRE2_CODE_UNIT_WIDTH == 8 \|\| \ PCRE2_CODE_UNIT_WIDTH == 16 \|\| \ PCRE2_CODE_UNIT_WIDTH == 32 #define PCRE2_SUFFIX(a) PCRE2_GLUE(a, PCRE2_CODE_UNIT_WIDTH) #elif PCRE2_CODE_UNIT_WIDTH == 0 #undef PCRE2_JOIN #undef PCRE2_GLUE #define PCRE2_SUFFIX(a) a #else #error PCRE2_CODE_UNIT_WIDTH must be 0, 8, 16, or 32. #endif #endif / PCRE2_CODE_UNIT_WIDTH is defined / #ifdef __cplusplus } / extern "C" / #endif #endif / PCRE2_H_IDEMPOTENT_GUARD / / End of pcre2.h */	46.15 KB	2024-10-02 21:57
📄 pcre2posix.h /************************************************* * Perl-Compatible Regular Expressions * ************************************************/ / PCRE2 is a library of functions to support regular expressions whose syntax and semantics are as close as possible to those of the Perl 5 language. This is the public header file to be #included by applications that call PCRE2 via the POSIX wrapper interface. Written by Philip Hazel Original API code Copyright (c) 1997-2012 University of Cambridge New API code Copyright (c) 2016-2019 University of Cambridge ----------------------------------------------------------------------------- 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. * Neither the name of the University of Cambridge 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 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. ----------------------------------------------------------------------------- / / Have to include stdlib.h in order to ensure that size_t is defined. / #include <stdlib.h> / Allow for C++ users / #ifdef __cplusplus extern "C" { #endif / Options, mostly defined by POSIX, but with some extras. / #define REG_ICASE 0x0001 / Maps to PCRE2_CASELESS / #define REG_NEWLINE 0x0002 / Maps to PCRE2_MULTILINE / #define REG_NOTBOL 0x0004 / Maps to PCRE2_NOTBOL / #define REG_NOTEOL 0x0008 / Maps to PCRE2_NOTEOL / #define REG_DOTALL 0x0010 / NOT defined by POSIX; maps to PCRE2_DOTALL / #define REG_NOSUB 0x0020 / Do not report what was matched / #define REG_UTF 0x0040 / NOT defined by POSIX; maps to PCRE2_UTF / #define REG_STARTEND 0x0080 / BSD feature: pass subject string by so,eo / #define REG_NOTEMPTY 0x0100 / NOT defined by POSIX; maps to PCRE2_NOTEMPTY / #define REG_UNGREEDY 0x0200 / NOT defined by POSIX; maps to PCRE2_UNGREEDY / #define REG_UCP 0x0400 / NOT defined by POSIX; maps to PCRE2_UCP / #define REG_PEND 0x0800 / GNU feature: pass end pattern by re_endp / #define REG_NOSPEC 0x1000 / Maps to PCRE2_LITERAL / / This is not used by PCRE2, but by defining it we make it easier to slot PCRE2 into existing programs that make POSIX calls. / #define REG_EXTENDED 0 / Error values. Not all these are relevant or used by the wrapper. / enum { REG_ASSERT = 1, / internal error ? / REG_BADBR, / invalid repeat counts in {} / REG_BADPAT, / pattern error / REG_BADRPT, / ? * + invalid / REG_EBRACE, / unbalanced {} / REG_EBRACK, / unbalanced [] / REG_ECOLLATE, / collation error - not relevant / REG_ECTYPE, / bad class / REG_EESCAPE, / bad escape sequence / REG_EMPTY, / empty expression / REG_EPAREN, / unbalanced () / REG_ERANGE, / bad range inside [] / REG_ESIZE, / expression too big / REG_ESPACE, / failed to get memory / REG_ESUBREG, / bad back reference / REG_INVARG, / bad argument / REG_NOMATCH / match failed / }; / The structure representing a compiled regular expression. It is also used for passing the pattern end pointer when REG_PEND is set. / typedef struct { void re_pcre2_code; void re_match_data; const char re_endp; size_t re_nsub; size_t re_erroffset; int re_cflags; } regex_t; /* The structure in which a captured offset is returned. / typedef int regoff_t; typedef struct { regoff_t rm_so; regoff_t rm_eo; } regmatch_t; / When an application links to a PCRE2 DLL in Windows, the symbols that are imported have to be identified as such. When building PCRE2, the appropriate export settings are needed, and are set in pcre2posix.c before including this file. / #if defined(_WIN32) && !defined(PCRE2_STATIC) && !defined(PCRE2POSIX_EXP_DECL) # define PCRE2POSIX_EXP_DECL extern __declspec(dllimport) # define PCRE2POSIX_EXP_DEFN __declspec(dllimport) #endif / By default, we use the standard "extern" declarations. / #ifndef PCRE2POSIX_EXP_DECL # ifdef __cplusplus # define PCRE2POSIX_EXP_DECL extern "C" # define PCRE2POSIX_EXP_DEFN extern "C" # else # define PCRE2POSIX_EXP_DECL extern # define PCRE2POSIX_EXP_DEFN extern # endif #endif / The functions. The actual code is in functions with pcre2_xxx names for uniqueness. POSIX names are provided as macros for API compatibility with POSIX regex functions. It's done this way to ensure to they are always linked from the PCRE2 library and not by accident from elsewhere (regex_t differs in size elsewhere). / PCRE2POSIX_EXP_DECL int pcre2_regcomp(regex_t , const char , int); PCRE2POSIX_EXP_DECL int pcre2_regexec(const regex_t , const char , size_t, regmatch_t , int); PCRE2POSIX_EXP_DECL size_t pcre2_regerror(int, const regex_t , char , size_t); PCRE2POSIX_EXP_DECL void pcre2_regfree(regex_t ); #define regcomp pcre2_regcomp #define regexec pcre2_regexec #define regerror pcre2_regerror #define regfree pcre2_regfree / Debian had a patch that used different names. These are now here to save them having to maintain their own patch, but are not documented by PCRE2. / #define PCRE2regcomp pcre2_regcomp #define PCRE2regexec pcre2_regexec #define PCRE2regerror pcre2_regerror #define PCRE2regfree pcre2_regfree #ifdef __cplusplus } / extern "C" / #endif / End of pcre2posix.h */	6.52 KB	2021-08-20 16:51
📄 poll.h #include <sys/poll.h>	22 B	2026-02-17 11:01
📄 powercap.h /* SPDX-License-Identifier: GPL-2.0-only / / * (C) 2016 SUSE Software Solutions GmbH * Thomas Renninger <trenn@suse.de> / #ifndef __CPUPOWER_RAPL_H__ #define __CPUPOWER_RAPL_H__ #define PATH_TO_POWERCAP "/sys/devices/virtual/powercap" #define PATH_TO_RAPL "/sys/devices/virtual/powercap/intel-rapl" #define PATH_TO_RAPL_CLASS "/sys/devices/virtual/powercap/intel-rapl" #define POWERCAP_MAX_CHILD_ZONES 10 #define POWERCAP_MAX_TREE_DEPTH 10 #define MAX_LINE_LEN 4096 #define SYSFS_PATH_MAX 255 #include <stdint.h> struct powercap_zone { char name[MAX_LINE_LEN]; / * sys_name relative to PATH_TO_POWERCAP, * do not forget the / in between / char sys_name[SYSFS_PATH_MAX]; int tree_depth; struct powercap_zone parent; struct powercap_zone children[POWERCAP_MAX_CHILD_ZONES]; / More possible caps or attributes to be added? / uint32_t has_power_uw:1, has_energy_uj:1; }; int powercap_walk_zones(struct powercap_zone zone, int (f)(struct powercap_zone zone)); struct powercap_zone powercap_init_zones(void); int powercap_get_enabled(int mode); int powercap_set_enabled(int mode); int powercap_get_driver(char driver, int buflen); int powercap_get_max_energy_range_uj(struct powercap_zone zone, uint64_t val); int powercap_get_energy_uj(struct powercap_zone zone, uint64_t val); int powercap_get_max_power_range_uw(struct powercap_zone zone, uint64_t val); int powercap_get_power_uw(struct powercap_zone zone, uint64_t val); int powercap_zone_get_enabled(struct powercap_zone zone, int mode); int powercap_zone_set_enabled(struct powercap_zone zone, int mode); #endif /* __CPUPOWER_RAPL_H__ */	1.62 KB	2026-03-24 10:02
📄 printf.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _PRINTF_H #define _PRINTF_H 1 #include <features.h> __BEGIN_DECLS #include <bits/types/FILE.h> #define __need_size_t #define __need_wchar_t #include <stddef.h> #include <stdarg.h> struct printf_info { int prec; / Precision. / int width; / Width. / wchar_t spec; / Format letter. / unsigned int is_long_double:1;/ L flag. / unsigned int is_short:1; / h flag. / unsigned int is_long:1; / l flag. / unsigned int alt:1; / # flag. / unsigned int space:1; / Space flag. / unsigned int left:1; / - flag. / unsigned int showsign:1; / + flag. / unsigned int group:1; / ' flag. / unsigned int extra:1; / For special use. / unsigned int is_char:1; / hh flag. / unsigned int wide:1; / Nonzero for wide character streams. / unsigned int i18n:1; / I flag. / unsigned int is_binary128:1; / Floating-point argument is ABI-compatible with IEC 60559 binary128. / unsigned int __pad:3; / Unused so far. / unsigned short int user; / Bits for user-installed modifiers. / wchar_t pad; / Padding character. / }; / Type of a printf specifier-handler function. STREAM is the FILE on which to write output. INFO gives information about the format specification. ARGS is a vector of pointers to the argument data; the number of pointers will be the number returned by the associated arginfo function for the same INFO. The function should return the number of characters written, or -1 for errors. / typedef int printf_function (FILE __stream, const struct printf_info __info, const void const __args); / Type of a printf specifier-arginfo function. INFO gives information about the format specification. N, ARGTYPES, SIZE has to contain the size of the parameter for user-defined types, and return value are as for parse_printf_format except that -1 should be returned if the handler cannot handle this case. This allows to partially overwrite the functionality of existing format specifiers. / typedef int printf_arginfo_size_function (const struct printf_info __info, size_t __n, int __argtypes, int __size); / Old version of 'printf_arginfo_function' without a SIZE parameter. / typedef int printf_arginfo_function (const struct printf_info __info, size_t __n, int __argtypes); / Type of a function to get a value of a user-defined from the variable argument list. / typedef void printf_va_arg_function (void __mem, va_list __ap); / Register FUNC to be called to format SPEC specifiers; ARGINFO must be specified to determine how many arguments a SPEC conversion requires and what their types are. / extern int register_printf_specifier (int __spec, printf_function __func, printf_arginfo_size_function __arginfo) __THROW; / Obsolete interface similar to register_printf_specifier. It can only handle basic data types because the ARGINFO callback does not return information on the size of the user-defined type. / extern int register_printf_function (int __spec, printf_function __func, printf_arginfo_function __arginfo) __THROW __attribute_deprecated__; / Register a new modifier character sequence. If the call succeeds it returns a positive value representing the bit set in the USER field in 'struct printf_info'. / extern int register_printf_modifier (const wchar_t __str) __THROW __wur; /* Register variable argument handler for user type. The return value is to be used in ARGINFO functions to signal the use of the type. / extern int register_printf_type (printf_va_arg_function __fct) __THROW __wur; / Parse FMT, and fill in N elements of ARGTYPES with the types needed for the conversions FMT specifies. Returns the number of arguments required by FMT. The ARGINFO function registered with a user-defined format is passed a `struct printf_info' describing the format spec being parsed. A width or precision of INT_MIN means a `' was used to indicate that the width/precision will come from an arg. The function should fill in the array it is passed with the types of the arguments it wants, and return the number of arguments it wants. / extern size_t parse_printf_format (const char __restrict __fmt, size_t __n, int __restrict __argtypes) __THROW; /* Codes returned by `parse_printf_format' for basic types. These values cover all the standard format specifications. Users can reserve new values after PA_LAST for their own types using 'register_printf_type'. / enum { / C type: / PA_INT, / int / PA_CHAR, / int, cast to char / PA_WCHAR, / wide char / PA_STRING, / const char , a '\0'-terminated string / PA_WSTRING, /* const wchar_t , wide character string / PA_POINTER, /* void * / PA_FLOAT, / float / PA_DOUBLE, / double / PA_LAST }; / Flag bits that can be set in a type returned by `parse_printf_format'. / #define PA_FLAG_MASK 0xff00 #define PA_FLAG_LONG_LONG (1 << 8) #define PA_FLAG_LONG_DOUBLE PA_FLAG_LONG_LONG #define PA_FLAG_LONG (1 << 9) #define PA_FLAG_SHORT (1 << 10) #define PA_FLAG_PTR (1 << 11) / Function which can be registered as `printf'-handlers. / / Print floating point value using using abbreviations for the orders of magnitude used for numbers ('k' for kilo, 'm' for mega etc). If the format specifier is a uppercase character powers of 1000 are used. Otherwise powers of 1024. / extern int printf_size (FILE __restrict __fp, const struct printf_info __info, const void const __restrict __args) __THROW; / This is the appropriate argument information function for `printf_size'. / extern int printf_size_info (const struct printf_info __restrict __info, size_t __n, int __restrict __argtypes) __THROW; #include <bits/floatn.h> #if defined __LDBL_COMPAT \|\| __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 # include <bits/printf-ldbl.h> #endif __END_DECLS #endif / printf.h */	6.71 KB	2026-02-17 11:01
📄 proc_service.h /* Callback interface for libthread_db, functions users must define. Copyright (C) 1999-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _PROC_SERVICE_H #define _PROC_SERVICE_H 1 / The definitions in this file must correspond to those in the debugger. / #include <sys/procfs.h> __BEGIN_DECLS / Functions in this interface return one of these status codes. / typedef enum { PS_OK, / Generic "call succeeded". / PS_ERR, / Generic error. / PS_BADPID, / Bad process handle. / PS_BADLID, / Bad LWP identifier. / PS_BADADDR, / Bad address. / PS_NOSYM, / Could not find given symbol. / PS_NOFREGS / FPU register set not available for given LWP. / } ps_err_e; / This type is opaque in this interface. It's defined by the user of libthread_db. / struct ps_prochandle; / Read or write process memory at the given address. / extern ps_err_e ps_pdread (struct ps_prochandle , psaddr_t, void , size_t); extern ps_err_e ps_pdwrite (struct ps_prochandle , psaddr_t, const void , size_t); extern ps_err_e ps_ptread (struct ps_prochandle , psaddr_t, void , size_t); extern ps_err_e ps_ptwrite (struct ps_prochandle , psaddr_t, const void , size_t); / Get and set the given LWP's general or FPU register set. / extern ps_err_e ps_lgetregs (struct ps_prochandle , lwpid_t, prgregset_t); extern ps_err_e ps_lsetregs (struct ps_prochandle , lwpid_t, const prgregset_t); extern ps_err_e ps_lgetfpregs (struct ps_prochandle , lwpid_t, prfpregset_t ); extern ps_err_e ps_lsetfpregs (struct ps_prochandle , lwpid_t, const prfpregset_t ); / Return the PID of the process. / extern pid_t ps_getpid (struct ps_prochandle ); /* Fetch the special per-thread address associated with the given LWP. This call is only used on a few platforms (most use a normal register). The meaning of the `int' parameter is machine-dependent. / extern ps_err_e ps_get_thread_area (struct ps_prochandle , lwpid_t, int, psaddr_t ); / Look up the named symbol in the named DSO in the symbol tables associated with the process being debugged, filling in SYM_ADDR with the corresponding run-time address. / extern ps_err_e ps_pglobal_lookup (struct ps_prochandle , const char object_name, const char sym_name, psaddr_t sym_addr); /* Stop or continue the entire process. / extern ps_err_e ps_pstop (struct ps_prochandle ); extern ps_err_e ps_pcontinue (struct ps_prochandle ); / Stop or continue the given LWP alone. / extern ps_err_e ps_lstop (struct ps_prochandle , lwpid_t); extern ps_err_e ps_lcontinue (struct ps_prochandle , lwpid_t); __END_DECLS #endif / proc_service.h */	3.4 KB	2026-02-17 11:02
📄 profile.h /* * profile.h / #ifndef _KRB5_PROFILE_H #define _KRB5_PROFILE_H #if defined(_WIN32) #include <win-mac.h> #endif #if defined(__MACH__) && defined(__APPLE__) # include <TargetConditionals.h> # if TARGET_RT_MAC_CFM # error "Use KfM 4.0 SDK headers for CFM compilation." # endif #endif #ifndef KRB5_CALLCONV #define KRB5_CALLCONV #define KRB5_CALLCONV_C #endif typedef struct _profile_t profile_t; /* Used by profile_init_flags(). / #define PROFILE_INIT_ALLOW_MODULE 0x0001 / Allow module declaration / / * Used by the profile iterator in prof_get.c / #define PROFILE_ITER_LIST_SECTION 0x0001 #define PROFILE_ITER_SECTIONS_ONLY 0x0002 #define PROFILE_ITER_RELATIONS_ONLY 0x0004 #ifdef __cplusplus extern "C" { #endif / __cplusplus / typedef char profile_filespec_t; /* path as C string / typedef char profile_filespec_list_t; /* list of : separated paths, C string / typedef const char const_profile_filespec_t; /* path as C string / typedef const char const_profile_filespec_list_t; /* list of : separated paths, C string / long KRB5_CALLCONV profile_init (const_profile_filespec_t files, profile_t ret_profile); long KRB5_CALLCONV profile_init_flags (const_profile_filespec_t files, int flags, profile_t ret_profile); long KRB5_CALLCONV profile_init_path (const_profile_filespec_list_t filelist, profile_t ret_profile); long KRB5_CALLCONV profile_flush (profile_t profile); long KRB5_CALLCONV profile_flush_to_file (profile_t profile, const_profile_filespec_t outfile); long KRB5_CALLCONV profile_flush_to_buffer (profile_t profile, char *bufp); void KRB5_CALLCONV profile_free_buffer (profile_t profile, char buf); long KRB5_CALLCONV profile_is_writable (profile_t profile, int writable); long KRB5_CALLCONV profile_is_modified (profile_t profile, int modified); void KRB5_CALLCONV profile_abandon (profile_t profile); void KRB5_CALLCONV profile_release (profile_t profile); long KRB5_CALLCONV profile_get_values (profile_t profile, const char const names, char *ret_values); void KRB5_CALLCONV profile_free_list (char list); long KRB5_CALLCONV profile_get_string (profile_t profile, const char name, const char subname, const char subsubname, const char def_val, char *ret_string); long KRB5_CALLCONV profile_get_integer (profile_t profile, const char name, const char subname, const char subsubname, int def_val, int ret_default); long KRB5_CALLCONV profile_get_boolean (profile_t profile, const char name, const char subname, const char subsubname, int def_val, int ret_default); long KRB5_CALLCONV profile_get_relation_names (profile_t profile, const char names, char ret_names); long KRB5_CALLCONV profile_get_subsection_names (profile_t profile, const char names, char **ret_names); long KRB5_CALLCONV profile_iterator_create (profile_t profile, const char const names, int flags, void ret_iter); void KRB5_CALLCONV profile_iterator_free (void iter_p); long KRB5_CALLCONV profile_iterator (void iter_p, char ret_name, char ret_value); void KRB5_CALLCONV profile_release_string (char str); long KRB5_CALLCONV profile_update_relation (profile_t profile, const char *names, const char old_value, const char new_value); long KRB5_CALLCONV profile_clear_relation (profile_t profile, const char names); long KRB5_CALLCONV profile_rename_section (profile_t profile, const char names, const char new_name); long KRB5_CALLCONV profile_add_relation (profile_t profile, const char *names, const char new_value); /* * profile_init_vtable allows a caller to create a profile-compatible object * with a different back end. / / * Mandatory: Look up all of the relations for names, placing the resulting * values in ret_values. If no relations exist, return PROF_NO_RELATION, or PROF_NO_SECTION to indicate that one of the intermediate names does not * exist as a section. The list will be freed with free_values. / typedef long (profile_get_values_fn)(void cbdata, const char const names, char *ret_values); / Mandatory: Free a list of strings returned by get_values. / typedef void (profile_free_values_fn)(void cbdata, char values); / Optional: Release any data associated with the profile. / typedef void (profile_cleanup_fn)(void cbdata); / * Optional (mandatory if cleanup is defined): Generate a new cbdata pointer * for a copy of the profile. If not implemented, the new profile will receive * the same cbdata pointer as the old one. / typedef long (profile_copy_fn)(void cbdata, void ret_cbdata); / * Optional: Create an iterator handle. * * If flags contains PROFILE_ITER_LIST_SECTION, iterate over all of the * relations and sections within names. Otherwise, iterate over the relation * values for names, or produce a single section result if names is a section. * * If flags contains PROFILE_ITER_SECTIONS_ONLY, produce only sections. * * If flags contains PROFILE_ITER_RELATIONS_ONLY, produce only relations. / typedef long (profile_iterator_create_fn)(void cbdata, const char const names, int flags, void ret_iter); / * Optional (mandatory if iterator_create is defined): Produce the next * relation or section in an iteration. If producing a section result, set * ret_value to NULL. The returned strings will be freed with free_string. / typedef long (profile_iterator_fn)(void cbdata, void iter, char ret_name, char ret_value); / * Optional (mandatory if iterator_create is defined): Free the memory for an * iterator. / typedef void (profile_iterator_free_fn)(void cbdata, void iter); /* Optional (mandatory if iterator is defined): Free a string value. / typedef void (profile_free_string_fn)(void cbdata, char string); /* * Optional: Determine if a profile is writable. If not implemented, the * profile is never writable. / typedef long (profile_writable_fn)(void cbdata, int writable); /* * Optional: Determine if a profile is modified in memory relative to the * persistent store. If not implemented, the profile is assumed to never be * modified. / typedef long (profile_modified_fn)(void cbdata, int modified); /* * Optional: Change the value of a relation, or remove it if new_value is NULL. * If old_value is set and the relation does not have that value, return * PROF_NO_RELATION. / typedef long (profile_update_relation_fn)(void cbdata, const char names, const char old_value, const char new_value); / * Optional: Rename a section to new_name, or remove the section if new_name is * NULL. / typedef long (profile_rename_section_fn)(void cbdata, const char names, const char new_name); /* * Optional: Add a new relation, or a new section if new_value is NULL. Add * any intermediate sections as necessary. / typedef long (profile_add_relation_fn)(void cbdata, const char names, const char new_value); /* * Optional: Flush any pending memory updates to the persistent store. If * implemented, this function will be called by profile_release as well as * profile_flush, so make sure it's not inefficient to flush an unmodified * profile. / typedef long (profile_flush_fn)(void cbdata); struct profile_vtable { int minor_ver; / Set to structure minor version (currently 1) * if calling profile_init_vtable. / / Methods needed for a basic read-only non-iterable profile (cleanup is * optional). / profile_get_values_fn get_values; profile_free_values_fn free_values; profile_cleanup_fn cleanup; profile_copy_fn copy; / Methods for iterable profiles. / profile_iterator_create_fn iterator_create; profile_iterator_fn iterator; profile_iterator_free_fn iterator_free; profile_free_string_fn free_string; / Methods for writable profiles. / profile_writable_fn writable; profile_modified_fn modified; profile_update_relation_fn update_relation; profile_rename_section_fn rename_section; profile_add_relation_fn add_relation; profile_flush_fn flush; / End of minor version 1. / }; / * Create a profile object whose operations will be performed using the * function pointers in vtable. cbdata will be supplied to each vtable * function as the first argument. / long KRB5_CALLCONV profile_init_vtable (struct profile_vtable vtable, void cbdata, profile_t ret_profile); /* * Dynamically loadable profile modules should define a function named * "profile_module_init" matching the following signature. The function should * initialize the methods of the provided vtable structure, stopping at the * field corresponding to vtable->minor_ver. Do not change the value of * vtable->minor_ver. Unimplemented methods can be left uninitialized. The * function should supply a callback data pointer in cb_ret; this pointer can be cleaned up via the vtable cleanup method. / typedef long (profile_module_init_fn)(const char residual, struct profile_vtable vtable, void *cb_ret); #ifdef __cplusplus } #endif / __cplusplus / #endif / _KRB5_PROFILE_H / / * et-h-prof_err.h: * This file is automatically generated; please do not edit it. / #include <et/com_err.h> #define PROF_VERSION (-1429577728L) #define PROF_MAGIC_NODE (-1429577727L) #define PROF_NO_SECTION (-1429577726L) #define PROF_NO_RELATION (-1429577725L) #define PROF_ADD_NOT_SECTION (-1429577724L) #define PROF_SECTION_WITH_VALUE (-1429577723L) #define PROF_BAD_LINK_LIST (-1429577722L) #define PROF_BAD_GROUP_LVL (-1429577721L) #define PROF_BAD_PARENT_PTR (-1429577720L) #define PROF_MAGIC_ITERATOR (-1429577719L) #define PROF_SET_SECTION_VALUE (-1429577718L) #define PROF_EINVAL (-1429577717L) #define PROF_READ_ONLY (-1429577716L) #define PROF_SECTION_NOTOP (-1429577715L) #define PROF_SECTION_SYNTAX (-1429577714L) #define PROF_RELATION_SYNTAX (-1429577713L) #define PROF_EXTRA_CBRACE (-1429577712L) #define PROF_MISSING_OBRACE (-1429577711L) #define PROF_MAGIC_PROFILE (-1429577710L) #define PROF_MAGIC_SECTION (-1429577709L) #define PROF_TOPSECTION_ITER_NOSUPP (-1429577708L) #define PROF_INVALID_SECTION (-1429577707L) #define PROF_END_OF_SECTIONS (-1429577706L) #define PROF_BAD_NAMESET (-1429577705L) #define PROF_NO_PROFILE (-1429577704L) #define PROF_MAGIC_FILE (-1429577703L) #define PROF_FAIL_OPEN (-1429577702L) #define PROF_EXISTS (-1429577701L) #define PROF_BAD_BOOLEAN (-1429577700L) #define PROF_BAD_INTEGER (-1429577699L) #define PROF_MAGIC_FILE_DATA (-1429577698L) #define PROF_FAIL_INCLUDE_FILE (-1429577697L) #define PROF_FAIL_INCLUDE_DIR (-1429577696L) #define PROF_UNSUPPORTED (-1429577695L) #define PROF_MAGIC_NODE_ITERATOR (-1429577694L) #define PROF_MODULE (-1429577693L) #define PROF_MODULE_SYNTAX (-1429577692L) #define PROF_MODULE_INVALID (-1429577691L) extern const struct error_table et_prof_error_table; extern void initialize_prof_error_table(void); / For compatibility with Heimdal / extern void initialize_prof_error_table_r(struct et_list list); #define ERROR_TABLE_BASE_prof (-1429577728L) / for compatibility with older versions... */ #define init_prof_err_tbl initialize_prof_error_table #define prof_err_base ERROR_TABLE_BASE_prof	11.87 KB	2025-06-24 12:43
📁 protocols	-	2026-03-21 15:44
📄 pthread.h /* Copyright (C) 2002-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _PTHREAD_H #define _PTHREAD_H 1 #include <features.h> #include <sched.h> #include <time.h> #include <bits/endian.h> #include <bits/pthreadtypes.h> #include <bits/setjmp.h> #include <bits/wordsize.h> #include <bits/types/struct_timespec.h> #include <bits/types/__sigset_t.h> #include <bits/types/struct___jmp_buf_tag.h> #ifdef __USE_MISC # include <bits/pthread_stack_min-dynamic.h> #endif / Detach state. / enum { PTHREAD_CREATE_JOINABLE, #define PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_DETACHED #define PTHREAD_CREATE_DETACHED PTHREAD_CREATE_DETACHED }; / Mutex types. / enum { PTHREAD_MUTEX_TIMED_NP, PTHREAD_MUTEX_RECURSIVE_NP, PTHREAD_MUTEX_ERRORCHECK_NP, PTHREAD_MUTEX_ADAPTIVE_NP #if defined __USE_UNIX98 \|\| defined __USE_XOPEN2K8 , PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP, PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL #endif #ifdef __USE_GNU / For compatibility. / , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP #endif }; #ifdef __USE_XOPEN2K / Robust mutex or not flags. / enum { PTHREAD_MUTEX_STALLED, PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED, PTHREAD_MUTEX_ROBUST, PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST }; #endif #if defined __USE_POSIX199506 \|\| defined __USE_UNIX98 / Mutex protocols. / enum { PTHREAD_PRIO_NONE, PTHREAD_PRIO_INHERIT, PTHREAD_PRIO_PROTECT }; #endif #define PTHREAD_MUTEX_INITIALIZER \ { { __PTHREAD_MUTEX_INITIALIZER (PTHREAD_MUTEX_TIMED_NP) } } #ifdef __USE_GNU # define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP \ { { __PTHREAD_MUTEX_INITIALIZER (PTHREAD_MUTEX_RECURSIVE_NP) } } # define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP \ { { __PTHREAD_MUTEX_INITIALIZER (PTHREAD_MUTEX_ERRORCHECK_NP) } } # define PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP \ { { __PTHREAD_MUTEX_INITIALIZER (PTHREAD_MUTEX_ADAPTIVE_NP) } } #endif / Read-write lock types. / #if defined __USE_UNIX98 \|\| defined __USE_XOPEN2K enum { PTHREAD_RWLOCK_PREFER_READER_NP, PTHREAD_RWLOCK_PREFER_WRITER_NP, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP }; / Read-write lock initializers. / # define PTHREAD_RWLOCK_INITIALIZER \ { { __PTHREAD_RWLOCK_INITIALIZER (PTHREAD_RWLOCK_DEFAULT_NP) } } # ifdef __USE_GNU # define PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP \ { { __PTHREAD_RWLOCK_INITIALIZER (PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP) } } # endif #endif / Unix98 or XOpen2K / / Scheduler inheritance. / enum { PTHREAD_INHERIT_SCHED, #define PTHREAD_INHERIT_SCHED PTHREAD_INHERIT_SCHED PTHREAD_EXPLICIT_SCHED #define PTHREAD_EXPLICIT_SCHED PTHREAD_EXPLICIT_SCHED }; / Scope handling. / enum { PTHREAD_SCOPE_SYSTEM, #define PTHREAD_SCOPE_SYSTEM PTHREAD_SCOPE_SYSTEM PTHREAD_SCOPE_PROCESS #define PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_PROCESS }; / Process shared or private flag. / enum { PTHREAD_PROCESS_PRIVATE, #define PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_SHARED #define PTHREAD_PROCESS_SHARED PTHREAD_PROCESS_SHARED }; / Conditional variable handling. / #define PTHREAD_COND_INITIALIZER { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0} } } / Cleanup buffers / struct _pthread_cleanup_buffer { void (__routine) (void ); / Function to call. / void __arg; /* Its argument. / int __canceltype; / Saved cancellation type. / struct _pthread_cleanup_buffer __prev; /* Chaining of cleanup functions. / }; / Cancellation / enum { PTHREAD_CANCEL_ENABLE, #define PTHREAD_CANCEL_ENABLE PTHREAD_CANCEL_ENABLE PTHREAD_CANCEL_DISABLE #define PTHREAD_CANCEL_DISABLE PTHREAD_CANCEL_DISABLE }; enum { PTHREAD_CANCEL_DEFERRED, #define PTHREAD_CANCEL_DEFERRED PTHREAD_CANCEL_DEFERRED PTHREAD_CANCEL_ASYNCHRONOUS #define PTHREAD_CANCEL_ASYNCHRONOUS PTHREAD_CANCEL_ASYNCHRONOUS }; #define PTHREAD_CANCELED ((void ) -1) /* Single execution handling. / #define PTHREAD_ONCE_INIT 0 #ifdef __USE_XOPEN2K / Value returned by 'pthread_barrier_wait' for one of the threads after the required number of threads have called this function. -1 is distinct from 0 and all errno constants / # define PTHREAD_BARRIER_SERIAL_THREAD -1 #endif __BEGIN_DECLS / Create a new thread, starting with execution of START-ROUTINE getting passed ARG. Creation attributed come from ATTR. The new handle is stored in NEWTHREAD. / extern int pthread_create (pthread_t __restrict __newthread, const pthread_attr_t __restrict __attr, void (__start_routine) (void ), void __restrict __arg) __THROWNL __nonnull ((1, 3)); /* Terminate calling thread. The registered cleanup handlers are called via exception handling so we cannot mark this function with __THROW./ extern void pthread_exit (void __retval) __attribute__ ((__noreturn__)); /* Make calling thread wait for termination of the thread TH. The exit status of the thread is stored in THREAD_RETURN, if THREAD_RETURN is not NULL. This function is a cancellation point and therefore not marked with __THROW. / extern int pthread_join (pthread_t __th, void *__thread_return); #ifdef __USE_GNU / Check whether thread TH has terminated. If yes return the status of the thread in THREAD_RETURN, if THREAD_RETURN is not NULL. / extern int pthread_tryjoin_np (pthread_t __th, void *__thread_return) __THROW; # ifndef __USE_TIME_BITS64 / Make calling thread wait for termination of the thread TH, but only until TIMEOUT. The exit status of the thread is stored in THREAD_RETURN, if THREAD_RETURN is not NULL. This function is a cancellation point and therefore not marked with __THROW. / extern int pthread_timedjoin_np (pthread_t __th, void *__thread_return, const struct timespec __abstime); /* Make calling thread wait for termination of the thread TH, but only until TIMEOUT measured against the clock specified by CLOCKID. The exit status of the thread is stored in THREAD_RETURN, if THREAD_RETURN is not NULL. This function is a cancellation point and therefore not marked with __THROW. / extern int pthread_clockjoin_np (pthread_t __th, void *__thread_return, clockid_t __clockid, const struct timespec __abstime); # else # ifdef __REDIRECT extern int __REDIRECT (pthread_timedjoin_np, (pthread_t __th, void *__thread_return, const struct timespec __abstime), __pthread_timedjoin_np64); extern int __REDIRECT (pthread_clockjoin_np, (pthread_t __th, void *__thread_return, clockid_t __clockid, const struct timespec __abstime), __pthread_clockjoin_np64); # else # define pthread_timedjoin_np __pthread_timedjoin_np64 # define pthread_clockjoin_np __pthread_clockjoin_np64 # endif # endif #endif /* Indicate that the thread TH is never to be joined with PTHREAD_JOIN. The resources of TH will therefore be freed immediately when it terminates, instead of waiting for another thread to perform PTHREAD_JOIN on it. / extern int pthread_detach (pthread_t __th) __THROW; / Obtain the identifier of the current thread. / extern pthread_t pthread_self (void) __THROW __attribute__ ((__const__)); / Compare two thread identifiers. / extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) __THROW __attribute__ ((__const__)); / Thread attribute handling. / / Initialize thread attribute ATTR with default attributes (detachstate is PTHREAD_JOINABLE, scheduling policy is SCHED_OTHER, no user-provided stack). / extern int pthread_attr_init (pthread_attr_t __attr) __THROW __nonnull ((1)); / Destroy thread attribute ATTR. / extern int pthread_attr_destroy (pthread_attr_t __attr) __THROW __nonnull ((1)); / Get detach state attribute. / extern int pthread_attr_getdetachstate (const pthread_attr_t __attr, int __detachstate) __THROW __nonnull ((1, 2)); / Set detach state attribute. / extern int pthread_attr_setdetachstate (pthread_attr_t __attr, int __detachstate) __THROW __nonnull ((1)); /* Get the size of the guard area created for stack overflow protection. / extern int pthread_attr_getguardsize (const pthread_attr_t __attr, size_t __guardsize) __THROW __nonnull ((1, 2)); / Set the size of the guard area created for stack overflow protection. / extern int pthread_attr_setguardsize (pthread_attr_t __attr, size_t __guardsize) __THROW __nonnull ((1)); /* Return in PARAM the scheduling parameters of ATTR. / extern int pthread_attr_getschedparam (const pthread_attr_t __restrict __attr, struct sched_param __restrict __param) __THROW __nonnull ((1, 2)); / Set scheduling parameters (priority, etc) in ATTR according to PARAM. / extern int pthread_attr_setschedparam (pthread_attr_t __restrict __attr, const struct sched_param __restrict __param) __THROW __nonnull ((1, 2)); /* Return in POLICY the scheduling policy of ATTR. / extern int pthread_attr_getschedpolicy (const pthread_attr_t __restrict __attr, int __restrict __policy) __THROW __nonnull ((1, 2)); / Set scheduling policy in ATTR according to POLICY. / extern int pthread_attr_setschedpolicy (pthread_attr_t __attr, int __policy) __THROW __nonnull ((1)); / Return in INHERIT the scheduling inheritance mode of ATTR. / extern int pthread_attr_getinheritsched (const pthread_attr_t __restrict __attr, int __restrict __inherit) __THROW __nonnull ((1, 2)); / Set scheduling inheritance mode in ATTR according to INHERIT. / extern int pthread_attr_setinheritsched (pthread_attr_t __attr, int __inherit) __THROW __nonnull ((1)); / Return in SCOPE the scheduling contention scope of ATTR. / extern int pthread_attr_getscope (const pthread_attr_t __restrict __attr, int __restrict __scope) __THROW __nonnull ((1, 2)); / Set scheduling contention scope in ATTR according to SCOPE. / extern int pthread_attr_setscope (pthread_attr_t __attr, int __scope) __THROW __nonnull ((1)); / Return the previously set address for the stack. / extern int pthread_attr_getstackaddr (const pthread_attr_t __restrict __attr, void *__restrict __stackaddr) __THROW __nonnull ((1, 2)) __attribute_deprecated__; / Set the starting address of the stack of the thread to be created. Depending on whether the stack grows up or down the value must either be higher or lower than all the address in the memory block. The minimal size of the block must be PTHREAD_STACK_MIN. / extern int pthread_attr_setstackaddr (pthread_attr_t __attr, void __stackaddr) __THROW __nonnull ((1)) __attribute_deprecated__; / Return the currently used minimal stack size. / extern int pthread_attr_getstacksize (const pthread_attr_t __restrict __attr, size_t __restrict __stacksize) __THROW __nonnull ((1, 2)); / Add information about the minimum stack size needed for the thread to be started. This size must never be less than PTHREAD_STACK_MIN and must also not exceed the system limits. / extern int pthread_attr_setstacksize (pthread_attr_t __attr, size_t __stacksize) __THROW __nonnull ((1)); #ifdef __USE_XOPEN2K /* Return the previously set address for the stack. / extern int pthread_attr_getstack (const pthread_attr_t __restrict __attr, void *__restrict __stackaddr, size_t __restrict __stacksize) __THROW __nonnull ((1, 2, 3)); /* The following two interfaces are intended to replace the last two. They require setting the address as well as the size since only setting the address will make the implementation on some architectures impossible. / extern int pthread_attr_setstack (pthread_attr_t __attr, void __stackaddr, size_t __stacksize) __THROW __nonnull ((1)); #endif #ifdef __USE_GNU / Thread created with attribute ATTR will be limited to run only on the processors represented in CPUSET. / extern int pthread_attr_setaffinity_np (pthread_attr_t __attr, size_t __cpusetsize, const cpu_set_t __cpuset) __THROW __nonnull ((1, 3)); / Get bit set in CPUSET representing the processors threads created with ATTR can run on. / extern int pthread_attr_getaffinity_np (const pthread_attr_t __attr, size_t __cpusetsize, cpu_set_t __cpuset) __THROW __nonnull ((1, 3)); / Get the default attributes used by pthread_create in this process. / extern int pthread_getattr_default_np (pthread_attr_t __attr) __THROW __nonnull ((1)); /* Store SIGMASK as the signal mask for the new thread in ATTR. / extern int pthread_attr_setsigmask_np (pthread_attr_t __attr, const __sigset_t sigmask); / Store the signal mask of ATTR in SIGMASK. If there is no signal mask stored, return PTHREAD_ATTR_NOSIGMASK_NP. Return zero on success. / extern int pthread_attr_getsigmask_np (const pthread_attr_t __attr, __sigset_t sigmask); / Special return value from pthread_attr_getsigmask_np if the signal mask has not been set. / #define PTHREAD_ATTR_NO_SIGMASK_NP (-1) / Set the default attributes to be used by pthread_create in this process. / extern int pthread_setattr_default_np (const pthread_attr_t __attr) __THROW __nonnull ((1)); /* Initialize thread attribute ATTR with attributes corresponding to the already running thread TH. It shall be called on uninitialized ATTR and destroyed with pthread_attr_destroy when no longer needed. / extern int pthread_getattr_np (pthread_t __th, pthread_attr_t __attr) __THROW __nonnull ((2)); #endif / Functions for scheduling control. / / Set the scheduling parameters for TARGET_THREAD according to POLICY and PARAM. / extern int pthread_setschedparam (pthread_t __target_thread, int __policy, const struct sched_param __param) __THROW __nonnull ((3)); / Return in POLICY and PARAM the scheduling parameters for TARGET_THREAD. / extern int pthread_getschedparam (pthread_t __target_thread, int __restrict __policy, struct sched_param __restrict __param) __THROW __nonnull ((2, 3)); / Set the scheduling priority for TARGET_THREAD. / extern int pthread_setschedprio (pthread_t __target_thread, int __prio) __THROW; #ifdef __USE_GNU / Get thread name visible in the kernel and its interfaces. / extern int pthread_getname_np (pthread_t __target_thread, char __buf, size_t __buflen) __THROW __nonnull ((2)); /* Set thread name visible in the kernel and its interfaces. / extern int pthread_setname_np (pthread_t __target_thread, const char __name) __THROW __nonnull ((2)); #endif #ifdef __USE_UNIX98 /* Determine level of concurrency. / extern int pthread_getconcurrency (void) __THROW; / Set new concurrency level to LEVEL. / extern int pthread_setconcurrency (int __level) __THROW; #endif #ifdef __USE_GNU extern int pthread_yield (void) __THROW; # ifdef __REDIRECT_NTH extern int __REDIRECT_NTH (pthread_yield, (void), sched_yield) __attribute_deprecated_msg__ ("\ pthread_yield is deprecated, use sched_yield instead"); # else # define pthread_yield sched_yield # endif / Limit specified thread TH to run only on the processors represented in CPUSET. / extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize, const cpu_set_t __cpuset) __THROW __nonnull ((3)); /* Get bit set in CPUSET representing the processors TH can run on. / extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize, cpu_set_t __cpuset) __THROW __nonnull ((3)); #endif /* Functions for handling initialization. / / Guarantee that the initialization function INIT_ROUTINE will be called only once, even if pthread_once is executed several times with the same ONCE_CONTROL argument. ONCE_CONTROL must point to a static or extern variable initialized to PTHREAD_ONCE_INIT. The initialization functions might throw exception which is why this function is not marked with __THROW. / extern int pthread_once (pthread_once_t __once_control, void (__init_routine) (void)) __nonnull ((1, 2)); / Functions for handling cancellation. Note that these functions are explicitly not marked to not throw an exception in C++ code. If cancellation is implemented by unwinding this is necessary to have the compiler generate the unwind information. / / Set cancelability state of current thread to STATE, returning old state in OLDSTATE if OLDSTATE is not NULL. / extern int pthread_setcancelstate (int __state, int __oldstate); / Set cancellation state of current thread to TYPE, returning the old type in OLDTYPE if OLDTYPE is not NULL. / extern int pthread_setcanceltype (int __type, int __oldtype); / Cancel THREAD immediately or at the next possibility. / extern int pthread_cancel (pthread_t __th); / Test for pending cancellation for the current thread and terminate the thread as per pthread_exit(PTHREAD_CANCELED) if it has been cancelled. / extern void pthread_testcancel (void); / Cancellation handling with integration into exception handling. / struct __cancel_jmp_buf_tag { __jmp_buf __cancel_jmp_buf; int __mask_was_saved; }; typedef struct { struct __cancel_jmp_buf_tag __cancel_jmp_buf[1]; void __pad[4]; } __pthread_unwind_buf_t __attribute__ ((__aligned__)); /* No special attributes by default. / #ifndef __cleanup_fct_attribute # define __cleanup_fct_attribute #endif / Structure to hold the cleanup handler information. / struct __pthread_cleanup_frame { void (__cancel_routine) (void ); void __cancel_arg; int __do_it; int __cancel_type; }; #if defined __GNUC__ && defined __EXCEPTIONS # ifdef __cplusplus /* Class to handle cancellation handler invocation. / class __pthread_cleanup_class { void (__cancel_routine) (void ); void __cancel_arg; int __do_it; int __cancel_type; public: __pthread_cleanup_class (void (__fct) (void ), void __arg) : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { } ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); } void __setdoit (int __newval) { __do_it = __newval; } void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, &__cancel_type); } void __restore () const { pthread_setcanceltype (__cancel_type, 0); } }; / Install a cleanup handler: ROUTINE will be called with arguments ARG when the thread is canceled or calls pthread_exit. ROUTINE will also be called with arguments ARG when the matching pthread_cleanup_pop is executed with non-zero EXECUTE argument. pthread_cleanup_push and pthread_cleanup_pop are macros and must always be used in matching pairs at the same nesting level of braces. / # define pthread_cleanup_push(routine, arg) \ do { \ __pthread_cleanup_class __clframe (routine, arg) / Remove a cleanup handler installed by the matching pthread_cleanup_push. If EXECUTE is non-zero, the handler function is called. / # define pthread_cleanup_pop(execute) \ __clframe.__setdoit (execute); \ } while (0) # ifdef __USE_GNU / Install a cleanup handler as pthread_cleanup_push does, but also saves the current cancellation type and sets it to deferred cancellation. / # define pthread_cleanup_push_defer_np(routine, arg) \ do { \ __pthread_cleanup_class __clframe (routine, arg); \ __clframe.__defer () / Remove a cleanup handler as pthread_cleanup_pop does, but also restores the cancellation type that was in effect when the matching pthread_cleanup_push_defer was called. / # define pthread_cleanup_pop_restore_np(execute) \ __clframe.__restore (); \ __clframe.__setdoit (execute); \ } while (0) # endif # else / Function called to call the cleanup handler. As an extern inline function the compiler is free to decide inlining the change when needed or fall back on the copy which must exist somewhere else. / __extern_inline void __pthread_cleanup_routine (struct __pthread_cleanup_frame __frame) { if (__frame->__do_it) __frame->__cancel_routine (__frame->__cancel_arg); } /* Install a cleanup handler: ROUTINE will be called with arguments ARG when the thread is canceled or calls pthread_exit. ROUTINE will also be called with arguments ARG when the matching pthread_cleanup_pop is executed with non-zero EXECUTE argument. pthread_cleanup_push and pthread_cleanup_pop are macros and must always be used in matching pairs at the same nesting level of braces. / # define pthread_cleanup_push(routine, arg) \ do { \ struct __pthread_cleanup_frame __clframe \ __attribute__ ((__cleanup__ (__pthread_cleanup_routine))) \ = { .__cancel_routine = (routine), .__cancel_arg = (arg), \ .__do_it = 1 }; / Remove a cleanup handler installed by the matching pthread_cleanup_push. If EXECUTE is non-zero, the handler function is called. / # define pthread_cleanup_pop(execute) \ __clframe.__do_it = (execute); \ } while (0) # ifdef __USE_GNU / Install a cleanup handler as pthread_cleanup_push does, but also saves the current cancellation type and sets it to deferred cancellation. / # define pthread_cleanup_push_defer_np(routine, arg) \ do { \ struct __pthread_cleanup_frame __clframe \ __attribute__ ((__cleanup__ (__pthread_cleanup_routine))) \ = { .__cancel_routine = (routine), .__cancel_arg = (arg), \ .__do_it = 1 }; \ (void) pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, \ &__clframe.__cancel_type) / Remove a cleanup handler as pthread_cleanup_pop does, but also restores the cancellation type that was in effect when the matching pthread_cleanup_push_defer was called. / # define pthread_cleanup_pop_restore_np(execute) \ (void) pthread_setcanceltype (__clframe.__cancel_type, NULL); \ __clframe.__do_it = (execute); \ } while (0) # endif # endif #else / Install a cleanup handler: ROUTINE will be called with arguments ARG when the thread is canceled or calls pthread_exit. ROUTINE will also be called with arguments ARG when the matching pthread_cleanup_pop is executed with non-zero EXECUTE argument. pthread_cleanup_push and pthread_cleanup_pop are macros and must always be used in matching pairs at the same nesting level of braces. / # define pthread_cleanup_push(routine, arg) \ do { \ __pthread_unwind_buf_t __cancel_buf; \ void (__cancel_routine) (void ) = (routine); \ void __cancel_arg = (arg); \ int __not_first_call = __sigsetjmp_cancel (__cancel_buf.__cancel_jmp_buf, \ 0); \ if (__glibc_unlikely (__not_first_call)) \ { \ __cancel_routine (__cancel_arg); \ __pthread_unwind_next (&__cancel_buf); \ /* NOTREACHED / \ } \ \ __pthread_register_cancel (&__cancel_buf); \ do { extern void __pthread_register_cancel (__pthread_unwind_buf_t __buf) __cleanup_fct_attribute; /* Remove a cleanup handler installed by the matching pthread_cleanup_push. If EXECUTE is non-zero, the handler function is called. / # define pthread_cleanup_pop(execute) \ do { } while (0);/ Empty to allow label before pthread_cleanup_pop. /\ } while (0); \ __pthread_unregister_cancel (&__cancel_buf); \ if (execute) \ __cancel_routine (__cancel_arg); \ } while (0) extern void __pthread_unregister_cancel (__pthread_unwind_buf_t __buf) __cleanup_fct_attribute; # ifdef __USE_GNU /* Install a cleanup handler as pthread_cleanup_push does, but also saves the current cancellation type and sets it to deferred cancellation. / # define pthread_cleanup_push_defer_np(routine, arg) \ do { \ __pthread_unwind_buf_t __cancel_buf; \ void (__cancel_routine) (void ) = (routine); \ void __cancel_arg = (arg); \ int __not_first_call = __sigsetjmp_cancel (__cancel_buf.__cancel_jmp_buf, \ 0); \ if (__glibc_unlikely (__not_first_call)) \ { \ __cancel_routine (__cancel_arg); \ __pthread_unwind_next (&__cancel_buf); \ /* NOTREACHED / \ } \ \ __pthread_register_cancel_defer (&__cancel_buf); \ do { extern void __pthread_register_cancel_defer (__pthread_unwind_buf_t __buf) __cleanup_fct_attribute; /* Remove a cleanup handler as pthread_cleanup_pop does, but also restores the cancellation type that was in effect when the matching pthread_cleanup_push_defer was called. / # define pthread_cleanup_pop_restore_np(execute) \ do { } while (0);/ Empty to allow label before pthread_cleanup_pop. /\ } while (0); \ __pthread_unregister_cancel_restore (&__cancel_buf); \ if (execute) \ __cancel_routine (__cancel_arg); \ } while (0) extern void __pthread_unregister_cancel_restore (__pthread_unwind_buf_t __buf) __cleanup_fct_attribute; # endif /* Internal interface to initiate cleanup. / extern void __pthread_unwind_next (__pthread_unwind_buf_t __buf) __cleanup_fct_attribute __attribute__ ((__noreturn__)) # ifndef SHARED __attribute__ ((__weak__)) # endif ; #endif /* Function used in the macros. Calling __sigsetjmp, with its first argument declared as an array, results in a -Wstringop-overflow warning from GCC 11 because struct pthread_unwind_buf is smaller than jmp_buf. The calls from the macros have __SAVEMASK set to 0, so nothing beyond the common prefix is used and this warning is a false positive. Use an alias with its first argument declared to use the type in the macros if possible to avoid this warning. / #if __GNUC_PREREQ (11, 0) extern int __REDIRECT_NTHNL (__sigsetjmp_cancel, (struct __cancel_jmp_buf_tag __env[1], int __savemask), __sigsetjmp) __attribute_returns_twice__; #else # define __sigsetjmp_cancel(env, savemask) \ __sigsetjmp ((struct __jmp_buf_tag ) (void ) (env), (savemask)) extern int __sigsetjmp (struct __jmp_buf_tag __env[1], int __savemask) __THROWNL; #endif / Mutex handling. / / Initialize a mutex. / extern int pthread_mutex_init (pthread_mutex_t __mutex, const pthread_mutexattr_t __mutexattr) __THROW __nonnull ((1)); / Destroy a mutex. / extern int pthread_mutex_destroy (pthread_mutex_t __mutex) __THROW __nonnull ((1)); /* Try locking a mutex. / extern int pthread_mutex_trylock (pthread_mutex_t __mutex) __THROWNL __nonnull ((1)); /* Lock a mutex. / extern int pthread_mutex_lock (pthread_mutex_t __mutex) __THROWNL __nonnull ((1)); #ifdef __USE_XOPEN2K /* Wait until lock becomes available, or specified time passes. / # ifndef __USE_TIME_BITS64 extern int pthread_mutex_timedlock (pthread_mutex_t __restrict __mutex, const struct timespec __restrict __abstime) __THROWNL __nonnull ((1, 2)); # else # ifdef __REDIRECT_NTHNL extern int __REDIRECT_NTHNL (pthread_mutex_timedlock, (pthread_mutex_t __restrict __mutex, const struct timespec __restrict __abstime), __pthread_mutex_timedlock64) __nonnull ((1, 2)); # else # define pthread_mutex_timedlock __pthread_mutex_timedlock64 # endif # endif #endif #ifdef __USE_GNU # ifndef __USE_TIME_BITS64 extern int pthread_mutex_clocklock (pthread_mutex_t __restrict __mutex, clockid_t __clockid, const struct timespec __restrict __abstime) __THROWNL __nonnull ((1, 3)); # else # ifdef __REDIRECT_NTHNL extern int __REDIRECT_NTHNL (pthread_mutex_clocklock, (pthread_mutex_t __restrict __mutex, clockid_t __clockid, const struct timespec __restrict __abstime), __pthread_mutex_clocklock64) __nonnull ((1, 3)); # else # define pthread_mutex_clocklock __pthread_mutex_clocklock64 # endif # endif #endif / Unlock a mutex. / extern int pthread_mutex_unlock (pthread_mutex_t __mutex) __THROWNL __nonnull ((1)); /* Get the priority ceiling of MUTEX. / extern int pthread_mutex_getprioceiling (const pthread_mutex_t __restrict __mutex, int __restrict __prioceiling) __THROW __nonnull ((1, 2)); / Set the priority ceiling of MUTEX to PRIOCEILING, return old priority ceiling value in OLD_CEILING. / extern int pthread_mutex_setprioceiling (pthread_mutex_t __restrict __mutex, int __prioceiling, int __restrict __old_ceiling) __THROW __nonnull ((1, 3)); #ifdef __USE_XOPEN2K8 /* Declare the state protected by MUTEX as consistent. / extern int pthread_mutex_consistent (pthread_mutex_t __mutex) __THROW __nonnull ((1)); # ifdef __USE_GNU # ifdef __REDIRECT_NTH extern int __REDIRECT_NTH (pthread_mutex_consistent_np, (pthread_mutex_t ), pthread_mutex_consistent) __nonnull ((1)) __attribute_deprecated_msg__ ("\ pthread_mutex_consistent_np is deprecated, use pthread_mutex_consistent"); # else # define pthread_mutex_consistent_np pthread_mutex_consistent # endif # endif #endif / Functions for handling mutex attributes. / / Initialize mutex attribute object ATTR with default attributes (kind is PTHREAD_MUTEX_TIMED_NP). / extern int pthread_mutexattr_init (pthread_mutexattr_t __attr) __THROW __nonnull ((1)); /* Destroy mutex attribute object ATTR. / extern int pthread_mutexattr_destroy (pthread_mutexattr_t __attr) __THROW __nonnull ((1)); /* Get the process-shared flag of the mutex attribute ATTR. / extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t __restrict __attr, int __restrict __pshared) __THROW __nonnull ((1, 2)); / Set the process-shared flag of the mutex attribute ATTR. / extern int pthread_mutexattr_setpshared (pthread_mutexattr_t __attr, int __pshared) __THROW __nonnull ((1)); #if defined __USE_UNIX98 \|\| defined __USE_XOPEN2K8 /* Return in KIND the mutex kind attribute in ATTR. / extern int pthread_mutexattr_gettype (const pthread_mutexattr_t __restrict __attr, int __restrict __kind) __THROW __nonnull ((1, 2)); / Set the mutex kind attribute in ATTR to KIND (either PTHREAD_MUTEX_NORMAL, PTHREAD_MUTEX_RECURSIVE, PTHREAD_MUTEX_ERRORCHECK, or PTHREAD_MUTEX_DEFAULT). / extern int pthread_mutexattr_settype (pthread_mutexattr_t __attr, int __kind) __THROW __nonnull ((1)); #endif / Return in PROTOCOL the mutex protocol attribute in ATTR. / extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t __restrict __attr, int __restrict __protocol) __THROW __nonnull ((1, 2)); / Set the mutex protocol attribute in ATTR to PROTOCOL (either PTHREAD_PRIO_NONE, PTHREAD_PRIO_INHERIT, or PTHREAD_PRIO_PROTECT). / extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t __attr, int __protocol) __THROW __nonnull ((1)); / Return in PRIOCEILING the mutex prioceiling attribute in ATTR. / extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t __restrict __attr, int __restrict __prioceiling) __THROW __nonnull ((1, 2)); / Set the mutex prioceiling attribute in ATTR to PRIOCEILING. / extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t __attr, int __prioceiling) __THROW __nonnull ((1)); #ifdef __USE_XOPEN2K / Get the robustness flag of the mutex attribute ATTR. / extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t __attr, int __robustness) __THROW __nonnull ((1, 2)); # ifdef __USE_GNU # ifdef __REDIRECT_NTH extern int __REDIRECT_NTH (pthread_mutexattr_getrobust_np, (pthread_mutexattr_t , int ), pthread_mutexattr_getrobust) __nonnull ((1)) __attribute_deprecated_msg__ ("\ pthread_mutexattr_getrobust_np is deprecated, use pthread_mutexattr_getrobust"); # else # define pthread_mutexattr_getrobust_np pthread_mutexattr_getrobust # endif # endif / Set the robustness flag of the mutex attribute ATTR. / extern int pthread_mutexattr_setrobust (pthread_mutexattr_t __attr, int __robustness) __THROW __nonnull ((1)); # ifdef __USE_GNU # ifdef __REDIRECT_NTH extern int __REDIRECT_NTH (pthread_mutexattr_setrobust_np, (pthread_mutexattr_t , int), pthread_mutexattr_setrobust) __nonnull ((1)) __attribute_deprecated_msg__ ("\ pthread_mutexattr_setrobust_np is deprecated, use pthread_mutexattr_setrobust"); # else # define pthread_mutexattr_setrobust_np pthread_mutexattr_setrobust # endif # endif #endif #if defined __USE_UNIX98 \|\| defined __USE_XOPEN2K / Functions for handling read-write locks. / / Initialize read-write lock RWLOCK using attributes ATTR, or use the default values if later is NULL. / extern int pthread_rwlock_init (pthread_rwlock_t __restrict __rwlock, const pthread_rwlockattr_t __restrict __attr) __THROW __nonnull ((1)); / Destroy read-write lock RWLOCK. / extern int pthread_rwlock_destroy (pthread_rwlock_t __rwlock) __THROW __nonnull ((1)); /* Acquire read lock for RWLOCK. / extern int pthread_rwlock_rdlock (pthread_rwlock_t __rwlock) __THROWNL __nonnull ((1)); /* Try to acquire read lock for RWLOCK. / extern int pthread_rwlock_tryrdlock (pthread_rwlock_t __rwlock) __THROWNL __nonnull ((1)); # ifdef __USE_XOPEN2K /* Try to acquire read lock for RWLOCK or return after specfied time. / # ifndef __USE_TIME_BITS64 extern int pthread_rwlock_timedrdlock (pthread_rwlock_t __restrict __rwlock, const struct timespec __restrict __abstime) __THROWNL __nonnull ((1, 2)); # else # ifdef __REDIRECT_NTHNL extern int __REDIRECT_NTHNL (pthread_rwlock_timedrdlock, (pthread_rwlock_t __restrict __rwlock, const struct timespec __restrict __abstime), __pthread_rwlock_timedrdlock64) __nonnull ((1, 2)); # else # define pthread_rwlock_timedrdlock __pthread_rwlock_timedrdlock64 # endif # endif # endif # ifdef __USE_GNU # ifndef __USE_TIME_BITS64 extern int pthread_rwlock_clockrdlock (pthread_rwlock_t __restrict __rwlock, clockid_t __clockid, const struct timespec __restrict __abstime) __THROWNL __nonnull ((1, 3)); # else # ifdef __REDIRECT_NTHNL extern int __REDIRECT_NTHNL (pthread_rwlock_clockrdlock, (pthread_rwlock_t __restrict __rwlock, clockid_t __clockid, const struct timespec __restrict __abstime), __pthread_rwlock_clockrdlock64) __nonnull ((1, 3)); # else # define pthread_rwlock_clockrdlock __pthread_rwlock_clockrdlock64 # endif # endif # endif / Acquire write lock for RWLOCK. / extern int pthread_rwlock_wrlock (pthread_rwlock_t __rwlock) __THROWNL __nonnull ((1)); /* Try to acquire write lock for RWLOCK. / extern int pthread_rwlock_trywrlock (pthread_rwlock_t __rwlock) __THROWNL __nonnull ((1)); # ifdef __USE_XOPEN2K /* Try to acquire write lock for RWLOCK or return after specfied time. / # ifndef __USE_TIME_BITS64 extern int pthread_rwlock_timedwrlock (pthread_rwlock_t __restrict __rwlock, const struct timespec __restrict __abstime) __THROWNL __nonnull ((1, 2)); # else # ifdef __REDIRECT_NTHNL extern int __REDIRECT_NTHNL (pthread_rwlock_timedwrlock, (pthread_rwlock_t __restrict __rwlock, const struct timespec __restrict __abstime), __pthread_rwlock_timedwrlock64) __nonnull ((1, 2)); # else # define pthread_rwlock_timedwrlock __pthread_rwlock_timedwrlock64 # endif # endif # endif # ifdef __USE_GNU # ifndef __USE_TIME_BITS64 extern int pthread_rwlock_clockwrlock (pthread_rwlock_t __restrict __rwlock, clockid_t __clockid, const struct timespec __restrict __abstime) __THROWNL __nonnull ((1, 3)); # else # ifdef __REDIRECT_NTHNL extern int __REDIRECT_NTHNL (pthread_rwlock_clockwrlock, (pthread_rwlock_t __restrict __rwlock, clockid_t __clockid, const struct timespec __restrict __abstime), __pthread_rwlock_clockwrlock64) __nonnull ((1, 3)); # else # define pthread_rwlock_clockwrlock __pthread_rwlock_clockwrlock64 # endif # endif # endif / Unlock RWLOCK. / extern int pthread_rwlock_unlock (pthread_rwlock_t __rwlock) __THROWNL __nonnull ((1)); /* Functions for handling read-write lock attributes. / / Initialize attribute object ATTR with default values. / extern int pthread_rwlockattr_init (pthread_rwlockattr_t __attr) __THROW __nonnull ((1)); /* Destroy attribute object ATTR. / extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t __attr) __THROW __nonnull ((1)); /* Return current setting of process-shared attribute of ATTR in PSHARED. / extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t __restrict __attr, int __restrict __pshared) __THROW __nonnull ((1, 2)); / Set process-shared attribute of ATTR to PSHARED. / extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t __attr, int __pshared) __THROW __nonnull ((1)); /* Return current setting of reader/writer preference. / extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t __restrict __attr, int __restrict __pref) __THROW __nonnull ((1, 2)); / Set reader/write preference. / extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t __attr, int __pref) __THROW __nonnull ((1)); #endif /* Functions for handling conditional variables. / / Initialize condition variable COND using attributes ATTR, or use the default values if later is NULL. / extern int pthread_cond_init (pthread_cond_t __restrict __cond, const pthread_condattr_t __restrict __cond_attr) __THROW __nonnull ((1)); / Destroy condition variable COND. / extern int pthread_cond_destroy (pthread_cond_t __cond) __THROW __nonnull ((1)); /* Wake up one thread waiting for condition variable COND. / extern int pthread_cond_signal (pthread_cond_t __cond) __THROWNL __nonnull ((1)); /* Wake up all threads waiting for condition variables COND. / extern int pthread_cond_broadcast (pthread_cond_t __cond) __THROWNL __nonnull ((1)); /* Wait for condition variable COND to be signaled or broadcast. MUTEX is assumed to be locked before. This function is a cancellation point and therefore not marked with __THROW. / extern int pthread_cond_wait (pthread_cond_t __restrict __cond, pthread_mutex_t __restrict __mutex) __nonnull ((1, 2)); / Wait for condition variable COND to be signaled or broadcast until ABSTIME. MUTEX is assumed to be locked before. ABSTIME is an absolute time specification; zero is the beginning of the epoch (00:00:00 GMT, January 1, 1970). This function is a cancellation point and therefore not marked with __THROW. / # ifndef __USE_TIME_BITS64 extern int pthread_cond_timedwait (pthread_cond_t __restrict __cond, pthread_mutex_t __restrict __mutex, const struct timespec __restrict __abstime) __nonnull ((1, 2, 3)); # else # ifdef __REDIRECT extern int __REDIRECT (pthread_cond_timedwait, (pthread_cond_t __restrict __cond, pthread_mutex_t __restrict __mutex, const struct timespec __restrict __abstime), __pthread_cond_timedwait64) __nonnull ((1, 2, 3)); # else # define pthread_cond_timedwait __pthread_cond_timedwait64 # endif # endif # ifdef __USE_GNU / Wait for condition variable COND to be signaled or broadcast until ABSTIME measured by the specified clock. MUTEX is assumed to be locked before. CLOCK is the clock to use. ABSTIME is an absolute time specification against CLOCK's epoch. This function is a cancellation point and therefore not marked with __THROW. / # ifndef __USE_TIME_BITS64 extern int pthread_cond_clockwait (pthread_cond_t __restrict __cond, pthread_mutex_t __restrict __mutex, __clockid_t __clock_id, const struct timespec __restrict __abstime) __nonnull ((1, 2, 4)); # else # ifdef __REDIRECT extern int __REDIRECT (pthread_cond_clockwait, (pthread_cond_t __restrict __cond, pthread_mutex_t __restrict __mutex, __clockid_t __clock_id, const struct timespec __restrict __abstime), __pthread_cond_clockwait64) __nonnull ((1, 2, 4)); # else # define pthread_cond_clockwait __pthread_cond_clockwait64 # endif # endif # endif / Functions for handling condition variable attributes. / / Initialize condition variable attribute ATTR. / extern int pthread_condattr_init (pthread_condattr_t __attr) __THROW __nonnull ((1)); /* Destroy condition variable attribute ATTR. / extern int pthread_condattr_destroy (pthread_condattr_t __attr) __THROW __nonnull ((1)); /* Get the process-shared flag of the condition variable attribute ATTR. / extern int pthread_condattr_getpshared (const pthread_condattr_t __restrict __attr, int __restrict __pshared) __THROW __nonnull ((1, 2)); / Set the process-shared flag of the condition variable attribute ATTR. / extern int pthread_condattr_setpshared (pthread_condattr_t __attr, int __pshared) __THROW __nonnull ((1)); #ifdef __USE_XOPEN2K /* Get the clock selected for the condition variable attribute ATTR. / extern int pthread_condattr_getclock (const pthread_condattr_t __restrict __attr, __clockid_t __restrict __clock_id) __THROW __nonnull ((1, 2)); / Set the clock selected for the condition variable attribute ATTR. / extern int pthread_condattr_setclock (pthread_condattr_t __attr, __clockid_t __clock_id) __THROW __nonnull ((1)); #endif #ifdef __USE_XOPEN2K /* Functions to handle spinlocks. / / Initialize the spinlock LOCK. If PSHARED is nonzero the spinlock can be shared between different processes. / extern int pthread_spin_init (pthread_spinlock_t __lock, int __pshared) __THROW __nonnull ((1)); /* Destroy the spinlock LOCK. / extern int pthread_spin_destroy (pthread_spinlock_t __lock) __THROW __nonnull ((1)); /* Wait until spinlock LOCK is retrieved. / extern int pthread_spin_lock (pthread_spinlock_t __lock) __THROWNL __nonnull ((1)); /* Try to lock spinlock LOCK. / extern int pthread_spin_trylock (pthread_spinlock_t __lock) __THROWNL __nonnull ((1)); /* Release spinlock LOCK. / extern int pthread_spin_unlock (pthread_spinlock_t __lock) __THROWNL __nonnull ((1)); /* Functions to handle barriers. / / Initialize BARRIER with the attributes in ATTR. The barrier is opened when COUNT waiters arrived. / extern int pthread_barrier_init (pthread_barrier_t __restrict __barrier, const pthread_barrierattr_t __restrict __attr, unsigned int __count) __THROW __nonnull ((1)); / Destroy a previously dynamically initialized barrier BARRIER. / extern int pthread_barrier_destroy (pthread_barrier_t __barrier) __THROW __nonnull ((1)); /* Wait on barrier BARRIER. / extern int pthread_barrier_wait (pthread_barrier_t __barrier) __THROWNL __nonnull ((1)); /* Initialize barrier attribute ATTR. / extern int pthread_barrierattr_init (pthread_barrierattr_t __attr) __THROW __nonnull ((1)); /* Destroy previously dynamically initialized barrier attribute ATTR. / extern int pthread_barrierattr_destroy (pthread_barrierattr_t __attr) __THROW __nonnull ((1)); /* Get the process-shared flag of the barrier attribute ATTR. / extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t __restrict __attr, int __restrict __pshared) __THROW __nonnull ((1, 2)); / Set the process-shared flag of the barrier attribute ATTR. / extern int pthread_barrierattr_setpshared (pthread_barrierattr_t __attr, int __pshared) __THROW __nonnull ((1)); #endif /* Functions for handling thread-specific data. / / Create a key value identifying a location in the thread-specific data area. Each thread maintains a distinct thread-specific data area. DESTR_FUNCTION, if non-NULL, is called with the value associated to that key when the key is destroyed. DESTR_FUNCTION is not called if the value associated is NULL when the key is destroyed. / extern int pthread_key_create (pthread_key_t __key, void (__destr_function) (void )) __THROW __nonnull ((1)); /* Destroy KEY. / extern int pthread_key_delete (pthread_key_t __key) __THROW; / Return current value of the thread-specific data slot identified by KEY. / extern void pthread_getspecific (pthread_key_t __key) __THROW; /* Store POINTER in the thread-specific data slot identified by KEY. / extern int pthread_setspecific (pthread_key_t __key, const void __pointer) __THROW __attr_access_none (2); #ifdef __USE_XOPEN2K /* Get ID of CPU-time clock for thread THREAD_ID. / extern int pthread_getcpuclockid (pthread_t __thread_id, __clockid_t __clock_id) __THROW __nonnull ((2)); #endif #ifdef __USE_GNU /* Return the Linux TID for THREAD_ID. Returns -1 on failure. / extern pid_t pthread_gettid_np (pthread_t __thread_id); #endif / Install handlers to be called when a new process is created with FORK. The PREPARE handler is called in the parent process just before performing FORK. The PARENT handler is called in the parent process just after FORK. The CHILD handler is called in the child process. Each of the three handlers can be NULL, meaning that no handler needs to be called at that point. PTHREAD_ATFORK can be called several times, in which case the PREPARE handlers are called in LIFO order (last added with PTHREAD_ATFORK, first called before FORK), and the PARENT and CHILD handlers are called in FIFO (first added, first called). / extern int pthread_atfork (void (__prepare) (void), void (__parent) (void), void (__child) (void)) __THROW; #ifdef __USE_EXTERN_INLINES /* Optimizations. / __extern_inline int __NTH (pthread_equal (pthread_t __thread1, pthread_t __thread2)) { return __thread1 == __thread2; } #endif __END_DECLS #endif / pthread.h */	47.39 KB	2026-02-17 11:01
📄 pty.h /* Functions for pseudo TTY handling. Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _PTY_H #define _PTY_H 1 #include <features.h> struct termios; struct winsize; #include <termios.h> #include <sys/ioctl.h> __BEGIN_DECLS / Create pseudo tty master slave pair with NAME and set terminal attributes according to TERMP and WINP and return handles for both ends in AMASTER and ASLAVE. / extern int openpty (int __amaster, int __aslave, char __name, const struct termios __termp, const struct winsize __winp) __THROW; /* Create child process and establish the slave pseudo terminal as the child's controlling terminal. / extern int forkpty (int __amaster, char __name, const struct termios __termp, const struct winsize __winp) __THROW; __END_DECLS #endif / pty.h */	1.53 KB	2026-02-17 11:02
📄 pwd.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * POSIX Standard: 9.2.2 User Database Access <pwd.h> / #ifndef _PWD_H #define _PWD_H 1 #include <features.h> __BEGIN_DECLS #include <bits/types.h> #define __need_size_t #include <stddef.h> #if defined __USE_XOPEN \|\| defined __USE_XOPEN2K / The Single Unix specification says that some more types are available here. / # ifndef __gid_t_defined typedef __gid_t gid_t; # define __gid_t_defined # endif # ifndef __uid_t_defined typedef __uid_t uid_t; # define __uid_t_defined # endif #endif / A record in the user database. / struct passwd { char pw_name; /* Username. / char pw_passwd; /* Hashed passphrase, if shadow database not in use (see shadow.h). / __uid_t pw_uid; / User ID. / __gid_t pw_gid; / Group ID. / char pw_gecos; /* Real name. / char pw_dir; /* Home directory. / char pw_shell; /* Shell program. / }; #ifdef __USE_MISC # include <bits/types/FILE.h> #endif #if defined __USE_MISC \|\| defined __USE_XOPEN_EXTENDED / Rewind the user database stream. This function is a possible cancellation point and therefore not marked with __THROW. / extern void setpwent (void); / Close the user database stream. This function is a possible cancellation point and therefore not marked with __THROW. / extern void endpwent (void); / Read an entry from the user database stream, opening it if necessary. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct passwd getpwent (void); #endif #ifdef __USE_MISC /* Read a user database entry from STREAM. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern struct passwd fgetpwent (FILE __stream) __nonnull ((1)); / Write a given user database entry onto the given stream. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int putpwent (const struct passwd __restrict __p, FILE __restrict __f); #endif / Retrieve the user database entry for the given user ID. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct passwd getpwuid (__uid_t __uid); /* Retrieve the user database entry for the given username. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct passwd getpwnam (const char __name) __nonnull ((1)); #ifdef __USE_POSIX # ifdef __USE_MISC / Reasonable value for the buffer sized used in the reentrant functions below. But better use `sysconf'. / # define NSS_BUFLEN_PASSWD 1024 # endif / Reentrant versions of some of the functions above. PLEASE NOTE: the `getpwent_r' function is not (yet) standardized. The interface may change in later versions of this library. But the interface is designed following the principals used for the other reentrant functions so the chances are good this is what the POSIX people would choose. / # ifdef __USE_MISC / This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int getpwent_r (struct passwd __restrict __resultbuf, char __restrict __buffer, size_t __buflen, struct passwd __restrict __result) __nonnull ((1, 2, 4)) __attr_access ((__write_only__, 2, 3)); # endif extern int getpwuid_r (__uid_t __uid, struct passwd __restrict __resultbuf, char __restrict __buffer, size_t __buflen, struct passwd __restrict __result) __nonnull ((2, 3, 5)) __attr_access ((__write_only__, 3, 4)); extern int getpwnam_r (const char __restrict __name, struct passwd __restrict __resultbuf, char __restrict __buffer, size_t __buflen, struct passwd *__restrict __result) __nonnull ((1, 2, 3, 5)) __attr_access ((__write_only__, 3, 4)); # ifdef __USE_MISC / Read a user database entry from STREAM. This function is not standardized and probably never will. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int fgetpwent_r (FILE __restrict __stream, struct passwd __restrict __resultbuf, char __restrict __buffer, size_t __buflen, struct passwd *__restrict __result) __nonnull ((1, 2, 3, 5)) __attr_access ((__write_only__, 3, 4)); # endif #endif / POSIX or reentrant / #ifdef __USE_GNU / Write a traditional /etc/passwd line, based on the user database entry for the given UID, to BUFFER; space for BUFFER must be allocated by the caller. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int getpw (__uid_t __uid, char __buffer); #endif __END_DECLS #endif /* pwd.h */	6.17 KB	2026-02-17 11:01
📁 python3.9	-	2026-03-21 15:44
📁 rdma	-	2026-03-27 02:43
📄 re_comp.h /* Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _RE_COMP_H #define _RE_COMP_H 1 / This is only a wrapper around the <regex.h> file. XPG4.2 mentions this name. / #include <regex.h> #endif / re_comp.h */	963 B	2026-02-17 11:01
📄 regex.h /* Definitions for data structures and routines for the regular expression library. Copyright (C) 1985, 1989-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _REGEX_H #define _REGEX_H 1 #include <sys/types.h> / Allow the use in C++ code. / #ifdef __cplusplus extern "C" { #endif / Define __USE_GNU to declare GNU extensions that violate the POSIX name space rules. / #ifdef _GNU_SOURCE # define __USE_GNU 1 #endif #ifdef _REGEX_LARGE_OFFSETS / Use types and values that are wide enough to represent signed and unsigned byte offsets in memory. This currently works only when the regex code is used outside of the GNU C library; it is not yet supported within glibc itself, and glibc users should not define _REGEX_LARGE_OFFSETS. / / The type of object sizes. / typedef size_t __re_size_t; / The type of object sizes, in places where the traditional code uses unsigned long int. / typedef size_t __re_long_size_t; #else / The traditional GNU regex implementation mishandles strings longer than INT_MAX. / typedef unsigned int __re_size_t; typedef unsigned long int __re_long_size_t; #endif / The following two types have to be signed and unsigned integer type wide enough to hold a value of a pointer. For most ANSI compilers ptrdiff_t and size_t should be likely OK. Still size of these two types is 2 for Microsoft C. Ugh... / typedef long int s_reg_t; typedef unsigned long int active_reg_t; / The following bits are used to determine the regexp syntax we recognize. The set/not-set meanings are chosen so that Emacs syntax remains the value 0. The bits are given in alphabetical order, and the definitions shifted by one from the previous bit; thus, when we add or remove a bit, only one other definition need change. / typedef unsigned long int reg_syntax_t; #ifdef __USE_GNU / If this bit is not set, then \ inside a bracket expression is literal. If set, then such a \ quotes the following character. / # define RE_BACKSLASH_ESCAPE_IN_LISTS ((unsigned long int) 1) / If this bit is not set, then + and ? are operators, and \+ and \? are literals. If set, then \+ and \? are operators and + and ? are literals. / # define RE_BK_PLUS_QM (RE_BACKSLASH_ESCAPE_IN_LISTS << 1) / If this bit is set, then character classes are supported. They are: [:alpha:], [:upper:], [:lower:], [:digit:], [:alnum:], [:xdigit:], [:space:], [:print:], [:punct:], [:graph:], and [:cntrl:]. If not set, then character classes are not supported. / # define RE_CHAR_CLASSES (RE_BK_PLUS_QM << 1) / If this bit is set, then ^ and $ are always anchors (outside bracket expressions, of course). If this bit is not set, then it depends: ^ is an anchor if it is at the beginning of a regular expression or after an open-group or an alternation operator; $ is an anchor if it is at the end of a regular expression, or before a close-group or an alternation operator. This bit could be (re)combined with RE_CONTEXT_INDEP_OPS, because POSIX draft 11.2 says that * etc. in leading positions is undefined. We already implemented a previous draft which made those constructs invalid, though, so we haven't changed the code back. / # define RE_CONTEXT_INDEP_ANCHORS (RE_CHAR_CLASSES << 1) / If this bit is set, then special characters are always special regardless of where they are in the pattern. If this bit is not set, then special characters are special only in some contexts; otherwise they are ordinary. Specifically, * + ? and intervals are only special when not after the beginning, open-group, or alternation operator. / # define RE_CONTEXT_INDEP_OPS (RE_CONTEXT_INDEP_ANCHORS << 1) / If this bit is set, then , +, ?, and { cannot be first in an re or immediately after an alternation or begin-group operator. / # define RE_CONTEXT_INVALID_OPS (RE_CONTEXT_INDEP_OPS << 1) /* If this bit is set, then . matches newline. If not set, then it doesn't. / # define RE_DOT_NEWLINE (RE_CONTEXT_INVALID_OPS << 1) / If this bit is set, then . doesn't match NUL. If not set, then it does. / # define RE_DOT_NOT_NULL (RE_DOT_NEWLINE << 1) / If this bit is set, nonmatching lists [^...] do not match newline. If not set, they do. / # define RE_HAT_LISTS_NOT_NEWLINE (RE_DOT_NOT_NULL << 1) / If this bit is set, either \{...\} or {...} defines an interval, depending on RE_NO_BK_BRACES. If not set, \{, \}, {, and } are literals. / # define RE_INTERVALS (RE_HAT_LISTS_NOT_NEWLINE << 1) / If this bit is set, +, ? and \| aren't recognized as operators. If not set, they are. / # define RE_LIMITED_OPS (RE_INTERVALS << 1) / If this bit is set, newline is an alternation operator. If not set, newline is literal. / # define RE_NEWLINE_ALT (RE_LIMITED_OPS << 1) / If this bit is set, then '{...}' defines an interval, and \{ and \} are literals. If not set, then '\{...\}' defines an interval. / # define RE_NO_BK_BRACES (RE_NEWLINE_ALT << 1) / If this bit is set, (...) defines a group, and $ and $ are literals. If not set, $...$ defines a group, and ( and ) are literals. / # define RE_NO_BK_PARENS (RE_NO_BK_BRACES << 1) / If this bit is set, then \<digit> matches <digit>. If not set, then \<digit> is a back-reference. / # define RE_NO_BK_REFS (RE_NO_BK_PARENS << 1) / If this bit is set, then \| is an alternation operator, and \\| is literal. If not set, then \\| is an alternation operator, and \| is literal. / # define RE_NO_BK_VBAR (RE_NO_BK_REFS << 1) / If this bit is set, then an ending range point collating higher than the starting range point, as in [z-a], is invalid. If not set, then when ending range point collates higher than the starting range point, the range is ignored. / # define RE_NO_EMPTY_RANGES (RE_NO_BK_VBAR << 1) / If this bit is set, then an unmatched ) is ordinary. If not set, then an unmatched ) is invalid. / # define RE_UNMATCHED_RIGHT_PAREN_ORD (RE_NO_EMPTY_RANGES << 1) / If this bit is set, succeed as soon as we match the whole pattern, without further backtracking. / # define RE_NO_POSIX_BACKTRACKING (RE_UNMATCHED_RIGHT_PAREN_ORD << 1) / If this bit is set, do not process the GNU regex operators. If not set, then the GNU regex operators are recognized. / # define RE_NO_GNU_OPS (RE_NO_POSIX_BACKTRACKING << 1) / If this bit is set, turn on internal regex debugging. If not set, and debugging was on, turn it off. This only works if regex.c is compiled -DDEBUG. We define this bit always, so that all that's needed to turn on debugging is to recompile regex.c; the calling code can always have this bit set, and it won't affect anything in the normal case. / # define RE_DEBUG (RE_NO_GNU_OPS << 1) / If this bit is set, a syntactically invalid interval is treated as a string of ordinary characters. For example, the ERE 'a{1' is treated as 'a\{1'. / # define RE_INVALID_INTERVAL_ORD (RE_DEBUG << 1) / If this bit is set, then ignore case when matching. If not set, then case is significant. / # define RE_ICASE (RE_INVALID_INTERVAL_ORD << 1) / This bit is used internally like RE_CONTEXT_INDEP_ANCHORS but only for ^, because it is difficult to scan the regex backwards to find whether ^ should be special. / # define RE_CARET_ANCHORS_HERE (RE_ICASE << 1) / If this bit is set, then \{ cannot be first in a regex or immediately after an alternation, open-group or \} operator. / # define RE_CONTEXT_INVALID_DUP (RE_CARET_ANCHORS_HERE << 1) / If this bit is set, then no_sub will be set to 1 during re_compile_pattern. / # define RE_NO_SUB (RE_CONTEXT_INVALID_DUP << 1) #endif / This global variable defines the particular regexp syntax to use (for some interfaces). When a regexp is compiled, the syntax used is stored in the pattern buffer, so changing this does not affect already-compiled regexps. / extern reg_syntax_t re_syntax_options; #ifdef __USE_GNU / Define combinations of the above bits for the standard possibilities. (The [[[ comments delimit what gets put into the Texinfo file, so don't delete them!) / / [[[begin syntaxes]]] / # define RE_SYNTAX_EMACS 0 # define RE_SYNTAX_AWK \ (RE_BACKSLASH_ESCAPE_IN_LISTS \| RE_DOT_NOT_NULL \ \| RE_NO_BK_PARENS \| RE_NO_BK_REFS \ \| RE_NO_BK_VBAR \| RE_NO_EMPTY_RANGES \ \| RE_DOT_NEWLINE \| RE_CONTEXT_INDEP_ANCHORS \ \| RE_CHAR_CLASSES \ \| RE_UNMATCHED_RIGHT_PAREN_ORD \| RE_NO_GNU_OPS) # define RE_SYNTAX_GNU_AWK \ ((RE_SYNTAX_POSIX_EXTENDED \| RE_BACKSLASH_ESCAPE_IN_LISTS \ \| RE_INVALID_INTERVAL_ORD) \ & ~(RE_DOT_NOT_NULL \| RE_CONTEXT_INDEP_OPS \ \| RE_CONTEXT_INVALID_OPS )) # define RE_SYNTAX_POSIX_AWK \ (RE_SYNTAX_POSIX_EXTENDED \| RE_BACKSLASH_ESCAPE_IN_LISTS \ \| RE_INTERVALS \| RE_NO_GNU_OPS \ \| RE_INVALID_INTERVAL_ORD) # define RE_SYNTAX_GREP \ ((RE_SYNTAX_POSIX_BASIC \| RE_NEWLINE_ALT) \ & ~(RE_CONTEXT_INVALID_DUP \| RE_DOT_NOT_NULL)) # define RE_SYNTAX_EGREP \ ((RE_SYNTAX_POSIX_EXTENDED \| RE_INVALID_INTERVAL_ORD \| RE_NEWLINE_ALT) \ & ~(RE_CONTEXT_INVALID_OPS \| RE_DOT_NOT_NULL)) / POSIX grep -E behavior is no longer incompatible with GNU. / # define RE_SYNTAX_POSIX_EGREP \ RE_SYNTAX_EGREP / P1003.2/D11.2, section 4.20.7.1, lines 5078ff. / # define RE_SYNTAX_ED RE_SYNTAX_POSIX_BASIC # define RE_SYNTAX_SED RE_SYNTAX_POSIX_BASIC / Syntax bits common to both basic and extended POSIX regex syntax. / # define _RE_SYNTAX_POSIX_COMMON \ (RE_CHAR_CLASSES \| RE_DOT_NEWLINE \| RE_DOT_NOT_NULL \ \| RE_INTERVALS \| RE_NO_EMPTY_RANGES) # define RE_SYNTAX_POSIX_BASIC \ (_RE_SYNTAX_POSIX_COMMON \| RE_BK_PLUS_QM \| RE_CONTEXT_INVALID_DUP) / Differs from ..._POSIX_BASIC only in that RE_BK_PLUS_QM becomes RE_LIMITED_OPS, i.e., \? \+ \\| are not recognized. Actually, this isn't minimal, since other operators, such as \`, aren't disabled. / # define RE_SYNTAX_POSIX_MINIMAL_BASIC \ (_RE_SYNTAX_POSIX_COMMON \| RE_LIMITED_OPS) # define RE_SYNTAX_POSIX_EXTENDED \ (_RE_SYNTAX_POSIX_COMMON \| RE_CONTEXT_INDEP_ANCHORS \ \| RE_CONTEXT_INDEP_OPS \| RE_NO_BK_BRACES \ \| RE_NO_BK_PARENS \| RE_NO_BK_VBAR \ \| RE_CONTEXT_INVALID_OPS \| RE_UNMATCHED_RIGHT_PAREN_ORD) / Differs from ..._POSIX_EXTENDED in that RE_CONTEXT_INDEP_OPS is removed and RE_NO_BK_REFS is added. / # define RE_SYNTAX_POSIX_MINIMAL_EXTENDED \ (_RE_SYNTAX_POSIX_COMMON \| RE_CONTEXT_INDEP_ANCHORS \ \| RE_CONTEXT_INVALID_OPS \| RE_NO_BK_BRACES \ \| RE_NO_BK_PARENS \| RE_NO_BK_REFS \ \| RE_NO_BK_VBAR \| RE_UNMATCHED_RIGHT_PAREN_ORD) / [[[end syntaxes]]] / / Maximum number of duplicates an interval can allow. POSIX-conforming systems might define this in <limits.h>, but we want our value, so remove any previous define. / # ifdef _REGEX_INCLUDE_LIMITS_H # include <limits.h> # endif # ifdef RE_DUP_MAX # undef RE_DUP_MAX # endif / RE_DUP_MAX is 2*15 - 1 because an earlier implementation stored the counter as a 2-byte signed integer. This is no longer true, so RE_DUP_MAX could be increased to (INT_MAX / 10 - 1), or to ((SIZE_MAX - 9) / 10) if _REGEX_LARGE_OFFSETS is defined. However, there would be a huge performance problem if someone actually used a pattern like a\{214748363\}, so RE_DUP_MAX retains its historical value. / # define RE_DUP_MAX (0x7fff) #endif /* POSIX 'cflags' bits (i.e., information for 'regcomp'). / / If this bit is set, then use extended regular expression syntax. If not set, then use basic regular expression syntax. / #define REG_EXTENDED 1 / If this bit is set, then ignore case when matching. If not set, then case is significant. / #define REG_ICASE (1 << 1) / If this bit is set, then anchors do not match at newline characters in the string. If not set, then anchors do match at newlines. / #define REG_NEWLINE (1 << 2) / If this bit is set, then report only success or fail in regexec. If not set, then returns differ between not matching and errors. / #define REG_NOSUB (1 << 3) / POSIX 'eflags' bits (i.e., information for regexec). / / If this bit is set, then the beginning-of-line operator doesn't match the beginning of the string (presumably because it's not the beginning of a line). If not set, then the beginning-of-line operator does match the beginning of the string. / #define REG_NOTBOL 1 / Like REG_NOTBOL, except for the end-of-line. / #define REG_NOTEOL (1 << 1) / Use PMATCH[0] to delimit the start and end of the search in the buffer. / #define REG_STARTEND (1 << 2) / If any error codes are removed, changed, or added, update the '__re_error_msgid' table in regcomp.c. / typedef enum { _REG_ENOSYS = -1, / This will never happen for this implementation. / _REG_NOERROR = 0, / Success. / _REG_NOMATCH, / Didn't find a match (for regexec). / / POSIX regcomp return error codes. (In the order listed in the standard.) / _REG_BADPAT, / Invalid pattern. / _REG_ECOLLATE, / Invalid collating element. / _REG_ECTYPE, / Invalid character class name. / _REG_EESCAPE, / Trailing backslash. / _REG_ESUBREG, / Invalid back reference. / _REG_EBRACK, / Unmatched left bracket. / _REG_EPAREN, / Parenthesis imbalance. / _REG_EBRACE, / Unmatched \{. / _REG_BADBR, / Invalid contents of \{\}. / _REG_ERANGE, / Invalid range end. / _REG_ESPACE, / Ran out of memory. / _REG_BADRPT, / No preceding re for repetition op. / / Error codes we've added. / _REG_EEND, / Premature end. / _REG_ESIZE, / Too large (e.g., repeat count too large). / _REG_ERPAREN / Unmatched ) or \); not returned from regcomp. / } reg_errcode_t; #if defined _XOPEN_SOURCE \|\| defined __USE_XOPEN2K # define REG_ENOSYS _REG_ENOSYS #endif #define REG_NOERROR _REG_NOERROR #define REG_NOMATCH _REG_NOMATCH #define REG_BADPAT _REG_BADPAT #define REG_ECOLLATE _REG_ECOLLATE #define REG_ECTYPE _REG_ECTYPE #define REG_EESCAPE _REG_EESCAPE #define REG_ESUBREG _REG_ESUBREG #define REG_EBRACK _REG_EBRACK #define REG_EPAREN _REG_EPAREN #define REG_EBRACE _REG_EBRACE #define REG_BADBR _REG_BADBR #define REG_ERANGE _REG_ERANGE #define REG_ESPACE _REG_ESPACE #define REG_BADRPT _REG_BADRPT #define REG_EEND _REG_EEND #define REG_ESIZE _REG_ESIZE #define REG_ERPAREN _REG_ERPAREN / This data structure represents a compiled pattern. Before calling the pattern compiler, the fields 'buffer', 'allocated', 'fastmap', and 'translate' can be set. After the pattern has been compiled, the fields 're_nsub', 'not_bol' and 'not_eol' are available. All other fields are private to the regex routines. / #ifndef RE_TRANSLATE_TYPE # define __RE_TRANSLATE_TYPE unsigned char # ifdef __USE_GNU # define RE_TRANSLATE_TYPE __RE_TRANSLATE_TYPE # endif #endif #ifdef __USE_GNU # define __REPB_PREFIX(name) name #else # define __REPB_PREFIX(name) __##name #endif struct re_pattern_buffer { /* Space that holds the compiled pattern. The type 'struct re_dfa_t' is private and is not declared here. / struct re_dfa_t __REPB_PREFIX(buffer); /* Number of bytes to which 'buffer' points. / __re_long_size_t __REPB_PREFIX(allocated); / Number of bytes actually used in 'buffer'. / __re_long_size_t __REPB_PREFIX(used); / Syntax setting with which the pattern was compiled. / reg_syntax_t __REPB_PREFIX(syntax); / Pointer to a fastmap, if any, otherwise zero. re_search uses the fastmap, if there is one, to skip over impossible starting points for matches. / char __REPB_PREFIX(fastmap); /* Either a translate table to apply to all characters before comparing them, or zero for no translation. The translation is applied to a pattern when it is compiled and to a string when it is matched. / __RE_TRANSLATE_TYPE __REPB_PREFIX(translate); / Number of subexpressions found by the compiler. / size_t re_nsub; / Zero if this pattern cannot match the empty string, one else. Well, in truth it's used only in 're_search_2', to see whether or not we should use the fastmap, so we don't set this absolutely perfectly; see 're_compile_fastmap' (the "duplicate" case). / unsigned __REPB_PREFIX(can_be_null) : 1; / If REGS_UNALLOCATED, allocate space in the 'regs' structure for 'max (RE_NREGS, re_nsub + 1)' groups. If REGS_REALLOCATE, reallocate space if necessary. If REGS_FIXED, use what's there. / #ifdef __USE_GNU # define REGS_UNALLOCATED 0 # define REGS_REALLOCATE 1 # define REGS_FIXED 2 #endif unsigned __REPB_PREFIX(regs_allocated) : 2; / Set to zero when 're_compile_pattern' compiles a pattern; set to one by 're_compile_fastmap' if it updates the fastmap. / unsigned __REPB_PREFIX(fastmap_accurate) : 1; / If set, 're_match_2' does not return information about subexpressions. / unsigned __REPB_PREFIX(no_sub) : 1; / If set, a beginning-of-line anchor doesn't match at the beginning of the string. / unsigned __REPB_PREFIX(not_bol) : 1; / Similarly for an end-of-line anchor. / unsigned __REPB_PREFIX(not_eol) : 1; / If true, an anchor at a newline matches. / unsigned __REPB_PREFIX(newline_anchor) : 1; }; typedef struct re_pattern_buffer regex_t; / Type for byte offsets within the string. POSIX mandates this. / #ifdef _REGEX_LARGE_OFFSETS / POSIX 1003.1-2008 requires that regoff_t be at least as wide as ptrdiff_t and ssize_t. We don't know of any hosts where ptrdiff_t is wider than ssize_t, so ssize_t is safe. ptrdiff_t is not visible here, so use ssize_t. / typedef ssize_t regoff_t; #else / The traditional GNU regex implementation mishandles strings longer than INT_MAX. / typedef int regoff_t; #endif #ifdef __USE_GNU / This is the structure we store register match data in. See regex.texinfo for a full description of what registers match. / struct re_registers { __re_size_t num_regs; regoff_t start; regoff_t end; }; / If 'regs_allocated' is REGS_UNALLOCATED in the pattern buffer, 're_match_2' returns information about at least this many registers the first time a 'regs' structure is passed. / # ifndef RE_NREGS # define RE_NREGS 30 # endif #endif / POSIX specification for registers. Aside from the different names than 're_registers', POSIX uses an array of structures, instead of a structure of arrays. / typedef struct { regoff_t rm_so; / Byte offset from string's start to substring's start. / regoff_t rm_eo; / Byte offset from string's start to substring's end. / } regmatch_t; / Declarations for routines. / #ifndef _REGEX_NELTS # if (defined __STDC_VERSION__ && 199901L <= __STDC_VERSION__ \ && !defined __STDC_NO_VLA__) # define _REGEX_NELTS(n) n # else # define _REGEX_NELTS(n) # endif #endif #if defined __GNUC__ && 4 < __GNUC__ + (6 <= __GNUC_MINOR__) # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wvla" #endif #ifndef _Attr_access_ # ifdef __attr_access # define _Attr_access_(arg) __attr_access (arg) # elif defined __GNUC__ && 10 <= __GNUC__ # define _Attr_access_(x) __attribute__ ((__access__ x)) # else # define _Attr_access_(x) # endif #endif #ifdef __USE_GNU / Sets the current default syntax to SYNTAX, and return the old syntax. You can also simply assign to the 're_syntax_options' variable. / extern reg_syntax_t re_set_syntax (reg_syntax_t __syntax); / Compile the regular expression PATTERN, with length LENGTH and syntax given by the global 're_syntax_options', into the buffer BUFFER. Return NULL if successful, and an error string if not. To free the allocated storage, you must call 'regfree' on BUFFER. Note that the translate table must either have been initialized by 'regcomp', with a malloc'ed value, or set to NULL before calling 'regfree'. / extern const char re_compile_pattern (const char __pattern, size_t __length, struct re_pattern_buffer __buffer) _Attr_access_ ((__read_only__, 1, 2)); /* Compile a fastmap for the compiled pattern in BUFFER; used to accelerate searches. Return 0 if successful and -2 if was an internal error. / extern int re_compile_fastmap (struct re_pattern_buffer __buffer); /* Search in the string STRING (with length LENGTH) for the pattern compiled into BUFFER. Start searching at position START, for RANGE characters. Return the starting position of the match, -1 for no match, or -2 for an internal error. Also return register information in REGS (if REGS and BUFFER->no_sub are nonzero). / extern regoff_t re_search (struct re_pattern_buffer __buffer, const char __String, regoff_t __length, regoff_t __start, regoff_t __range, struct re_registers __regs) _Attr_access_ ((__read_only__, 2, 3)); /* Like 're_search', but search in the concatenation of STRING1 and STRING2. Also, stop searching at index START + STOP. / extern regoff_t re_search_2 (struct re_pattern_buffer __buffer, const char __string1, regoff_t __length1, const char __string2, regoff_t __length2, regoff_t __start, regoff_t __range, struct re_registers __regs, regoff_t __stop) _Attr_access_ ((__read_only__, 2, 3)) _Attr_access_ ((__read_only__, 4, 5)); / Like 're_search', but return how many characters in STRING the regexp in BUFFER matched, starting at position START. / extern regoff_t re_match (struct re_pattern_buffer __buffer, const char __String, regoff_t __length, regoff_t __start, struct re_registers __regs) _Attr_access_ ((__read_only__, 2, 3)); /* Relates to 're_match' as 're_search_2' relates to 're_search'. / extern regoff_t re_match_2 (struct re_pattern_buffer __buffer, const char __string1, regoff_t __length1, const char __string2, regoff_t __length2, regoff_t __start, struct re_registers __regs, regoff_t __stop) _Attr_access_ ((__read_only__, 2, 3)) _Attr_access_ ((__read_only__, 4, 5)); / Set REGS to hold NUM_REGS registers, storing them in STARTS and ENDS. Subsequent matches using BUFFER and REGS will use this memory for recording register information. STARTS and ENDS must be allocated with malloc, and must each be at least 'NUM_REGS * sizeof (regoff_t)' bytes long. If NUM_REGS == 0, then subsequent matches should allocate their own register data. Unless this function is called, the first search or match using BUFFER will allocate its own register data, without freeing the old data. / extern void re_set_registers (struct re_pattern_buffer __buffer, struct re_registers __regs, __re_size_t __num_regs, regoff_t __starts, regoff_t __ends); #endif / Use GNU / #if defined _REGEX_RE_COMP \|\| (defined _LIBC && defined __USE_MISC) / 4.2 bsd compatibility. / extern char re_comp (const char ); extern int re_exec (const char ); #endif /* For plain 'restrict', use glibc's __restrict if defined. Otherwise, GCC 2.95 and later have "__restrict"; C99 compilers have "restrict", and "configure" may have defined "restrict". Other compilers use __restrict, __restrict__, and _Restrict, and 'configure' might #define 'restrict' to those words, so pick a different name. / #ifndef _Restrict_ # if defined __restrict \ \|\| 2 < __GNUC__ + (95 <= __GNUC_MINOR__) \ \|\| __clang_major__ >= 3 # define _Restrict_ __restrict # elif 199901L <= __STDC_VERSION__ \|\| defined restrict # define _Restrict_ restrict # else # define _Restrict_ # endif #endif / For the ISO C99 syntax array_name[restrict] use glibc's __restrict_arr if available. Otherwise, GCC 3.1 and clang support this syntax (but not in C++ mode). Other ISO C99 compilers support it as well. / #ifndef _Restrict_arr_ # ifdef __restrict_arr # define _Restrict_arr_ __restrict_arr # elif ((199901L <= __STDC_VERSION__ \ \|\| 3 < __GNUC__ + (1 <= __GNUC_MINOR__) \ \|\| __clang_major__ >= 3) \ && !defined __cplusplus) # define _Restrict_arr_ _Restrict_ # else # define _Restrict_arr_ # endif #endif / POSIX compatibility. / extern int regcomp (regex_t _Restrict_ __preg, const char _Restrict_ __pattern, int __cflags); extern int regexec (const regex_t _Restrict_ __preg, const char _Restrict_ __String, size_t __nmatch, regmatch_t __pmatch[_Restrict_arr_ _REGEX_NELTS (__nmatch)], int __eflags); extern size_t regerror (int __errcode, const regex_t _Restrict_ __preg, char _Restrict_ __errbuf, size_t __errbuf_size) _Attr_access_ ((__write_only__, 3, 4)); extern void regfree (regex_t __preg); #if defined __GNUC__ && 4 < __GNUC__ + (6 <= __GNUC_MINOR__) # pragma GCC diagnostic pop #endif #ifdef __cplusplus } #endif /* C++ / #endif / regex.h */	25.3 KB	2026-02-17 11:01
📄 regexp.h /* Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _REGEXP_H #define _REGEXP_H 1 / The contents of this header file were originally standardized in the Single Unix Specification, Issue 3 (1992). In Issue 4 (1994) the header was marked as TO BE WITHDRAWN, and new applications were encouraged to use <regex.h> instead. It was officially withdrawn from the standard in Issue 6 (aka POSIX.1-2001). The GNU C Library provided this header through version 2.22. / #error "The GNU C Library no longer implements <regexp.h>." #error "Please update your code to use <regex.h> instead (no trailing 'p')." #endif / regexp.h */	1.41 KB	2026-02-17 11:01
📄 resolv.h /* * Copyright (c) 1983, 1987, 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. * 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) 1996-1999 by Internet Software Consortium. * * 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 INTERNET SOFTWARE CONSORTIUM DISCLAIMS * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE * CONSORTIUM 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. / / * @(#)resolv.h 8.1 (Berkeley) 6/2/93 * $BINDId: resolv.h,v 8.31 2000/03/30 20:16:50 vixie Exp $ / #ifndef _RESOLV_H_ #define _RESOLV_H_ #include <sys/cdefs.h> #include <sys/param.h> #include <sys/types.h> #include <stdio.h> #include <netinet/in.h> #include <arpa/nameser.h> #include <bits/types/res_state.h> / * Global defines and variables for resolver stub. / #define LOCALDOMAINPARTS 2 / min levels in name that is "local" / #define RES_TIMEOUT 5 / min. seconds between retries / #define RES_MAXNDOTS 15 / should reflect bit field size / #define RES_MAXRETRANS 30 / only for resolv.conf/RES_OPTIONS / #define RES_MAXRETRY 5 / only for resolv.conf/RES_OPTIONS / #define RES_DFLRETRY 2 / Default #/tries. / #define RES_MAXTIME 65535 / Infinity, in milliseconds. / #define nsaddr nsaddr_list[0] / for backward compatibility / / * 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 (__RES > 19931104)". Do not * compare for equality; rather, use it to determine whether your resolver * is new enough to contain a certain feature. / #define __RES 19991006 / * Resolver configuration file. * Normally not present, but may contain the address of the * inital name server(s) to query and the domain search list. / #ifndef _PATH_RESCONF #define _PATH_RESCONF "/etc/resolv.conf" #endif struct res_sym { int number; / Identifying number, like T_MX / char name; /* Its symbolic name, like "MX" / char humanname; /* Its fun name, like "mail exchanger" / }; / * Resolver options (keep these in synch with res_debug.c, please) / #define RES_INIT 0x00000001 / address initialized / #define RES_DEBUG 0x00000002 / print debug messages / #define RES_AAONLY \ __glibc_macro_warning ("RES_AAONLY is deprecated") 0x00000004 #define RES_USEVC 0x00000008 / use virtual circuit / #define RES_PRIMARY \ __glibc_macro_warning ("RES_PRIMARY is deprecated") 0x00000010 #define RES_IGNTC 0x00000020 / ignore trucation errors / #define RES_RECURSE 0x00000040 / recursion desired / #define RES_DEFNAMES 0x00000080 / use default domain name / #define RES_STAYOPEN 0x00000100 / Keep TCP socket open / #define RES_DNSRCH 0x00000200 / search up local domain tree / #define RES_NOALIASES 0x00001000 / shuts off HOSTALIASES feature / #define RES_ROTATE 0x00004000 / rotate ns list after each query / #define RES_NOCHECKNAME \ __glibc_macro_warning ("RES_NOCHECKNAME is deprecated") 0x00008000 #define RES_KEEPTSIG \ __glibc_macro_warning ("RES_KEEPTSIG is deprecated") 0x00010000 #define RES_BLAST \ __glibc_macro_warning ("RES_BLAST is deprecated") 0x00020000 #define RES_USE_EDNS0 0x00100000 / Use EDNS0. / #define RES_SNGLKUP 0x00200000 / one outstanding request at a time / #define RES_SNGLKUPREOP 0x00400000 / -"-, but open new socket for each request / #define RES_USE_DNSSEC 0x00800000 / use DNSSEC using OK bit in OPT / #define RES_NOTLDQUERY 0x01000000 / Do not look up unqualified name as a TLD. / #define RES_NORELOAD 0x02000000 / No automatic configuration reload. / #define RES_TRUSTAD 0x04000000 / Request AD bit, keep it in responses. / #define RES_NOAAAA 0x08000000 / Suppress AAAA queries. / #define RES_STRICTERR 0x10000000 / Report more DNS errors as errors. / #define RES_DEFAULT (RES_RECURSE\|RES_DEFNAMES\|RES_DNSRCH) / * Resolver "pfcode" values. Used by dig. / #define RES_PRF_STATS 0x00000001 #define RES_PRF_UPDATE 0x00000002 #define RES_PRF_CLASS 0x00000004 #define RES_PRF_CMD 0x00000008 #define RES_PRF_QUES 0x00000010 #define RES_PRF_ANS 0x00000020 #define RES_PRF_AUTH 0x00000040 #define RES_PRF_ADD 0x00000080 #define RES_PRF_HEAD1 0x00000100 #define RES_PRF_HEAD2 0x00000200 #define RES_PRF_TTLID 0x00000400 #define RES_PRF_HEADX 0x00000800 #define RES_PRF_QUERY 0x00001000 #define RES_PRF_REPLY 0x00002000 #define RES_PRF_INIT 0x00004000 / 0x00008000 / / Things involving an internal (static) resolver context. / __BEGIN_DECLS extern struct __res_state __res_state(void) __attribute__ ((__const__)); __END_DECLS #define _res (__res_state()) #define fp_nquery __fp_nquery #define fp_query __fp_query #define hostalias __hostalias #define p_query __p_query #define res_close __res_close #define res_init __res_init #define res_isourserver __res_isourserver #ifdef _LIBC # define __RESOLV_DEPRECATED # define __RESOLV_DEPRECATED_MSG(msg) #else # define __RESOLV_DEPRECATED __attribute_deprecated__ # define __RESOLV_DEPRECATED_MSG(msg) __attribute_deprecated_msg__ (msg) #endif __BEGIN_DECLS void fp_nquery (const unsigned char , int, FILE ) __THROW __RESOLV_DEPRECATED; void fp_query (const unsigned char , FILE ) __THROW __RESOLV_DEPRECATED; const char hostalias (const char ) __THROW __RESOLV_DEPRECATED_MSG ("use getaddrinfo instead"); void p_query (const unsigned char ) __THROW __RESOLV_DEPRECATED; void res_close (void) __THROW; int res_init (void) __THROW; int res_isourserver (const struct sockaddr_in ) __THROW __RESOLV_DEPRECATED; int res_mkquery (int, const char , int, int, const unsigned char , int, const unsigned char , unsigned char , int) __THROW; int res_query (const char , int, int, unsigned char , int) __THROW; int res_querydomain (const char , const char , int, int, unsigned char , int) __THROW; int res_search (const char , int, int, unsigned char , int) __THROW; int res_send (const unsigned char , int, unsigned char , int) __THROW; __END_DECLS #define b64_ntop __b64_ntop #define b64_pton __b64_pton #define dn_count_labels __dn_count_labels #define fp_resstat __fp_resstat #define loc_aton __loc_aton #define loc_ntoa __loc_ntoa #define p_cdname __p_cdname #define p_cdnname __p_cdnname #define p_class __p_class #define p_fqname __p_fqname #define p_fqnname __p_fqnname #define p_option __p_option #define p_time __p_time #define p_type __p_type #define p_rcode __p_rcode #define putlong __putlong #define putshort __putshort #define res_hostalias __res_hostalias #define res_nameinquery __res_nameinquery #define res_nclose __res_nclose #define res_ninit __res_ninit #define res_queriesmatch __res_queriesmatch #define res_randomid __res_randomid #define sym_ntop __sym_ntop #define sym_ntos __sym_ntos #define sym_ston __sym_ston __BEGIN_DECLS int res_hnok (const char ) __THROW; int res_ownok (const char ) __THROW; int res_mailok (const char ) __THROW; int res_dnok (const char ) __THROW; int sym_ston (const struct res_sym , const char , int ) __THROW __RESOLV_DEPRECATED; const char sym_ntos (const struct res_sym , int, int ) __THROW __RESOLV_DEPRECATED; const char * sym_ntop (const struct res_sym , int, int ) __THROW __RESOLV_DEPRECATED; int b64_ntop (const unsigned char , size_t, char , size_t) __THROW; int b64_pton (char const , unsigned char , size_t) __THROW; int loc_aton (const char __ascii, unsigned char __binary) __THROW __RESOLV_DEPRECATED; const char * loc_ntoa (const unsigned char __binary, char __ascii) __THROW __RESOLV_DEPRECATED; int dn_skipname (const unsigned char , const unsigned char ) __THROW; void putlong (uint32_t, unsigned char ) __THROW __RESOLV_DEPRECATED_MSG ("use NS_PUT16 instead"); void putshort (uint16_t, unsigned char ) __THROW __RESOLV_DEPRECATED_MSG ("use NS_PUT32 instead"); const char * p_class (int) __THROW __RESOLV_DEPRECATED; const char * p_time (uint32_t) __THROW __RESOLV_DEPRECATED; const char * p_type (int) __THROW __RESOLV_DEPRECATED; const char * p_rcode (int) __THROW __RESOLV_DEPRECATED; const unsigned char * p_cdnname (const unsigned char , const unsigned char , int, FILE ) __THROW __RESOLV_DEPRECATED; const unsigned char p_cdname (const unsigned char , const unsigned char , FILE ) __THROW __RESOLV_DEPRECATED; const unsigned char p_fqnname (const unsigned char __cp, const unsigned char __msg, int, char , int) __THROW __RESOLV_DEPRECATED; const unsigned char p_fqname (const unsigned char , const unsigned char , FILE ) __THROW __RESOLV_DEPRECATED; const char p_option (unsigned long __option) __THROW __RESOLV_DEPRECATED; int dn_count_labels (const char ) __THROW __RESOLV_DEPRECATED; int dn_comp (const char , unsigned char , int, unsigned char , unsigned char ) __THROW; int dn_expand (const unsigned char , const unsigned char , const unsigned char , char , int) __THROW; unsigned int res_randomid (void) __THROW __RESOLV_DEPRECATED_MSG ("use getentropy instead"); int res_nameinquery (const char , int, int, const unsigned char , const unsigned char ) __THROW __RESOLV_DEPRECATED; int res_queriesmatch (const unsigned char , const unsigned char , const unsigned char , const unsigned char ) __THROW __RESOLV_DEPRECATED; /* Things involving a resolver context. / int res_ninit (res_state) __THROW; void fp_resstat (const res_state, FILE ) __THROW __RESOLV_DEPRECATED; const char * res_hostalias (const res_state, const char , char , size_t) __THROW __RESOLV_DEPRECATED_MSG ("use getaddrinfo instead"); int res_nquery (res_state, const char , int, int, unsigned char , int) __THROW; int res_nsearch (res_state, const char , int, int, unsigned char , int) __THROW; int res_nquerydomain (res_state, const char , const char , int, int, unsigned char , int) __THROW; int res_nmkquery (res_state, int, const char , int, int, const unsigned char , int, const unsigned char , unsigned char , int) __THROW; int res_nsend (res_state, const unsigned char , int, unsigned char , int) __THROW; void res_nclose (res_state) __THROW; __END_DECLS #endif / !_RESOLV_H_ */	12.1 KB	2026-02-17 11:02
📁 rpc	-	2026-03-21 15:44
📁 sasl	-	2026-03-31 19:08
📄 sched.h /* Definitions for POSIX 1003.1b-1993 (aka POSIX.4) scheduling interface. Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _SCHED_H #define _SCHED_H 1 #include <features.h> / Get type definitions. / #include <bits/types.h> #define __need_size_t #define __need_NULL #include <stddef.h> #include <bits/types/time_t.h> #include <bits/types/struct_timespec.h> #ifndef __USE_XOPEN2K # include <time.h> #endif #ifndef __pid_t_defined typedef __pid_t pid_t; # define __pid_t_defined #endif / Get system specific constant and data structure definitions. / #include <bits/sched.h> #include <bits/cpu-set.h> / Backward compatibility. / #define sched_priority sched_priority #define __sched_priority sched_priority __BEGIN_DECLS / Set scheduling parameters for a process. / extern int sched_setparam (__pid_t __pid, const struct sched_param __param) __THROW; /* Retrieve scheduling parameters for a particular process. / extern int sched_getparam (__pid_t __pid, struct sched_param __param) __THROW; /* Set scheduling algorithm and/or parameters for a process. / extern int sched_setscheduler (__pid_t __pid, int __policy, const struct sched_param __param) __THROW; /* Retrieve scheduling algorithm for a particular purpose. / extern int sched_getscheduler (__pid_t __pid) __THROW; / Yield the processor. / extern int sched_yield (void) __THROW; / Get maximum priority value for a scheduler. / extern int sched_get_priority_max (int __algorithm) __THROW; / Get minimum priority value for a scheduler. / extern int sched_get_priority_min (int __algorithm) __THROW; / Get the SCHED_RR interval for the named process. / #ifndef __USE_TIME_BITS64 extern int sched_rr_get_interval (__pid_t __pid, struct timespec __t) __THROW; #else # ifdef __REDIRECT_NTH extern int __REDIRECT_NTH (sched_rr_get_interval, (__pid_t __pid, struct timespec __t), __sched_rr_get_interval64); # else # define sched_rr_get_interval __sched_rr_get_interval64 # endif #endif #ifdef __USE_GNU / Access macros for `cpu_set'. / # define CPU_SETSIZE __CPU_SETSIZE # define CPU_SET(cpu, cpusetp) __CPU_SET_S (cpu, sizeof (cpu_set_t), cpusetp) # define CPU_CLR(cpu, cpusetp) __CPU_CLR_S (cpu, sizeof (cpu_set_t), cpusetp) # define CPU_ISSET(cpu, cpusetp) __CPU_ISSET_S (cpu, sizeof (cpu_set_t), \ cpusetp) # define CPU_ZERO(cpusetp) __CPU_ZERO_S (sizeof (cpu_set_t), cpusetp) # define CPU_COUNT(cpusetp) __CPU_COUNT_S (sizeof (cpu_set_t), cpusetp) # define CPU_SET_S(cpu, setsize, cpusetp) __CPU_SET_S (cpu, setsize, cpusetp) # define CPU_CLR_S(cpu, setsize, cpusetp) __CPU_CLR_S (cpu, setsize, cpusetp) # define CPU_ISSET_S(cpu, setsize, cpusetp) __CPU_ISSET_S (cpu, setsize, \ cpusetp) # define CPU_ZERO_S(setsize, cpusetp) __CPU_ZERO_S (setsize, cpusetp) # define CPU_COUNT_S(setsize, cpusetp) __CPU_COUNT_S (setsize, cpusetp) # define CPU_EQUAL(cpusetp1, cpusetp2) \ __CPU_EQUAL_S (sizeof (cpu_set_t), cpusetp1, cpusetp2) # define CPU_EQUAL_S(setsize, cpusetp1, cpusetp2) \ __CPU_EQUAL_S (setsize, cpusetp1, cpusetp2) # define CPU_AND(destset, srcset1, srcset2) \ __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, &) # define CPU_OR(destset, srcset1, srcset2) \ __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, \|) # define CPU_XOR(destset, srcset1, srcset2) \ __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, ^) # define CPU_AND_S(setsize, destset, srcset1, srcset2) \ __CPU_OP_S (setsize, destset, srcset1, srcset2, &) # define CPU_OR_S(setsize, destset, srcset1, srcset2) \ __CPU_OP_S (setsize, destset, srcset1, srcset2, \|) # define CPU_XOR_S(setsize, destset, srcset1, srcset2) \ __CPU_OP_S (setsize, destset, srcset1, srcset2, ^) # define CPU_ALLOC_SIZE(count) __CPU_ALLOC_SIZE (count) # define CPU_ALLOC(count) __CPU_ALLOC (count) # define CPU_FREE(cpuset) __CPU_FREE (cpuset) / Set the CPU affinity for a task / extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize, const cpu_set_t __cpuset) __THROW; /* Get the CPU affinity for a task / extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize, cpu_set_t __cpuset) __THROW; #endif __END_DECLS #endif /* sched.h */	4.92 KB	2026-02-17 11:01
📁 scsi	-	2026-03-27 02:43
📄 search.h /* Declarations for System V style searching functions. Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _SEARCH_H #define _SEARCH_H 1 #include <features.h> #define __need_size_t #include <stddef.h> __BEGIN_DECLS #if defined __USE_MISC \|\| defined __USE_XOPEN_EXTENDED / Prototype structure for a linked-list data structure. This is the type used by the `insque' and `remque' functions. / # ifdef __USE_GNU struct qelem { struct qelem q_forw; struct qelem q_back; char q_data[1]; }; # endif / Insert ELEM into a doubly-linked list, after PREV. / extern void insque (void __elem, void __prev) __THROW; / Unlink ELEM from the doubly-linked list that it is in. / extern void remque (void __elem) __THROW; #endif /* For use with hsearch(3). / #ifndef __COMPAR_FN_T # define __COMPAR_FN_T typedef int (__compar_fn_t) (const void , const void ); # ifdef __USE_GNU typedef __compar_fn_t comparison_fn_t; # endif #endif /* Action which shall be performed in the call the hsearch. / typedef enum { FIND, ENTER } ACTION; typedef struct entry { char key; void data; } ENTRY; / Opaque type for internal use. / struct _ENTRY; / Family of hash table handling functions. The functions also have reentrant counterparts ending with _r. The non-reentrant functions all work on a signle internal hashing table. / / Search for entry matching ITEM.key in internal hash table. If ACTION is `FIND' return found entry or signal error by returning NULL. If ACTION is `ENTER' replace existing data (if any) with ITEM.data. / extern ENTRY hsearch (ENTRY __item, ACTION __action) __THROW; /* Create a new hashing table which will at most contain NEL elements. / extern int hcreate (size_t __nel) __THROW; / Destroy current internal hashing table. / extern void hdestroy (void) __THROW; #ifdef __USE_GNU / Data type for reentrant functions. / struct hsearch_data { struct _ENTRY table; unsigned int size; unsigned int filled; }; /* Reentrant versions which can handle multiple hashing tables at the same time. / extern int hsearch_r (ENTRY __item, ACTION __action, ENTRY __retval, struct hsearch_data __htab) __THROW; extern int hcreate_r (size_t __nel, struct hsearch_data __htab) __THROW; extern void hdestroy_r (struct hsearch_data __htab) __THROW; #endif /* The tsearch routines are very interesting. They make many assumptions about the compiler. It assumes that the first field in node must be the "key" field, which points to the datum. Everything depends on that. / / For tsearch / typedef enum { preorder, postorder, endorder, leaf } VISIT; / Search for an entry matching the given KEY in the tree pointed to by ROOTP and insert a new element if not found. / extern void tsearch (const void __key, void *__rootp, __compar_fn_t __compar); / Search for an entry matching the given KEY in the tree pointed to by ROOTP. If no matching entry is available return NULL. / extern void tfind (const void __key, void const __rootp, __compar_fn_t __compar); /* Remove the element matching KEY from the tree pointed to by ROOTP. / extern void tdelete (const void __restrict __key, void *__restrict __rootp, __compar_fn_t __compar); #ifndef __ACTION_FN_T # define __ACTION_FN_T typedef void (__action_fn_t) (const void __nodep, VISIT __value, int __level); #endif / Walk through the whole tree and call the ACTION callback for every node or leaf. / extern void twalk (const void __root, __action_fn_t __action); #ifdef __USE_GNU /* Like twalk, but pass down a closure parameter instead of the level. / extern void twalk_r (const void __root, void () (const void __nodep, VISIT __value, void __closure), void __closure); /* Callback type for function to free a tree node. If the keys are atomic data this function should do nothing. / typedef void (__free_fn_t) (void __nodep); / Destroy the whole tree, call FREEFCT for each node or leaf. / extern void tdestroy (void __root, __free_fn_t __freefct); #endif /* Perform linear search for KEY by comparing by COMPAR in an array [BASE,BASE+NMEMBSIZE). / extern void lfind (const void __key, const void __base, size_t __nmemb, size_t __size, __compar_fn_t __compar); /* Perform linear search for KEY by comparing by COMPAR function in array [BASE,BASE+NMEMBSIZE) and insert entry if not found. / extern void lsearch (const void __key, void __base, size_t __nmemb, size_t __size, __compar_fn_t __compar); __END_DECLS #endif /* search.h */	5.32 KB	2026-02-17 11:01
📁 selinux	-	2026-03-21 15:44
📄 semaphore.h /* Copyright (C) 2002-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _SEMAPHORE_H #define _SEMAPHORE_H 1 #include <features.h> #include <sys/types.h> #ifdef __USE_XOPEN2K # include <bits/types/struct_timespec.h> #endif / Get the definition for sem_t. / #include <bits/semaphore.h> __BEGIN_DECLS / Initialize semaphore object SEM to VALUE. If PSHARED then share it with other processes. / extern int sem_init (sem_t __sem, int __pshared, unsigned int __value) __THROW __nonnull ((1)); /* Free resources associated with semaphore object SEM. / extern int sem_destroy (sem_t __sem) __THROW __nonnull ((1)); /* Open a named semaphore NAME with open flags OFLAG. / extern sem_t sem_open (const char __name, int __oflag, ...) __THROW __nonnull ((1)); / Close descriptor for named semaphore SEM. / extern int sem_close (sem_t __sem) __THROW __nonnull ((1)); /* Remove named semaphore NAME. / extern int sem_unlink (const char __name) __THROW __nonnull ((1)); /* Wait for SEM being posted. This function is a cancellation point and therefore not marked with __THROW. / extern int sem_wait (sem_t __sem) __nonnull ((1)); #ifdef __USE_XOPEN2K /* Similar to `sem_wait' but wait only until ABSTIME. This function is a cancellation point and therefore not marked with __THROW. / # ifndef __USE_TIME_BITS64 extern int sem_timedwait (sem_t __restrict __sem, const struct timespec __restrict __abstime) __nonnull ((1, 2)); # else # ifdef __REDIRECT extern int __REDIRECT (sem_timedwait, (sem_t __restrict __sem, const struct timespec __restrict __abstime), __sem_timedwait64) __nonnull ((1, 2)); # else # define sem_timedwait __sem_timedwait64 # endif # endif #endif #ifdef __USE_GNU # ifndef __USE_TIME_BITS64 extern int sem_clockwait (sem_t __restrict __sem, clockid_t clock, const struct timespec __restrict __abstime) __nonnull ((1, 3)); # else # ifdef __REDIRECT extern int __REDIRECT (sem_clockwait, (sem_t __restrict __sem, clockid_t clock, const struct timespec __restrict __abstime), __sem_clockwait64) __nonnull ((1, 3)); # else # define sem_clockwait __sem_clockwait64 # endif # endif #endif / Test whether SEM is posted. / extern int sem_trywait (sem_t __sem) __THROWNL __nonnull ((1)); /* Post SEM. / extern int sem_post (sem_t __sem) __THROWNL __nonnull ((1)); /* Get current value of SEM and store it in SVAL. / extern int sem_getvalue (sem_t __restrict __sem, int __restrict __sval) __THROW __nonnull ((1, 2)); __END_DECLS #endif /* semaphore.h */	3.38 KB	2026-02-17 11:01
📁 sepol	-	2026-03-21 15:44
📄 setjmp.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99 Standard: 7.13 Nonlocal jumps <setjmp.h> / #ifndef _SETJMP_H #define _SETJMP_H 1 #include <features.h> __BEGIN_DECLS #include <bits/setjmp.h> / Get `__jmp_buf'. / #include <bits/types/struct___jmp_buf_tag.h> typedef struct __jmp_buf_tag jmp_buf[1]; / Store the calling environment in ENV, also saving the signal mask. Return 0. / extern int setjmp (jmp_buf __env) __THROWNL; / Store the calling environment in ENV, also saving the signal mask if SAVEMASK is nonzero. Return 0. This is the internal name for `sigsetjmp'. / extern int __sigsetjmp (struct __jmp_buf_tag __env[1], int __savemask) __THROWNL; / Store the calling environment in ENV, not saving the signal mask. Return 0. / extern int _setjmp (struct __jmp_buf_tag __env[1]) __THROWNL; / Do not save the signal mask. This is equivalent to the `_setjmp' BSD function. / #define setjmp(env) _setjmp (env) / Jump to the environment saved in ENV, making the `setjmp' call there return VAL, or 1 if VAL is 0. / extern void longjmp (struct __jmp_buf_tag __env[1], int __val) __THROWNL __attribute__ ((__noreturn__)); #if defined __USE_MISC \|\| defined __USE_XOPEN / Same. Usually `_longjmp' is used with `_setjmp', which does not save the signal mask. But it is how ENV was saved that determines whether `longjmp' restores the mask; `_longjmp' is just an alias. / extern void _longjmp (struct __jmp_buf_tag __env[1], int __val) __THROWNL __attribute__ ((__noreturn__)); #endif #ifdef __USE_POSIX / Use the same type for `jmp_buf' and `sigjmp_buf'. The `__mask_was_saved' flag determines whether or not `longjmp' will restore the signal mask. / typedef struct __jmp_buf_tag sigjmp_buf[1]; / Store the calling environment in ENV, also saving the signal mask if SAVEMASK is nonzero. Return 0. / # define sigsetjmp(env, savemask) __sigsetjmp (env, savemask) / Jump to the environment saved in ENV, making the sigsetjmp call there return VAL, or 1 if VAL is 0. Restore the signal mask if that sigsetjmp call saved it. This is just an alias `longjmp'. / extern void siglongjmp (sigjmp_buf __env, int __val) __THROWNL __attribute__ ((__noreturn__)); #endif / Use POSIX. / / Define helper functions to catch unsafe code. / #if __USE_FORTIFY_LEVEL > 0 # include <bits/setjmp2.h> #endif __END_DECLS #endif / setjmp.h */	3.12 KB	2026-02-17 11:01
📄 sgtty.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _SGTTY_H #define _SGTTY_H 1 #include <features.h> #include <sys/ioctl.h> / On some systems this type is not defined by <bits/ioctl-types.h>; in that case, the functions are just stubs that return ENOSYS. / struct sgttyb; __BEGIN_DECLS / Fill in PARAMS with terminal parameters associated with FD. / extern int gtty (int __fd, struct sgttyb __params) __THROW; / Set the terminal parameters associated with FD to PARAMS. / extern int stty (int __fd, const struct sgttyb __params) __THROW; __END_DECLS #endif / sgtty.h */	1.31 KB	2026-02-17 11:01
📄 shadow.h /* Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / Declaration of types and functions for "shadow" storage of hashed passphrases. The shadow database is like the user database, but is only accessible with special privileges, so that malicious users cannot retrieve everyone else's hashed passphrase to brute-force at their convenience. / #ifndef _SHADOW_H #define _SHADOW_H 1 #include <features.h> #include <paths.h> #define __need_size_t #include <stddef.h> #include <bits/types/FILE.h> / Paths to the user database files. / #define SHADOW _PATH_SHADOW __BEGIN_DECLS / A record in the shadow database. / struct spwd { char sp_namp; /* Login name. / char sp_pwdp; /* Hashed passphrase. / long int sp_lstchg; / Date of last change. / long int sp_min; / Minimum number of days between changes. / long int sp_max; / Maximum number of days between changes. / long int sp_warn; / Number of days to warn user to change the password. / long int sp_inact; / Number of days the account may be inactive. / long int sp_expire; / Number of days since 1970-01-01 until account expires. / unsigned long int sp_flag; / Reserved. / }; / Open database for reading. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern void setspent (void); / Close database. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern void endspent (void); / Get next entry from database, perhaps after opening the file. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern struct spwd getspent (void); /* Get shadow entry matching NAME. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern struct spwd getspnam (const char __name); / Read shadow entry from STRING. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern struct spwd sgetspent (const char __string); / Read next shadow entry from STREAM. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern struct spwd fgetspent (FILE __stream); / Write line containing shadow entry to stream. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int putspent (const struct spwd __p, FILE __stream); #ifdef __USE_MISC / Reentrant versions of some of the functions above. These functions are not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation they are cancellation points and therefore not marked with __THROW. / extern int getspent_r (struct spwd __result_buf, char __buffer, size_t __buflen, struct spwd __result); extern int getspnam_r (const char __name, struct spwd __result_buf, char __buffer, size_t __buflen, struct spwd *__result); extern int sgetspent_r (const char __string, struct spwd __result_buf, char __buffer, size_t __buflen, struct spwd *__result); extern int fgetspent_r (FILE __stream, struct spwd __result_buf, char __buffer, size_t __buflen, struct spwd *__result); #endif / misc / / The simple locking functionality provided here is not suitable for multi-threaded applications. / / Request exclusive access to /etc/passwd and /etc/shadow. / extern int lckpwdf (void) __THROW; / Release exclusive access to /etc/passwd and /etc/shadow. / extern int ulckpwdf (void) __THROW; __END_DECLS #endif / shadow.h */	5.34 KB	2026-02-17 11:02
📄 signal.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99 Standard: 7.14 Signal handling <signal.h> / #ifndef _SIGNAL_H #define _SIGNAL_H #include <features.h> __BEGIN_DECLS #include <bits/types.h> #include <bits/signum-generic.h> #include <bits/types/sig_atomic_t.h> #if defined __USE_POSIX #include <bits/types/sigset_t.h> #endif #if defined __USE_XOPEN \|\| defined __USE_XOPEN2K # ifndef __pid_t_defined typedef __pid_t pid_t; # define __pid_t_defined #endif #ifdef __USE_XOPEN # endif # ifndef __uid_t_defined typedef __uid_t uid_t; # define __uid_t_defined # endif #endif / Unix98 / #ifdef __USE_POSIX199309 / We need `struct timespec' later on. / # include <bits/types/struct_timespec.h> #endif #if defined __USE_POSIX199309 \|\| defined __USE_XOPEN_EXTENDED # include <bits/types/siginfo_t.h> # include <bits/siginfo-consts.h> #endif #ifdef __USE_MISC # include <bits/types/sigval_t.h> #endif #ifdef __USE_POSIX199309 # include <bits/types/sigevent_t.h> # include <bits/sigevent-consts.h> #endif / Type of a signal handler. / typedef void (__sighandler_t) (int); /* The X/Open definition of `signal' specifies the SVID semantic. Use the additional function `sysv_signal' when X/Open compatibility is requested. / extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler) __THROW; #ifdef __USE_GNU extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler) __THROW; #endif / Set the handler for the signal SIG to HANDLER, returning the old handler, or SIG_ERR on error. By default `signal' has the BSD semantic. / #ifdef __USE_MISC extern __sighandler_t signal (int __sig, __sighandler_t __handler) __THROW; #else / Make sure the used `signal' implementation is the SVID version. / # ifdef __REDIRECT_NTH extern __sighandler_t __REDIRECT_NTH (signal, (int __sig, __sighandler_t __handler), __sysv_signal); # else # define signal __sysv_signal # endif #endif #if defined __USE_XOPEN_EXTENDED && !defined __USE_XOPEN2K8 / The X/Open definition of `signal' conflicts with the BSD version. So they defined another function `bsd_signal'. / extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler) __THROW; #endif / Send signal SIG to process number PID. If PID is zero, send SIG to all processes in the current process's process group. If PID is < -1, send SIG to all processes in process group - PID. / #ifdef __USE_POSIX extern int kill (__pid_t __pid, int __sig) __THROW; #endif / Use POSIX. / #if defined __USE_MISC \|\| defined __USE_XOPEN_EXTENDED / Send SIG to all processes in process group PGRP. If PGRP is zero, send SIG to all processes in the current process's process group. / extern int killpg (__pid_t __pgrp, int __sig) __THROW; #endif / Use misc \|\| X/Open Unix. / / Raise signal SIG, i.e., send SIG to yourself. / extern int raise (int __sig) __THROW; #ifdef __USE_MISC / SVID names for the same things. / extern __sighandler_t ssignal (int __sig, __sighandler_t __handler) __THROW; extern int gsignal (int __sig) __THROW; #endif / Use misc. / #ifdef __USE_XOPEN2K8 / Print a message describing the meaning of the given signal number. / extern void psignal (int __sig, const char __s); /* Print a message describing the meaning of the given signal information. / extern void psiginfo (const siginfo_t __pinfo, const char __s); #endif / POSIX 2008. / / The `sigpause' function in X/Open defines the argument as the signal number. This requires redirecting to another function because the default version in glibc uses an old BSD interface. This function is a cancellation point and therefore not marked with __THROW. / #ifdef __USE_XOPEN_EXTENDED # ifdef __GNUC__ extern int sigpause (int __sig) __asm__ ("__xpg_sigpause") __attribute_deprecated_msg__ ("Use the sigsuspend function instead"); # else extern int __sigpause (int __sig_or_mask, int __is_sig); / Remove a signal from the signal mask and suspend the process. / # define sigpause(sig) __sigpause ((sig), 1) # endif #endif #ifdef __USE_MISC / None of the following functions should be used anymore. They are here only for compatibility. A single word (`int') is not guaranteed to be enough to hold a complete signal mask and therefore these functions simply do not work in many situations. Use `sigprocmask' instead. / / Compute mask for signal SIG. / # define sigmask(sig) \ __glibc_macro_warning ("sigmask is deprecated") \ ((int)(1u << ((sig) - 1))) / Block signals in MASK, returning the old mask. / extern int sigblock (int __mask) __THROW __attribute_deprecated__; / Set the mask of blocked signals to MASK, returning the old mask. / extern int sigsetmask (int __mask) __THROW __attribute_deprecated__; / Return currently selected signal mask. / extern int siggetmask (void) __THROW __attribute_deprecated__; #endif / Use misc. / #ifdef __USE_MISC # define NSIG _NSIG #endif #ifdef __USE_GNU typedef __sighandler_t sighandler_t; #endif / 4.4 BSD uses the name `sig_t' for this. / #ifdef __USE_MISC typedef __sighandler_t sig_t; #endif #ifdef __USE_POSIX / Clear all signals from SET. / extern int sigemptyset (sigset_t __set) __THROW __nonnull ((1)); /* Set all signals in SET. / extern int sigfillset (sigset_t __set) __THROW __nonnull ((1)); /* Add SIGNO to SET. / extern int sigaddset (sigset_t __set, int __signo) __THROW __nonnull ((1)); /* Remove SIGNO from SET. / extern int sigdelset (sigset_t __set, int __signo) __THROW __nonnull ((1)); /* Return 1 if SIGNO is in SET, 0 if not. / extern int sigismember (const sigset_t __set, int __signo) __THROW __nonnull ((1)); # ifdef __USE_GNU /* Return non-empty value is SET is not empty. / extern int sigisemptyset (const sigset_t __set) __THROW __nonnull ((1)); /* Build new signal set by combining the two inputs set using logical AND. / extern int sigandset (sigset_t __set, const sigset_t __left, const sigset_t __right) __THROW __nonnull ((1, 2, 3)); /* Build new signal set by combining the two inputs set using logical OR. / extern int sigorset (sigset_t __set, const sigset_t __left, const sigset_t __right) __THROW __nonnull ((1, 2, 3)); # endif /* GNU / / Get the system-specific definitions of `struct sigaction' and the `SA_' and `SIG_'. constants. / # include <bits/sigaction.h> / Get and/or change the set of blocked signals. / extern int sigprocmask (int __how, const sigset_t __restrict __set, sigset_t __restrict __oset) __THROW; / Change the set of blocked signals to SET, wait until a signal arrives, and restore the set of blocked signals. This function is a cancellation point and therefore not marked with __THROW. / extern int sigsuspend (const sigset_t __set) __nonnull ((1)); /* Get and/or set the action for signal SIG. / extern int sigaction (int __sig, const struct sigaction __restrict __act, struct sigaction __restrict __oact) __THROW; / Put in SET all signals that are blocked and waiting to be delivered. / extern int sigpending (sigset_t __set) __THROW __nonnull ((1)); # ifdef __USE_POSIX199506 /* Select any of pending signals from SET or wait for any to arrive. This function is a cancellation point and therefore not marked with __THROW. / extern int sigwait (const sigset_t __restrict __set, int __restrict __sig) __nonnull ((1, 2)); # endif / Use POSIX 1995. / # ifdef __USE_POSIX199309 / Select any of pending signals from SET and place information in INFO. This function is a cancellation point and therefore not marked with __THROW. / extern int sigwaitinfo (const sigset_t __restrict __set, siginfo_t __restrict __info) __nonnull ((1)); / Select any of pending signals from SET and place information in INFO. Wait the time specified by TIMEOUT if no signal is pending. This function is a cancellation point and therefore not marked with __THROW. / # ifndef __USE_TIME_BITS64 extern int sigtimedwait (const sigset_t __restrict __set, siginfo_t __restrict __info, const struct timespec __restrict __timeout) __nonnull ((1)); # else # ifdef __REDIRECT extern int __REDIRECT (sigtimedwait, (const sigset_t __restrict __set, siginfo_t __restrict __info, const struct timespec __restrict __timeout), __sigtimedwait64) __nonnull ((1)); # else # define sigtimedwait __sigtimedwait64 # endif # endif / Send signal SIG to the process PID. Associate data in VAL with the signal. / extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val) __THROW; # endif / Use POSIX 199306. / #endif / Use POSIX. / #ifdef __USE_MISC / Get machine-dependent `struct sigcontext' and signal subcodes. / # include <bits/sigcontext.h> / Restore the state saved in SCP. / extern int sigreturn (struct sigcontext __scp) __THROW; #endif /* Use misc. / #if defined __USE_XOPEN_EXTENDED \|\| defined __USE_XOPEN2K8 # define __need_size_t # include <stddef.h> # include <bits/types/stack_t.h> # if defined __USE_XOPEN \|\| defined __USE_XOPEN2K8 / This will define `ucontext_t' and `mcontext_t'. / # include <sys/ucontext.h> # endif #endif / Use POSIX.1-2008 or X/Open Unix. / #if defined __USE_XOPEN_EXTENDED \|\| defined __USE_MISC / If INTERRUPT is nonzero, make signal SIG interrupt system calls (causing them to fail with EINTR); if INTERRUPT is zero, make system calls be restarted after signal SIG. / extern int siginterrupt (int __sig, int __interrupt) __THROW __attribute_deprecated_msg__ ("Use sigaction with SA_RESTART instead"); # include <bits/sigstack.h> # include <bits/sigstksz.h> # include <bits/ss_flags.h> / Alternate signal handler stack interface. This interface should always be preferred over `sigstack'. / extern int sigaltstack (const stack_t __restrict __ss, stack_t __restrict __oss) __THROW; #endif / __USE_XOPEN_EXTENDED \|\| __USE_MISC / #if ((defined __USE_XOPEN_EXTENDED && !defined __USE_XOPEN2K8) \ \|\| defined __USE_MISC) # include <bits/types/struct_sigstack.h> #endif #if ((defined __USE_XOPEN_EXTENDED && !defined __USE_XOPEN2K) \ \|\| defined __USE_MISC) / Run signals handlers on the stack specified by SS (if not NULL). If OSS is not NULL, it is filled in with the old signal stack status. This interface is obsolete and on many platform not implemented. / extern int sigstack (struct sigstack __ss, struct sigstack __oss) __THROW __attribute_deprecated__; #endif #ifdef __USE_XOPEN_EXTENDED / Simplified interface for signal management. / / Add SIG to the calling process' signal mask. / extern int sighold (int __sig) __THROW __attribute_deprecated_msg__ ("Use the sigprocmask function instead"); / Remove SIG from the calling process' signal mask. / extern int sigrelse (int __sig) __THROW __attribute_deprecated_msg__ ("Use the sigprocmask function instead"); / Set the disposition of SIG to SIG_IGN. / extern int sigignore (int __sig) __THROW __attribute_deprecated_msg__ ("Use the signal function instead"); / Set the disposition of SIG. / extern __sighandler_t sigset (int __sig, __sighandler_t __disp) __THROW __attribute_deprecated_msg__ ("Use the signal and sigprocmask functions instead"); #endif #if defined __USE_POSIX199506 \|\| defined __USE_UNIX98 / Some of the functions for handling signals in threaded programs must be defined here. / # include <bits/pthreadtypes.h> # include <bits/sigthread.h> #endif / use Unix98 / / The following functions are used internally in the C library and in other code which need deep insights. / / Return number of available real-time signal with highest priority. / extern int __libc_current_sigrtmin (void) __THROW; / Return number of available real-time signal with lowest priority. / extern int __libc_current_sigrtmax (void) __THROW; #define SIGRTMIN (__libc_current_sigrtmin ()) #define SIGRTMAX (__libc_current_sigrtmax ()) / System-specific extensions. / #include <bits/signal_ext.h> __END_DECLS #endif / not signal.h */	12.73 KB	2026-02-17 11:01
📄 slapi-plugin.h /* $OpenLDAP$ / / This work is part of OpenLDAP Software <http://www.openldap.org/>. * * Copyright 1998-2024 The OpenLDAP Foundation. * Portions Copyright 1997,2002,2003 IBM Corporation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted only as authorized by the OpenLDAP * Public License. * * A copy of this license is available in file LICENSE in the * top-level directory of the distribution or, alternatively, at * <http://www.OpenLDAP.org/license.html>. / / * This header is used in development of SLAPI plugins for * OpenLDAP slapd(8) and other directory servers supporting * this interface. Your portability mileage may vary. / #ifndef _SLAPI_PLUGIN_H #define _SLAPI_PLUGIN_H #include <ldap.h> typedef struct slapi_pblock Slapi_PBlock; typedef struct slapi_entry Slapi_Entry; typedef struct slapi_attr Slapi_Attr; typedef struct slapi_value Slapi_Value; typedef struct slapi_valueset Slapi_ValueSet; typedef struct slapi_filter Slapi_Filter; typedef struct BackendDB Slapi_Backend; typedef struct Operation Slapi_Operation; typedef struct Connection Slapi_Connection; typedef struct slapi_dn Slapi_DN; typedef struct slapi_rdn Slapi_RDN; typedef struct slapi_mod Slapi_Mod; typedef struct slapi_mods Slapi_Mods; typedef struct slapi_componentid Slapi_ComponentId; #define SLAPI_ATTR_UNIQUEID "entryUUID" #define SLAPI_ATTR_OBJECTCLASS "objectClass" / pblock routines / int slapi_pblock_get( Slapi_PBlock pb, int arg, void value ); int slapi_pblock_set( Slapi_PBlock pb, int arg, void value ); Slapi_PBlock slapi_pblock_new( void ); void slapi_pblock_destroy( Slapi_PBlock pb ); / entry/attr/dn routines / Slapi_Entry slapi_str2entry( char s, int flags ); #define SLAPI_STR2ENTRY_REMOVEDUPVALS 1 #define SLAPI_STR2ENTRY_ADDRDNVALS 2 #define SLAPI_STR2ENTRY_BIGENTRY 4 #define SLAPI_STR2ENTRY_TOMBSTONE_CHECK 8 #define SLAPI_STR2ENTRY_IGNORE_STATE 16 #define SLAPI_STR2ENTRY_INCLUDE_VERSION_STR 32 #define SLAPI_STR2ENTRY_EXPAND_OBJECTCLASSES 64 #define SLAPI_STR2ENTRY_NOT_WELL_FORMED_LDIF 128 char slapi_entry2str( Slapi_Entry e, int len ); char slapi_entry_get_dn( Slapi_Entry e ); int slapi_x_entry_get_id( Slapi_Entry e ); void slapi_entry_set_dn( Slapi_Entry e, char dn ); Slapi_Entry slapi_entry_dup( Slapi_Entry e ); int slapi_entry_attr_delete( Slapi_Entry e, char type ); Slapi_Entry slapi_entry_alloc(); void slapi_entry_free( Slapi_Entry e ); int slapi_entry_attr_merge( Slapi_Entry e, char type, struct berval vals ); int slapi_entry_attr_find( Slapi_Entry e, char type, Slapi_Attr attr ); char slapi_entry_attr_get_charptr( const Slapi_Entry e, const char type ); int slapi_entry_attr_get_int( const Slapi_Entry e, const char type ); long slapi_entry_attr_get_long( const Slapi_Entry e, const char type ); unsigned int slapi_entry_attr_get_uint( const Slapi_Entry e, const char type ); unsigned long slapi_entry_attr_get_ulong( const Slapi_Entry e, const char type ); int slapi_attr_get_values( Slapi_Attr attr, struct berval *vals ); char slapi_dn_normalize( char dn ); char slapi_dn_normalize_case( char dn ); int slapi_dn_issuffix( char dn, char suffix ); char slapi_dn_beparent( Slapi_PBlock pb, const char dn ); int slapi_dn_isbesuffix( Slapi_PBlock pb, char dn ); char slapi_dn_parent( const char dn ); int slapi_dn_isparent( const char parentdn, const char childdn ); char slapi_dn_ignore_case( char dn ); int slapi_rdn2typeval( char rdn, char type, struct berval bv ); char slapi_dn_plus_rdn(const char dn, const char rdn); / DS 5.x SLAPI / int slapi_access_allowed( Slapi_PBlock pb, Slapi_Entry e, char attr, struct berval val, int access ); int slapi_acl_check_mods( Slapi_PBlock pb, Slapi_Entry e, LDAPMod mods, char errbuf ); Slapi_Attr slapi_attr_new( void ); Slapi_Attr slapi_attr_init( Slapi_Attr a, const char type ); void slapi_attr_free( Slapi_Attr a ); Slapi_Attr slapi_attr_dup( const Slapi_Attr attr ); int slapi_attr_add_value( Slapi_Attr a, const Slapi_Value v ); int slapi_attr_type2plugin( const char type, void *pi ); int slapi_attr_get_type( const Slapi_Attr attr, char *type ); int slapi_attr_get_oid_copy( const Slapi_Attr attr, char *oidp ); int slapi_attr_get_flags( const Slapi_Attr attr, unsigned long flags ); int slapi_attr_flag_is_set( const Slapi_Attr attr, unsigned long flag ); int slapi_attr_value_cmp( const Slapi_Attr attr, const struct berval v1, const struct berval v2 ); int slapi_attr_value_find( const Slapi_Attr a, struct berval v ); #define SLAPI_TYPE_CMP_EXACT 0 #define SLAPI_TYPE_CMP_BASE 1 #define SLAPI_TYPE_CMP_SUBTYPE 2 int slapi_attr_type_cmp( const char t1, const char t2, int opt ); int slapi_attr_types_equivalent( const char t1, const char t2 ); int slapi_attr_first_value( Slapi_Attr a, Slapi_Value *v ); int slapi_attr_next_value( Slapi_Attr a, int hint, Slapi_Value *v ); int slapi_attr_get_numvalues( const Slapi_Attr a, int numValues ); int slapi_attr_get_valueset( const Slapi_Attr a, Slapi_ValueSet *vs ); int slapi_attr_get_bervals_copy( Slapi_Attr a, struct berval **vals ); int slapi_entry_attr_hasvalue( Slapi_Entry e, const char type, const char value ); int slapi_entry_attr_merge_sv( Slapi_Entry e, const char type, Slapi_Value *vals ); void slapi_entry_attr_set_charptr(Slapi_Entry e, const char type, const char value); void slapi_entry_attr_set_int( Slapi_Entry* e, const char type, int l); void slapi_entry_attr_set_uint( Slapi_Entry e, const char type, unsigned int l); void slapi_entry_attr_set_long(Slapi_Entry e, const char type, long l); void slapi_entry_attr_set_ulong(Slapi_Entry e, const char type, unsigned long l); int slapi_entry_has_children(const Slapi_Entry e); size_t slapi_entry_size(Slapi_Entry e); int slapi_is_rootdse( const char dn ); int slapi_entry_attr_merge_sv( Slapi_Entry e, const char type, Slapi_Value *vals ); int slapi_entry_add_values_sv( Slapi_Entry e, const char type, Slapi_Value vals ); int slapi_entry_add_valueset(Slapi_Entry e, const char type, Slapi_ValueSet vs); int slapi_entry_delete_values_sv( Slapi_Entry e, const char type, Slapi_Value *vals ); int slapi_entry_merge_values_sv( Slapi_Entry e, const char type, Slapi_Value vals ); int slapi_entry_attr_replace_sv( Slapi_Entry e, const char type, Slapi_Value vals ); int slapi_entry_add_value(Slapi_Entry e, const char type, const Slapi_Value value); int slapi_entry_add_string(Slapi_Entry e, const char type, const char value); int slapi_entry_delete_string(Slapi_Entry e, const char type, const char value); int slapi_entry_first_attr( const Slapi_Entry e, Slapi_Attr attr ); int slapi_entry_next_attr( const Slapi_Entry e, Slapi_Attr prevattr, Slapi_Attr attr ); const char slapi_entry_get_uniqueid( const Slapi_Entry e ); void slapi_entry_set_uniqueid( Slapi_Entry e, char uniqueid ); int slapi_entry_schema_check( Slapi_PBlock pb, Slapi_Entry e ); int slapi_entry_rdn_values_present( const Slapi_Entry e ); int slapi_entry_add_rdn_values( Slapi_Entry e ); char slapi_attr_syntax_normalize( const char s ); Slapi_Value slapi_value_new( void ); Slapi_Value slapi_value_new_berval(const struct berval bval); Slapi_Value slapi_value_new_value(const Slapi_Value v); Slapi_Value slapi_value_new_string(const char s); Slapi_Value slapi_value_init(Slapi_Value v); Slapi_Value slapi_value_init_berval(Slapi_Value v, struct berval bval); Slapi_Value slapi_value_init_string(Slapi_Value v, const char s); Slapi_Value slapi_value_dup(const Slapi_Value v); void slapi_value_free(Slapi_Value *value); const struct berval slapi_value_get_berval( const Slapi_Value value ); Slapi_Value slapi_value_set_berval( Slapi_Value value, const struct berval bval ); Slapi_Value slapi_value_set_value( Slapi_Value value, const Slapi_Value vfrom); Slapi_Value slapi_value_set( Slapi_Value value, void val, unsigned long len); int slapi_value_set_string(Slapi_Value value, const char strVal); int slapi_value_set_int(Slapi_Value value, int intVal); const charslapi_value_get_string(const Slapi_Value value); int slapi_value_get_int(const Slapi_Value value); unsigned int slapi_value_get_uint(const Slapi_Value value); long slapi_value_get_long(const Slapi_Value value); unsigned long slapi_value_get_ulong(const Slapi_Value value); size_t slapi_value_get_length(const Slapi_Value value); int slapi_value_compare(const Slapi_Attr a, const Slapi_Value v1, const Slapi_Value v2); Slapi_ValueSet slapi_valueset_new( void ); void slapi_valueset_free(Slapi_ValueSet vs); void slapi_valueset_init(Slapi_ValueSet vs); void slapi_valueset_done(Slapi_ValueSet vs); void slapi_valueset_add_value(Slapi_ValueSet vs, const Slapi_Value addval); int slapi_valueset_first_value( Slapi_ValueSet vs, Slapi_Value *v ); int slapi_valueset_next_value( Slapi_ValueSet vs, int index, Slapi_Value *v); int slapi_valueset_count( const Slapi_ValueSet vs); void slapi_valueset_set_valueset(Slapi_ValueSet vs1, const Slapi_ValueSet vs2); /* DNs / Slapi_DN slapi_sdn_new( void ); Slapi_DN slapi_sdn_new_dn_byval( const char dn ); Slapi_DN slapi_sdn_new_ndn_byval( const char ndn ); Slapi_DN slapi_sdn_new_dn_byref( const char dn ); Slapi_DN slapi_sdn_new_ndn_byref( const char ndn ); Slapi_DN slapi_sdn_new_dn_passin( const char dn ); Slapi_DN slapi_sdn_set_dn_byval( Slapi_DN sdn, const char dn ); Slapi_DN slapi_sdn_set_dn_byref( Slapi_DN sdn, const char dn ); Slapi_DN slapi_sdn_set_dn_passin( Slapi_DN sdn, const char dn ); Slapi_DN slapi_sdn_set_ndn_byval( Slapi_DN sdn, const char ndn ); Slapi_DN slapi_sdn_set_ndn_byref( Slapi_DN sdn, const char ndn ); void slapi_sdn_done( Slapi_DN sdn ); void slapi_sdn_free( Slapi_DN *sdn ); const char slapi_sdn_get_dn( const Slapi_DN sdn ); const char slapi_sdn_get_ndn( const Slapi_DN sdn ); void slapi_sdn_get_parent( const Slapi_DN sdn,Slapi_DN sdn_parent ); void slapi_sdn_get_backend_parent( const Slapi_DN sdn, Slapi_DN sdn_parent, const Slapi_Backend backend ); Slapi_DN * slapi_sdn_dup( const Slapi_DN sdn ); void slapi_sdn_copy( const Slapi_DN from, Slapi_DN to ); int slapi_sdn_compare( const Slapi_DN sdn1, const Slapi_DN sdn2 ); int slapi_sdn_isempty( const Slapi_DN sdn ); int slapi_sdn_issuffix(const Slapi_DN sdn, const Slapi_DN suffixsdn ); int slapi_sdn_isparent( const Slapi_DN parent, const Slapi_DN child ); int slapi_sdn_isgrandparent( const Slapi_DN parent, const Slapi_DN child ); int slapi_sdn_get_ndn_len( const Slapi_DN sdn ); int slapi_sdn_scope_test( const Slapi_DN dn, const Slapi_DN base, int scope ); void slapi_sdn_get_rdn( const Slapi_DN sdn,Slapi_RDN rdn ); Slapi_DN slapi_sdn_set_rdn( Slapi_DN sdn, const Slapi_RDN rdn ); Slapi_DN slapi_sdn_set_parent( Slapi_DN sdn, const Slapi_DN parentdn ); int slapi_sdn_is_rdn_component( const Slapi_DN rdn, const Slapi_Attr a, const Slapi_Value v ); char * slapi_moddn_get_newdn( Slapi_DN dn_olddn, char newrdn, char newsuperiordn ); / RDNs / Slapi_RDN slapi_rdn_new( void ); Slapi_RDN slapi_rdn_new_dn( const char dn ); Slapi_RDN slapi_rdn_new_sdn( const Slapi_DN sdn ); Slapi_RDN slapi_rdn_new_rdn( const Slapi_RDN fromrdn ); void slapi_rdn_init( Slapi_RDN rdn ); void slapi_rdn_init_dn( Slapi_RDN rdn, const char dn ); void slapi_rdn_init_sdn( Slapi_RDN rdn, const Slapi_DN sdn ); void slapi_rdn_init_rdn( Slapi_RDN rdn, const Slapi_RDN fromrdn ); void slapi_rdn_set_dn( Slapi_RDN rdn, const char dn ); void slapi_rdn_set_sdn( Slapi_RDN rdn, const Slapi_DN sdn ); void slapi_rdn_set_rdn( Slapi_RDN rdn, const Slapi_RDN fromrdn ); void slapi_rdn_free( Slapi_RDN rdn ); void slapi_rdn_done( Slapi_RDN rdn ); int slapi_rdn_get_first( Slapi_RDN rdn, char type, char value ); int slapi_rdn_get_next( Slapi_RDN rdn, int index, char type, char value ); int slapi_rdn_get_index( Slapi_RDN rdn, const char type, const char value, size_t length ); int slapi_rdn_get_index_attr( Slapi_RDN rdn, const char type, char value ); int slapi_rdn_contains( Slapi_RDN rdn, const char type, const char value,size_t length ); int slapi_rdn_contains_attr( Slapi_RDN rdn, const char type, char *value ); int slapi_rdn_add( Slapi_RDN rdn, const char type, const char value ); int slapi_rdn_remove_index( Slapi_RDN rdn, int atindex ); int slapi_rdn_remove( Slapi_RDN rdn, const char type, const char value, size_t length ); int slapi_rdn_remove_attr( Slapi_RDN rdn, const char type ); int slapi_rdn_isempty( const Slapi_RDN rdn ); int slapi_rdn_get_num_components( Slapi_RDN rdn ); int slapi_rdn_compare( Slapi_RDN rdn1, Slapi_RDN rdn2 ); const char slapi_rdn_get_rdn( const Slapi_RDN rdn ); const char slapi_rdn_get_nrdn( const Slapi_RDN rdn ); Slapi_DN slapi_sdn_add_rdn( Slapi_DN sdn, const Slapi_RDN rdn ); / locks and synchronization / typedef struct slapi_mutex Slapi_Mutex; typedef struct slapi_condvar Slapi_CondVar; Slapi_Mutex slapi_new_mutex( void ); void slapi_destroy_mutex( Slapi_Mutex mutex ); void slapi_lock_mutex( Slapi_Mutex mutex ); int slapi_unlock_mutex( Slapi_Mutex mutex ); Slapi_CondVar slapi_new_condvar( Slapi_Mutex mutex ); void slapi_destroy_condvar( Slapi_CondVar cvar ); int slapi_wait_condvar( Slapi_CondVar cvar, struct timeval timeout ); int slapi_notify_condvar( Slapi_CondVar cvar, int notify_all ); / thread-safe LDAP connections / LDAP slapi_ldap_init( char ldaphost, int ldapport, int secure, int shared ); void slapi_ldap_unbind( LDAP ld ); char slapi_ch_malloc( unsigned long size ); void slapi_ch_free( void ptr ); void slapi_ch_free_string( char ptr ); char slapi_ch_calloc( unsigned long nelem, unsigned long size ); char slapi_ch_realloc( char block, unsigned long size ); char slapi_ch_strdup( const char s ); void slapi_ch_array_free( char *arrayp ); struct berval slapi_ch_bvdup(const struct berval v); struct berval slapi_ch_bvecdup(const struct berval v); / LDAP V3 routines / int slapi_control_present( LDAPControl controls, char oid, struct berval *val, int iscritical); void slapi_register_supported_control(char controloid, unsigned long controlops); #define SLAPI_OPERATION_BIND 0x00000001L #define SLAPI_OPERATION_UNBIND 0x00000002L #define SLAPI_OPERATION_SEARCH 0x00000004L #define SLAPI_OPERATION_MODIFY 0x00000008L #define SLAPI_OPERATION_ADD 0x00000010L #define SLAPI_OPERATION_DELETE 0x00000020L #define SLAPI_OPERATION_MODDN 0x00000040L #define SLAPI_OPERATION_MODRDN SLAPI_OPERATION_MODDN #define SLAPI_OPERATION_COMPARE 0x00000080L #define SLAPI_OPERATION_ABANDON 0x00000100L #define SLAPI_OPERATION_EXTENDED 0x00000200L #define SLAPI_OPERATION_ANY 0xFFFFFFFFL #define SLAPI_OPERATION_NONE 0x00000000L int slapi_get_supported_controls(char ctrloidsp, unsigned long ctrlopsp); LDAPControl slapi_dup_control(LDAPControl ctrl); void slapi_register_supported_saslmechanism(char mechanism); char slapi_get_supported_saslmechanisms(); char slapi_get_supported_extended_ops(void); / operation / int slapi_op_abandoned( Slapi_PBlock pb ); unsigned long slapi_op_get_type(Slapi_Operation * op); void slapi_operation_set_flag(Slapi_Operation op, unsigned long flag); void slapi_operation_clear_flag(Slapi_Operation op, unsigned long flag); int slapi_operation_is_flag_set(Slapi_Operation op, unsigned long flag); char slapi_op_type_to_string(unsigned long type); /* send ldap result back / void slapi_send_ldap_result( Slapi_PBlock pb, int err, char matched, char text, int nentries, struct berval *urls ); int slapi_send_ldap_search_entry( Slapi_PBlock pb, Slapi_Entry e, LDAPControl ectrls, char attrs, int attrsonly ); int slapi_send_ldap_search_reference( Slapi_PBlock pb, Slapi_Entry e, struct berval urls, LDAPControl ectrls, struct berval v2refs ); / filter routines / Slapi_Filter slapi_str2filter( char str ); Slapi_Filter slapi_filter_dup( Slapi_Filter f ); void slapi_filter_free( Slapi_Filter f, int recurse ); int slapi_filter_get_choice( Slapi_Filter f); int slapi_filter_get_ava( Slapi_Filter f, char type, struct berval bval ); Slapi_Filter slapi_filter_list_first( Slapi_Filter f ); Slapi_Filter slapi_filter_list_next( Slapi_Filter f, Slapi_Filter fprev ); int slapi_filter_get_attribute_type( Slapi_Filter f, char *type ); int slapi_x_filter_set_attribute_type( Slapi_Filter f, const char type ); int slapi_filter_get_subfilt( Slapi_Filter f, char type, char initial, char *any, char final ); Slapi_Filter slapi_filter_join( int ftype, Slapi_Filter f1, Slapi_Filter f2); int slapi_x_filter_append( int choice, Slapi_Filter pContainingFilter, Slapi_Filter pNextFilter, Slapi_Filter filterToAppend ); int slapi_filter_test( Slapi_PBlock pb, Slapi_Entry e, Slapi_Filter f, int verify_access ); int slapi_filter_test_simple( Slapi_Entry e, Slapi_Filter f ); typedef int (FILTER_APPLY_FN)( Slapi_Filter f, void arg ); int slapi_filter_apply( Slapi_Filter f, FILTER_APPLY_FN fn, void arg, int error_code ); #define SLAPI_FILTER_SCAN_STOP -1 / set by callback / #define SLAPI_FILTER_SCAN_ERROR -2 / set by callback / #define SLAPI_FILTER_SCAN_NOMORE 0 / set by callback / #define SLAPI_FILTER_SCAN_CONTINUE 1 / set by callback / #define SLAPI_FILTER_UNKNOWN_FILTER_TYPE 2 / set by slapi_filter_apply() / / internal add/delete/search/modify routines / Slapi_PBlock slapi_search_internal( char base, int scope, char filter, LDAPControl controls, char attrs, int attrsonly ); Slapi_PBlock slapi_modify_internal( char dn, LDAPMod mods, LDAPControl controls, int log_change ); Slapi_PBlock slapi_add_internal( char dn, LDAPMod attrs, LDAPControl controls, int log_changes ); Slapi_PBlock slapi_add_entry_internal( Slapi_Entry e, LDAPControl *controls, int log_change ); Slapi_PBlock slapi_delete_internal( char * dn, LDAPControl *controls, int log_change ); Slapi_PBlock slapi_modrdn_internal( char * olddn, char * newrdn, int deloldrdn, LDAPControl *controls, int log_change ); Slapi_PBlock slapi_rename_internal( const char * olddn, const char newrdn, const char newsuperior, int deloldrdn, LDAPControl *controls, int log_change ); void slapi_free_search_results_internal(Slapi_PBlock pb); /* new internal add/delete/search/modify routines / typedef void (plugin_result_callback)( int rc, void callback_data ); typedef int (plugin_referral_entry_callback)( char * referral, void callback_data ); typedef int (plugin_search_entry_callback)( Slapi_Entry e, void callback_data ); void slapi_free_search_results_internal( Slapi_PBlock pb ); #define SLAPI_OP_FLAG_NEVER_CHAIN 0x0800 int slapi_search_internal_pb( Slapi_PBlock pb ); int slapi_search_internal_callback_pb( Slapi_PBlock pb, void callback_data, plugin_result_callback prc, plugin_search_entry_callback psec, plugin_referral_entry_callback prec ); int slapi_add_internal_pb( Slapi_PBlock pb ); int slapi_modify_internal_pb( Slapi_PBlock pb ); int slapi_modrdn_internal_pb( Slapi_PBlock pb ); int slapi_delete_internal_pb( Slapi_PBlock pb ); int slapi_seq_internal_callback_pb(Slapi_PBlock pb, void callback_data, plugin_result_callback res_callback, plugin_search_entry_callback srch_callback, plugin_referral_entry_callback ref_callback); void slapi_search_internal_set_pb( Slapi_PBlock pb, const char base, int scope, const char filter, char attrs, int attrsonly, LDAPControl controls, const char uniqueid, Slapi_ComponentId plugin_identity, int operation_flags ); void slapi_add_entry_internal_set_pb( Slapi_PBlock pb, Slapi_Entry e, LDAPControl controls, Slapi_ComponentId plugin_identity, int operation_flags ); int slapi_add_internal_set_pb( Slapi_PBlock pb, const char dn, LDAPMod attrs, LDAPControl controls, Slapi_ComponentId plugin_identity, int operation_flags ); void slapi_modify_internal_set_pb( Slapi_PBlock pb, const char dn, LDAPMod mods, LDAPControl controls, const char uniqueid, Slapi_ComponentId plugin_identity, int operation_flags ); void slapi_rename_internal_set_pb( Slapi_PBlock pb, const char olddn, const char newrdn, const char newsuperior, int deloldrdn, LDAPControl controls, const char uniqueid, Slapi_ComponentId plugin_identity, int operation_flags ); void slapi_delete_internal_set_pb( Slapi_PBlock pb, const char dn, LDAPControl controls, const char uniqueid, Slapi_ComponentId plugin_identity, int operation_flags ); void slapi_seq_internal_set_pb( Slapi_PBlock pb, char ibase, int type, char attrname, char val, char attrs, int attrsonly, LDAPControl controls, Slapi_ComponentId plugin_identity, int operation_flags ); /* connection related routines / int slapi_is_connection_ssl(Slapi_PBlock pPB, int isSSL); int slapi_get_client_port(Slapi_PBlock pPB, int fromPort); int slapi_get_client_ip(Slapi_PBlock pb, char clientIP); void slapi_free_client_ip(char clientIP); /* computed attributes / typedef struct _computed_attr_context computed_attr_context; typedef int (slapi_compute_output_t)(computed_attr_context c, Slapi_Attr a, Slapi_Entry e); typedef int (slapi_compute_callback_t)(computed_attr_context c, char type, Slapi_Entry e, slapi_compute_output_t outputfn); typedef int (slapi_search_rewrite_callback_t)(Slapi_PBlock pb); int slapi_compute_add_evaluator(slapi_compute_callback_t function); int slapi_compute_add_search_rewriter(slapi_search_rewrite_callback_t function); int compute_rewrite_search_filter(Slapi_PBlock pb); int compute_evaluator(computed_attr_context c, char type, Slapi_Entry e, slapi_compute_output_t outputfn); int slapi_x_compute_get_pblock(computed_attr_context c, Slapi_PBlock *pb); / backend routines / void slapi_be_set_readonly( Slapi_Backend be, int readonly ); int slapi_be_get_readonly( Slapi_Backend be ); const char slapi_x_be_get_updatedn( Slapi_Backend be ); Slapi_Backend slapi_be_select( const Slapi_DN sdn ); / ACL plugins; only SLAPI_PLUGIN_ACL_ALLOW_ACCESS supported now / typedef int (slapi_acl_callback_t)(Slapi_PBlock pb, Slapi_Entry e, const char attr, struct berval berval, int access, void state); / object extensions / typedef void (slapi_extension_constructor_fnptr)(void object, void parent); typedef void (slapi_extension_destructor_fnptr)(void extension, void object, void parent); int slapi_register_object_extension( const char pluginname, const char objectname, slapi_extension_constructor_fnptr constructor, slapi_extension_destructor_fnptr destructor, int objecttype, int extensionhandle); #define SLAPI_EXT_CONNECTION "Connection" #define SLAPI_EXT_OPERATION "Operation" #define SLAPI_EXT_ENTRY "Entry" #define SLAPI_EXT_MTNODE "Mapping Tree Node" void slapi_get_object_extension(int objecttype, void object, int extensionhandle); void slapi_set_object_extension(int objecttype, void object, int extensionhandle, void extension); int slapi_x_backend_get_flags( const Slapi_Backend be, unsigned long flags ); / parameters currently supported / / * Attribute flags returned by slapi_attr_get_flags() / #define SLAPI_ATTR_FLAG_SINGLE 0x0001 #define SLAPI_ATTR_FLAG_OPATTR 0x0002 #define SLAPI_ATTR_FLAG_READONLY 0x0004 #define SLAPI_ATTR_FLAG_STD_ATTR SLAPI_ATTR_FLAG_READONLY #define SLAPI_ATTR_FLAG_OBSOLETE 0x0040 #define SLAPI_ATTR_FLAG_COLLECTIVE 0x0080 #define SLAPI_ATTR_FLAG_NOUSERMOD 0x0100 / * Backend flags returned by slapi_x_backend_get_flags() / #define SLAPI_BACKEND_FLAG_NOLASTMOD 0x0001U #define SLAPI_BACKEND_FLAG_NO_SCHEMA_CHECK 0x0002U #define SLAPI_BACKEND_FLAG_GLUE_INSTANCE 0x0010U / a glue backend / #define SLAPI_BACKEND_FLAG_GLUE_SUBORDINATE 0x0020U / child of a glue hierarchy / #define SLAPI_BACKEND_FLAG_GLUE_LINKED 0x0040U / child is connected to parent / #define SLAPI_BACKEND_FLAG_OVERLAY 0x0080U / this db struct is an overlay / #define SLAPI_BACKEND_FLAG_GLOBAL_OVERLAY 0x0100U / this db struct is a global overlay / #define SLAPI_BACKEND_FLAG_SHADOW 0x8000U / a shadow / #define SLAPI_BACKEND_FLAG_SYNC_SHADOW 0x1000U / a sync shadow / #define SLAPI_BACKEND_FLAG_SLURP_SHADOW 0x2000U / a slurp shadow / / * ACL levels / #define SLAPI_ACL_COMPARE 0x01 #define SLAPI_ACL_SEARCH 0x02 #define SLAPI_ACL_READ 0x04 #define SLAPI_ACL_WRITE 0x08 #define SLAPI_ACL_DELETE 0x10 #define SLAPI_ACL_ADD 0x20 #define SLAPI_ACL_SELF 0x40 #define SLAPI_ACL_PROXY 0x80 #define SLAPI_ACL_ALL 0x7f / plugin types supported / #define SLAPI_PLUGIN_DATABASE 1 #define SLAPI_PLUGIN_EXTENDEDOP 2 #define SLAPI_PLUGIN_PREOPERATION 3 #define SLAPI_PLUGIN_POSTOPERATION 4 #define SLAPI_PLUGIN_MATCHINGRULE 5 #define SLAPI_PLUGIN_SYNTAX 6 #define SLAPI_PLUGIN_AUDIT 7 / misc params / #define SLAPI_BACKEND 130 #define SLAPI_CONNECTION 131 #define SLAPI_OPERATION 132 #define SLAPI_REQUESTOR_ISROOT 133 #define SLAPI_BE_MONITORDN 134 #define SLAPI_BE_TYPE 135 #define SLAPI_BE_READONLY 136 #define SLAPI_BE_LASTMOD 137 #define SLAPI_CONN_ID 139 / operation params / #define SLAPI_OPINITIATED_TIME 140 #define SLAPI_REQUESTOR_DN 141 #define SLAPI_IS_REPLICATED_OPERATION 142 #define SLAPI_REQUESTOR_ISUPDATEDN SLAPI_IS_REPLICATED_OPERATION / connection structure params/ #define SLAPI_CONN_DN 143 #define SLAPI_CONN_AUTHTYPE 144 #define SLAPI_CONN_CLIENTIP 145 #define SLAPI_CONN_SERVERIP 146 / OpenLDAP extensions / #define SLAPI_X_CONN_CLIENTPATH 1300 #define SLAPI_X_CONN_SERVERPATH 1301 #define SLAPI_X_CONN_IS_UDP 1302 #define SLAPI_X_CONN_SSF 1303 #define SLAPI_X_CONN_SASL_CONTEXT 1304 #define SLAPI_X_OPERATION_DELETE_GLUE_PARENT 1305 #define SLAPI_X_RELAX 1306 #define SLAPI_X_MANAGEDIT SLAPI_X_RELAX #define SLAPI_X_OPERATION_NO_SCHEMA_CHECK 1307 #define SLAPI_X_ADD_STRUCTURAL_CLASS 1308 #define SLAPI_X_OPERATION_NO_SUBORDINATE_GLUE 1309 / Authentication types / #define SLAPD_AUTH_NONE "none" #define SLAPD_AUTH_SIMPLE "simple" #define SLAPD_AUTH_SSL "SSL" #define SLAPD_AUTH_SASL "SASL " / plugin configuration parmams / #define SLAPI_PLUGIN 3 #define SLAPI_PLUGIN_PRIVATE 4 #define SLAPI_PLUGIN_TYPE 5 #define SLAPI_PLUGIN_ARGV 6 #define SLAPI_PLUGIN_ARGC 7 #define SLAPI_PLUGIN_VERSION 8 #define SLAPI_PLUGIN_OPRETURN 9 #define SLAPI_PLUGIN_OBJECT 10 #define SLAPI_PLUGIN_DESTROY_FN 11 #define SLAPI_PLUGIN_DESCRIPTION 12 #define SLAPI_PLUGIN_IDENTITY 13 / internal operations params / #define SLAPI_PLUGIN_INTOP_RESULT 15 #define SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES 16 #define SLAPI_PLUGIN_INTOP_SEARCH_REFERRALS 17 / transaction arguments / #define SLAPI_PARENT_TXN 190 #define SLAPI_TXN 191 / function pointer params for backends / #define SLAPI_PLUGIN_DB_BIND_FN 200 #define SLAPI_PLUGIN_DB_UNBIND_FN 201 #define SLAPI_PLUGIN_DB_SEARCH_FN 202 #define SLAPI_PLUGIN_DB_COMPARE_FN 203 #define SLAPI_PLUGIN_DB_MODIFY_FN 204 #define SLAPI_PLUGIN_DB_MODRDN_FN 205 #define SLAPI_PLUGIN_DB_ADD_FN 206 #define SLAPI_PLUGIN_DB_DELETE_FN 207 #define SLAPI_PLUGIN_DB_ABANDON_FN 208 #define SLAPI_PLUGIN_DB_CONFIG_FN 209 #define SLAPI_PLUGIN_CLOSE_FN 210 #define SLAPI_PLUGIN_DB_FLUSH_FN 211 #define SLAPI_PLUGIN_START_FN 212 #define SLAPI_PLUGIN_DB_SEQ_FN 213 #define SLAPI_PLUGIN_DB_ENTRY_FN 214 #define SLAPI_PLUGIN_DB_REFERRAL_FN 215 #define SLAPI_PLUGIN_DB_RESULT_FN 216 #define SLAPI_PLUGIN_DB_LDIF2DB_FN 217 #define SLAPI_PLUGIN_DB_DB2LDIF_FN 218 #define SLAPI_PLUGIN_DB_BEGIN_FN 219 #define SLAPI_PLUGIN_DB_COMMIT_FN 220 #define SLAPI_PLUGIN_DB_ABORT_FN 221 #define SLAPI_PLUGIN_DB_ARCHIVE2DB_FN 222 #define SLAPI_PLUGIN_DB_DB2ARCHIVE_FN 223 #define SLAPI_PLUGIN_DB_NEXT_SEARCH_ENTRY_FN 224 #define SLAPI_PLUGIN_DB_FREE_RESULT_SET_FN 225 #define SLAPI_PLUGIN_DB_SIZE_FN 226 #define SLAPI_PLUGIN_DB_TEST_FN 227 / functions pointers for LDAP V3 extended ops / #define SLAPI_PLUGIN_EXT_OP_FN 300 #define SLAPI_PLUGIN_EXT_OP_OIDLIST 301 / preoperation / #define SLAPI_PLUGIN_PRE_BIND_FN 401 #define SLAPI_PLUGIN_PRE_UNBIND_FN 402 #define SLAPI_PLUGIN_PRE_SEARCH_FN 403 #define SLAPI_PLUGIN_PRE_COMPARE_FN 404 #define SLAPI_PLUGIN_PRE_MODIFY_FN 405 #define SLAPI_PLUGIN_PRE_MODRDN_FN 406 #define SLAPI_PLUGIN_PRE_ADD_FN 407 #define SLAPI_PLUGIN_PRE_DELETE_FN 408 #define SLAPI_PLUGIN_PRE_ABANDON_FN 409 #define SLAPI_PLUGIN_PRE_ENTRY_FN 410 #define SLAPI_PLUGIN_PRE_REFERRAL_FN 411 #define SLAPI_PLUGIN_PRE_RESULT_FN 412 / internal preoperation / #define SLAPI_PLUGIN_INTERNAL_PRE_ADD_FN 420 #define SLAPI_PLUGIN_INTERNAL_PRE_MODIFY_FN 421 #define SLAPI_PLUGIN_INTERNAL_PRE_MODRDN_FN 422 #define SLAPI_PLUGIN_INTERNAL_PRE_DELETE_FN 423 / backend preoperation / #define SLAPI_PLUGIN_BE_PRE_ADD_FN 450 #define SLAPI_PLUGIN_BE_PRE_MODIFY_FN 451 #define SLAPI_PLUGIN_BE_PRE_MODRDN_FN 452 #define SLAPI_PLUGIN_BE_PRE_DELETE_FN 453 / postoperation / #define SLAPI_PLUGIN_POST_BIND_FN 501 #define SLAPI_PLUGIN_POST_UNBIND_FN 502 #define SLAPI_PLUGIN_POST_SEARCH_FN 503 #define SLAPI_PLUGIN_POST_COMPARE_FN 504 #define SLAPI_PLUGIN_POST_MODIFY_FN 505 #define SLAPI_PLUGIN_POST_MODRDN_FN 506 #define SLAPI_PLUGIN_POST_ADD_FN 507 #define SLAPI_PLUGIN_POST_DELETE_FN 508 #define SLAPI_PLUGIN_POST_ABANDON_FN 509 #define SLAPI_PLUGIN_POST_ENTRY_FN 510 #define SLAPI_PLUGIN_POST_REFERRAL_FN 511 #define SLAPI_PLUGIN_POST_RESULT_FN 512 / internal postoperation / #define SLAPI_PLUGIN_INTERNAL_POST_ADD_FN 520 #define SLAPI_PLUGIN_INTERNAL_POST_MODIFY_FN 521 #define SLAPI_PLUGIN_INTERNAL_POST_MODRDN_FN 522 #define SLAPI_PLUGIN_INTERNAL_POST_DELETE_FN 523 / backend postoperation / #define SLAPI_PLUGIN_BE_POST_ADD_FN 550 #define SLAPI_PLUGIN_BE_POST_MODIFY_FN 551 #define SLAPI_PLUGIN_BE_POST_MODRDN_FN 552 #define SLAPI_PLUGIN_BE_POST_DELETE_FN 553 #define SLAPI_OPERATION_TYPE 590 #define SLAPI_OPERATION_MSGID 591 #define SLAPI_PLUGIN_MR_FILTER_CREATE_FN 600 #define SLAPI_PLUGIN_MR_INDEXER_CREATE_FN 601 #define SLAPI_PLUGIN_MR_FILTER_MATCH_FN 602 #define SLAPI_PLUGIN_MR_FILTER_INDEX_FN 603 #define SLAPI_PLUGIN_MR_FILTER_RESET_FN 604 #define SLAPI_PLUGIN_MR_INDEX_FN 605 #define SLAPI_PLUGIN_MR_OID 610 #define SLAPI_PLUGIN_MR_TYPE 611 #define SLAPI_PLUGIN_MR_VALUE 612 #define SLAPI_PLUGIN_MR_VALUES 613 #define SLAPI_PLUGIN_MR_KEYS 614 #define SLAPI_PLUGIN_MR_FILTER_REUSABLE 615 #define SLAPI_PLUGIN_MR_QUERY_OPERATOR 616 #define SLAPI_PLUGIN_MR_USAGE 617 #define SLAPI_MATCHINGRULE_NAME 1 #define SLAPI_MATCHINGRULE_OID 2 #define SLAPI_MATCHINGRULE_DESC 3 #define SLAPI_MATCHINGRULE_SYNTAX 4 #define SLAPI_MATCHINGRULE_OBSOLETE 5 #define SLAPI_OP_LESS 1 #define SLAPI_OP_LESS_OR_EQUAL 2 #define SLAPI_OP_EQUAL 3 #define SLAPI_OP_GREATER_OR_EQUAL 4 #define SLAPI_OP_GREATER 5 #define SLAPI_OP_SUBSTRING 6 #define SLAPI_PLUGIN_MR_USAGE_INDEX 0 #define SLAPI_PLUGIN_MR_USAGE_SORT 1 #define SLAPI_PLUGIN_SYNTAX_FILTER_AVA 700 #define SLAPI_PLUGIN_SYNTAX_FILTER_SUB 701 #define SLAPI_PLUGIN_SYNTAX_VALUES2KEYS 702 #define SLAPI_PLUGIN_SYNTAX_ASSERTION2KEYS_AVA 703 #define SLAPI_PLUGIN_SYNTAX_ASSERTION2KEYS_SUB 704 #define SLAPI_PLUGIN_SYNTAX_NAMES 705 #define SLAPI_PLUGIN_SYNTAX_OID 706 #define SLAPI_PLUGIN_SYNTAX_FLAGS 707 #define SLAPI_PLUGIN_SYNTAX_COMPARE 708 #define SLAPI_PLUGIN_SYNTAX_FLAG_ORKEYS 1 #define SLAPI_PLUGIN_SYNTAX_FLAG_ORDERING 2 #define SLAPI_PLUGIN_ACL_INIT 730 #define SLAPI_PLUGIN_ACL_SYNTAX_CHECK 731 #define SLAPI_PLUGIN_ACL_ALLOW_ACCESS 732 #define SLAPI_PLUGIN_ACL_MODS_ALLOWED 733 #define SLAPI_PLUGIN_ACL_MODS_UPDATE 734 #define SLAPI_OPERATION_AUTHTYPE 741 #define SLAPI_OPERATION_ID 742 #define SLAPI_CONN_CERT 743 #define SLAPI_CONN_AUTHMETHOD 746 #define SLAPI_IS_INTERNAL_OPERATION 748 #define SLAPI_RESULT_CODE 881 #define SLAPI_RESULT_TEXT 882 #define SLAPI_RESULT_MATCHED 883 / managedsait control / #define SLAPI_MANAGEDSAIT 1000 / audit plugin defines / #define SLAPI_PLUGIN_AUDIT_DATA 1100 #define SLAPI_PLUGIN_AUDIT_FN 1101 / backend_group extension / #define SLAPI_X_PLUGIN_PRE_GROUP_FN 1202 #define SLAPI_X_PLUGIN_POST_GROUP_FN 1203 #define SLAPI_X_GROUP_ENTRY 1250 / group entry / #define SLAPI_X_GROUP_ATTRIBUTE 1251 / member attribute / #define SLAPI_X_GROUP_OPERATION_DN 1252 / asserted value / #define SLAPI_X_GROUP_TARGET_ENTRY 1253 / target entry / / internal preoperation extensions / #define SLAPI_PLUGIN_INTERNAL_PRE_BIND_FN 1260 #define SLAPI_PLUGIN_INTERNAL_PRE_UNBIND_FN 1261 #define SLAPI_PLUGIN_INTERNAL_PRE_SEARCH_FN 1262 #define SLAPI_PLUGIN_INTERNAL_PRE_COMPARE_FN 1263 #define SLAPI_PLUGIN_INTERNAL_PRE_ABANDON_FN 1264 / internal postoperation extensions / #define SLAPI_PLUGIN_INTERNAL_POST_BIND_FN 1270 #define SLAPI_PLUGIN_INTERNAL_POST_UNBIND_FN 1271 #define SLAPI_PLUGIN_INTERNAL_POST_SEARCH_FN 1272 #define SLAPI_PLUGIN_INTERNAL_POST_COMPARE_FN 1273 #define SLAPI_PLUGIN_INTERNAL_POST_ABANDON_FN 1274 / config stuff / #define SLAPI_CONFIG_FILENAME 40 #define SLAPI_CONFIG_LINENO 41 #define SLAPI_CONFIG_ARGC 42 #define SLAPI_CONFIG_ARGV 43 / operational params / #define SLAPI_TARGET_ADDRESS 48 #define SLAPI_TARGET_UNIQUEID 49 #define SLAPI_TARGET_DN 50 / server LDAPv3 controls / #define SLAPI_REQCONTROLS 51 #define SLAPI_RESCONTROLS 55 #define SLAPI_ADD_RESCONTROL 56 #define SLAPI_CONTROLS_ARG 58 / add params / #define SLAPI_ADD_TARGET SLAPI_TARGET_DN #define SLAPI_ADD_ENTRY 60 #define SLAPI_ADD_EXISTING_DN_ENTRY 61 #define SLAPI_ADD_PARENT_ENTRY 62 #define SLAPI_ADD_PARENT_UNIQUEID 63 #define SLAPI_ADD_EXISTING_UNIQUEID_ENTRY 64 / bind params / #define SLAPI_BIND_TARGET SLAPI_TARGET_DN #define SLAPI_BIND_METHOD 70 #define SLAPI_BIND_CREDENTIALS 71 #define SLAPI_BIND_SASLMECHANISM 72 #define SLAPI_BIND_RET_SASLCREDS 73 / compare params / #define SLAPI_COMPARE_TARGET SLAPI_TARGET_DN #define SLAPI_COMPARE_TYPE 80 #define SLAPI_COMPARE_VALUE 81 / delete params / #define SLAPI_DELETE_TARGET SLAPI_TARGET_DN #define SLAPI_DELETE_EXISTING_ENTRY SLAPI_ADD_EXISTING_DN_ENTRY / modify params / #define SLAPI_MODIFY_TARGET SLAPI_TARGET_DN #define SLAPI_MODIFY_MODS 90 #define SLAPI_MODIFY_EXISTING_ENTRY SLAPI_ADD_EXISTING_DN_ENTRY / modrdn params / #define SLAPI_MODRDN_TARGET SLAPI_TARGET_DN #define SLAPI_MODRDN_NEWRDN 100 #define SLAPI_MODRDN_DELOLDRDN 101 #define SLAPI_MODRDN_NEWSUPERIOR 102 / v3 only / #define SLAPI_MODRDN_EXISTING_ENTRY SLAPI_ADD_EXISTING_DN_ENTRY #define SLAPI_MODRDN_PARENT_ENTRY 104 #define SLAPI_MODRDN_NEWPARENT_ENTRY 105 #define SLAPI_MODRDN_TARGET_ENTRY 106 #define SLAPI_MODRDN_NEWSUPERIOR_ADDRESS 107 / search params / #define SLAPI_SEARCH_TARGET SLAPI_TARGET_DN #define SLAPI_SEARCH_SCOPE 110 #define SLAPI_SEARCH_DEREF 111 #define SLAPI_SEARCH_SIZELIMIT 112 #define SLAPI_SEARCH_TIMELIMIT 113 #define SLAPI_SEARCH_FILTER 114 #define SLAPI_SEARCH_STRFILTER 115 #define SLAPI_SEARCH_ATTRS 116 #define SLAPI_SEARCH_ATTRSONLY 117 / abandon params / #define SLAPI_ABANDON_MSGID 120 / extended operation params / #define SLAPI_EXT_OP_REQ_OID 160 #define SLAPI_EXT_OP_REQ_VALUE 161 / extended operation return codes / #define SLAPI_EXT_OP_RET_OID 162 #define SLAPI_EXT_OP_RET_VALUE 163 #define SLAPI_PLUGIN_EXTENDED_SENT_RESULT -1 #define SLAPI_FAIL_DISKFULL -2 #define SLAPI_FAIL_GENERAL -1 #define SLAPI_PLUGIN_EXTENDED_NOT_HANDLED -2 #define SLAPI_BIND_SUCCESS 0 #define SLAPI_BIND_FAIL 2 #define SLAPI_BIND_ANONYMOUS 3 / Search result params / #define SLAPI_SEARCH_RESULT_SET 193 #define SLAPI_SEARCH_RESULT_ENTRY 194 #define SLAPI_NENTRIES 195 #define SLAPI_SEARCH_REFERRALS 196 / filter types / #ifndef LDAP_FILTER_AND #define LDAP_FILTER_AND 0xa0L #endif #ifndef LDAP_FILTER_OR #define LDAP_FILTER_OR 0xa1L #endif #ifndef LDAP_FILTER_NOT #define LDAP_FILTER_NOT 0xa2L #endif #ifndef LDAP_FILTER_EQUALITY #define LDAP_FILTER_EQUALITY 0xa3L #endif #ifndef LDAP_FILTER_SUBSTRINGS #define LDAP_FILTER_SUBSTRINGS 0xa4L #endif #ifndef LDAP_FILTER_GE #define LDAP_FILTER_GE 0xa5L #endif #ifndef LDAP_FILTER_LE #define LDAP_FILTER_LE 0xa6L #endif #ifndef LDAP_FILTER_PRESENT #define LDAP_FILTER_PRESENT 0x87L #endif #ifndef LDAP_FILTER_APPROX #define LDAP_FILTER_APPROX 0xa8L #endif #ifndef LDAP_FILTER_EXT_MATCH #define LDAP_FILTER_EXT_MATCH 0xa9L #endif int slapi_log_error( int severity, char subsystem, char fmt, ... ); #define SLAPI_LOG_FATAL 0 #define SLAPI_LOG_TRACE 1 #define SLAPI_LOG_PACKETS 2 #define SLAPI_LOG_ARGS 3 #define SLAPI_LOG_CONNS 4 #define SLAPI_LOG_BER 5 #define SLAPI_LOG_FILTER 6 #define SLAPI_LOG_CONFIG 7 #define SLAPI_LOG_ACL 8 #define SLAPI_LOG_SHELL 9 #define SLAPI_LOG_PARSE 10 #define SLAPI_LOG_HOUSE 11 #define SLAPI_LOG_REPL 12 #define SLAPI_LOG_CACHE 13 #define SLAPI_LOG_PLUGIN 14 #define SLAPI_LOG_TIMING 15 #define SLAPI_PLUGIN_DESCRIPTION 12 typedef struct slapi_plugindesc { char spd_id; char spd_vendor; char spd_version; char spd_description; } Slapi_PluginDesc; #define SLAPI_PLUGIN_VERSION_01 "01" #define SLAPI_PLUGIN_VERSION_02 "02" #define SLAPI_PLUGIN_VERSION_03 "03" #define SLAPI_PLUGIN_CURRENT_VERSION SLAPI_PLUGIN_VERSION_03 #endif / _SLAPI_PLUGIN_H */	37.45 KB	2024-05-21 17:19
📁 sound	-	2026-03-27 02:43
📄 spawn.h /* Definitions for POSIX spawn interface. Copyright (C) 2000-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _SPAWN_H #define _SPAWN_H 1 #include <features.h> #include <sched.h> #include <sys/types.h> #include <bits/types/sigset_t.h> / Data structure to contain attributes for thread creation. / typedef struct { short int __flags; pid_t __pgrp; sigset_t __sd; sigset_t __ss; struct sched_param __sp; int __policy; int __pad[16]; } posix_spawnattr_t; / Data structure to contain information about the actions to be performed in the new process with respect to file descriptors. / typedef struct { int __allocated; int __used; struct __spawn_action __actions; int __pad[16]; } posix_spawn_file_actions_t; /* Flags to be set in the `posix_spawnattr_t'. / #define POSIX_SPAWN_RESETIDS 0x01 #define POSIX_SPAWN_SETPGROUP 0x02 #define POSIX_SPAWN_SETSIGDEF 0x04 #define POSIX_SPAWN_SETSIGMASK 0x08 #define POSIX_SPAWN_SETSCHEDPARAM 0x10 #define POSIX_SPAWN_SETSCHEDULER 0x20 #ifdef __USE_GNU # define POSIX_SPAWN_USEVFORK 0x40 # define POSIX_SPAWN_SETSID 0x80 #endif __BEGIN_DECLS / Spawn a new process executing PATH with the attributes describes in ATTRP. Before running the process perform the actions described in FILE-ACTIONS. This function is a possible cancellation point and therefore not marked with __THROW. / extern int posix_spawn (pid_t __restrict __pid, const char __restrict __path, const posix_spawn_file_actions_t __restrict __file_actions, const posix_spawnattr_t __restrict __attrp, char const __argv[__restrict_arr], char const __envp[__restrict_arr]) __nonnull ((2, 5)); /* Similar to `posix_spawn' but search for FILE in the PATH. This function is a possible cancellation point and therefore not marked with __THROW. / extern int posix_spawnp (pid_t __pid, const char __file, const posix_spawn_file_actions_t __file_actions, const posix_spawnattr_t __attrp, char const __argv[], char const __envp[]) __nonnull ((2, 5)); / Initialize data structure with attributes for `spawn' to default values. / extern int posix_spawnattr_init (posix_spawnattr_t __attr) __THROW __nonnull ((1)); /* Free resources associated with ATTR. / extern int posix_spawnattr_destroy (posix_spawnattr_t __attr) __THROW __nonnull ((1)); /* Store signal mask for signals with default handling from ATTR in SIGDEFAULT. / extern int posix_spawnattr_getsigdefault (const posix_spawnattr_t __restrict __attr, sigset_t __restrict __sigdefault) __THROW __nonnull ((1, 2)); / Set signal mask for signals with default handling in ATTR to SIGDEFAULT. / extern int posix_spawnattr_setsigdefault (posix_spawnattr_t __restrict __attr, const sigset_t __restrict __sigdefault) __THROW __nonnull ((1, 2)); / Store signal mask for the new process from ATTR in SIGMASK. / extern int posix_spawnattr_getsigmask (const posix_spawnattr_t __restrict __attr, sigset_t __restrict __sigmask) __THROW __nonnull ((1, 2)); / Set signal mask for the new process in ATTR to SIGMASK. / extern int posix_spawnattr_setsigmask (posix_spawnattr_t __restrict __attr, const sigset_t __restrict __sigmask) __THROW __nonnull ((1, 2)); / Get flag word from the attribute structure. / extern int posix_spawnattr_getflags (const posix_spawnattr_t __restrict __attr, short int __restrict __flags) __THROW __nonnull ((1, 2)); / Store flags in the attribute structure. / extern int posix_spawnattr_setflags (posix_spawnattr_t _attr, short int __flags) __THROW __nonnull ((1)); /* Get process group ID from the attribute structure. / extern int posix_spawnattr_getpgroup (const posix_spawnattr_t __restrict __attr, pid_t __restrict __pgroup) __THROW __nonnull ((1, 2)); / Store process group ID in the attribute structure. / extern int posix_spawnattr_setpgroup (posix_spawnattr_t __attr, pid_t __pgroup) __THROW __nonnull ((1)); /* Get scheduling policy from the attribute structure. / extern int posix_spawnattr_getschedpolicy (const posix_spawnattr_t __restrict __attr, int __restrict __schedpolicy) __THROW __nonnull ((1, 2)); / Store scheduling policy in the attribute structure. / extern int posix_spawnattr_setschedpolicy (posix_spawnattr_t __attr, int __schedpolicy) __THROW __nonnull ((1)); /* Get scheduling parameters from the attribute structure. / extern int posix_spawnattr_getschedparam (const posix_spawnattr_t __restrict __attr, struct sched_param __restrict __schedparam) __THROW __nonnull ((1, 2)); / Store scheduling parameters in the attribute structure. / extern int posix_spawnattr_setschedparam (posix_spawnattr_t __restrict __attr, const struct sched_param * __restrict __schedparam) __THROW __nonnull ((1, 2)); /* Initialize data structure for file attribute for `spawn' call. / extern int posix_spawn_file_actions_init (posix_spawn_file_actions_t __file_actions) __THROW __nonnull ((1)); /* Free resources associated with FILE-ACTIONS. / extern int posix_spawn_file_actions_destroy (posix_spawn_file_actions_t __file_actions) __THROW __nonnull ((1)); /* Add an action to FILE-ACTIONS which tells the implementation to call `open' for the given file during the `spawn' call. / extern int posix_spawn_file_actions_addopen (posix_spawn_file_actions_t __restrict __file_actions, int __fd, const char __restrict __path, int __oflag, mode_t __mode) __THROW __nonnull ((1, 3)); / Add an action to FILE-ACTIONS which tells the implementation to call `close' for the given file descriptor during the `spawn' call. / extern int posix_spawn_file_actions_addclose (posix_spawn_file_actions_t __file_actions, int __fd) __THROW __nonnull ((1)); /* Add an action to FILE-ACTIONS which tells the implementation to call `dup2' for the given file descriptors during the `spawn' call. / extern int posix_spawn_file_actions_adddup2 (posix_spawn_file_actions_t __file_actions, int __fd, int __newfd) __THROW __nonnull ((1)); #ifdef __USE_MISC /* Add an action changing the directory to PATH during spawn. This affects the subsequent file actions. / extern int posix_spawn_file_actions_addchdir_np (posix_spawn_file_actions_t __restrict __actions, const char __restrict __path) __THROW __nonnull ((1, 2)); / Add an action changing the directory to FD during spawn. This affects the subsequent file actions. FD is not duplicated and must be open when the file action is executed. / extern int posix_spawn_file_actions_addfchdir_np (posix_spawn_file_actions_t , int __fd) __THROW __nonnull ((1)); /* Add an action to close all file descriptor greater than or equal to FROM during spawn. This affects the subsequent file actions. / extern int posix_spawn_file_actions_addclosefrom_np (posix_spawn_file_actions_t , int __from) __THROW __nonnull ((1)); /* Add an action to set the process group of the forground process group associated with the terminal TCFD. / extern int posix_spawn_file_actions_addtcsetpgrp_np (posix_spawn_file_actions_t , int __tcfd) __THROW __nonnull ((1)); #endif /* __USE_MISC / __END_DECLS #endif / spawn.h */	8.1 KB	2026-02-17 11:01
📄 stab.h #ifndef __GNU_STAB__ /* Indicate the GNU stab.h is in use. / #define __GNU_STAB__ #define __define_stab(NAME, CODE, STRING) NAME=CODE, enum __stab_debug_code { #include <bits/stab.def> LAST_UNUSED_STAB_CODE }; #undef __define_stab #endif / __GNU_STAB_ */	264 B	2026-02-17 11:01
📄 stdc-predef.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _STDC_PREDEF_H #define _STDC_PREDEF_H 1 / This header is separate from features.h so that the compiler can include it implicitly at the start of every compilation. It must not itself include <features.h> or any other header that includes <features.h> because the implicit include comes before any feature test macros that may be defined in a source file before it first explicitly includes a system header. GCC knows the name of this header in order to preinclude it. / / glibc's intent is to support the IEC 559 math functionality, real and complex. If the GCC (4.9 and later) predefined macros specifying compiler intent are available, use them to determine whether the overall intent is to support these features; otherwise, presume an older compiler has intent to support these features and define these macros by default. / #ifdef __GCC_IEC_559 # if __GCC_IEC_559 > 0 # define __STDC_IEC_559__ 1 # endif #else # define __STDC_IEC_559__ 1 #endif #ifdef __GCC_IEC_559_COMPLEX # if __GCC_IEC_559_COMPLEX > 0 # define __STDC_IEC_559_COMPLEX__ 1 # endif #else # define __STDC_IEC_559_COMPLEX__ 1 #endif / wchar_t uses Unicode 10.0.0. Version 10.0 of the Unicode Standard is synchronized with ISO/IEC 10646:2017, fifth edition, plus the following additions from Amendment 1 to the fifth edition: - 56 emoji characters - 285 hentaigana - 3 additional Zanabazar Square characters */ #define __STDC_ISO_10646__ 201706L #endif	2.24 KB	2026-02-17 11:01
📄 stdint.h /* Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99: 7.18 Integer types <stdint.h> / #ifndef _STDINT_H #define _STDINT_H 1 #define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION #include <bits/libc-header-start.h> #include <bits/types.h> #include <bits/wchar.h> #include <bits/wordsize.h> / Exact integral types. / / Signed. / #include <bits/stdint-intn.h> / Unsigned. / #include <bits/stdint-uintn.h> / Small types. / / Signed. / typedef __int_least8_t int_least8_t; typedef __int_least16_t int_least16_t; typedef __int_least32_t int_least32_t; typedef __int_least64_t int_least64_t; / Unsigned. / typedef __uint_least8_t uint_least8_t; typedef __uint_least16_t uint_least16_t; typedef __uint_least32_t uint_least32_t; typedef __uint_least64_t uint_least64_t; / Fast types. / / Signed. / typedef signed char int_fast8_t; #if __WORDSIZE == 64 typedef long int int_fast16_t; typedef long int int_fast32_t; typedef long int int_fast64_t; #else typedef int int_fast16_t; typedef int int_fast32_t; __extension__ typedef long long int int_fast64_t; #endif / Unsigned. / typedef unsigned char uint_fast8_t; #if __WORDSIZE == 64 typedef unsigned long int uint_fast16_t; typedef unsigned long int uint_fast32_t; typedef unsigned long int uint_fast64_t; #else typedef unsigned int uint_fast16_t; typedef unsigned int uint_fast32_t; __extension__ typedef unsigned long long int uint_fast64_t; #endif / Types for `void ' pointers. / #if __WORDSIZE == 64 # ifndef __intptr_t_defined typedef long int intptr_t; # define __intptr_t_defined # endif typedef unsigned long int uintptr_t; #else # ifndef __intptr_t_defined typedef int intptr_t; # define __intptr_t_defined # endif typedef unsigned int uintptr_t; #endif /* Largest integral types. / typedef __intmax_t intmax_t; typedef __uintmax_t uintmax_t; # if __WORDSIZE == 64 # define __INT64_C(c) c ## L # define __UINT64_C(c) c ## UL # else # define __INT64_C(c) c ## LL # define __UINT64_C(c) c ## ULL # endif / Limits of integral types. / / Minimum of signed integral types. / # define INT8_MIN (-128) # define INT16_MIN (-32767-1) # define INT32_MIN (-2147483647-1) # define INT64_MIN (-__INT64_C(9223372036854775807)-1) / Maximum of signed integral types. / # define INT8_MAX (127) # define INT16_MAX (32767) # define INT32_MAX (2147483647) # define INT64_MAX (__INT64_C(9223372036854775807)) / Maximum of unsigned integral types. / # define UINT8_MAX (255) # define UINT16_MAX (65535) # define UINT32_MAX (4294967295U) # define UINT64_MAX (__UINT64_C(18446744073709551615)) / Minimum of signed integral types having a minimum size. / # define INT_LEAST8_MIN (-128) # define INT_LEAST16_MIN (-32767-1) # define INT_LEAST32_MIN (-2147483647-1) # define INT_LEAST64_MIN (-__INT64_C(9223372036854775807)-1) / Maximum of signed integral types having a minimum size. / # define INT_LEAST8_MAX (127) # define INT_LEAST16_MAX (32767) # define INT_LEAST32_MAX (2147483647) # define INT_LEAST64_MAX (__INT64_C(9223372036854775807)) / Maximum of unsigned integral types having a minimum size. / # define UINT_LEAST8_MAX (255) # define UINT_LEAST16_MAX (65535) # define UINT_LEAST32_MAX (4294967295U) # define UINT_LEAST64_MAX (__UINT64_C(18446744073709551615)) / Minimum of fast signed integral types having a minimum size. / # define INT_FAST8_MIN (-128) # if __WORDSIZE == 64 # define INT_FAST16_MIN (-9223372036854775807L-1) # define INT_FAST32_MIN (-9223372036854775807L-1) # else # define INT_FAST16_MIN (-2147483647-1) # define INT_FAST32_MIN (-2147483647-1) # endif # define INT_FAST64_MIN (-__INT64_C(9223372036854775807)-1) / Maximum of fast signed integral types having a minimum size. / # define INT_FAST8_MAX (127) # if __WORDSIZE == 64 # define INT_FAST16_MAX (9223372036854775807L) # define INT_FAST32_MAX (9223372036854775807L) # else # define INT_FAST16_MAX (2147483647) # define INT_FAST32_MAX (2147483647) # endif # define INT_FAST64_MAX (__INT64_C(9223372036854775807)) / Maximum of fast unsigned integral types having a minimum size. / # define UINT_FAST8_MAX (255) # if __WORDSIZE == 64 # define UINT_FAST16_MAX (18446744073709551615UL) # define UINT_FAST32_MAX (18446744073709551615UL) # else # define UINT_FAST16_MAX (4294967295U) # define UINT_FAST32_MAX (4294967295U) # endif # define UINT_FAST64_MAX (__UINT64_C(18446744073709551615)) / Values to test for integral types holding `void ' pointer. / # if __WORDSIZE == 64 # define INTPTR_MIN (-9223372036854775807L-1) # define INTPTR_MAX (9223372036854775807L) # define UINTPTR_MAX (18446744073709551615UL) # else # define INTPTR_MIN (-2147483647-1) # define INTPTR_MAX (2147483647) # define UINTPTR_MAX (4294967295U) # endif /* Minimum for largest signed integral type. / # define INTMAX_MIN (-__INT64_C(9223372036854775807)-1) / Maximum for largest signed integral type. / # define INTMAX_MAX (__INT64_C(9223372036854775807)) / Maximum for largest unsigned integral type. / # define UINTMAX_MAX (__UINT64_C(18446744073709551615)) / Limits of other integer types. / / Limits of `ptrdiff_t' type. / # if __WORDSIZE == 64 # define PTRDIFF_MIN (-9223372036854775807L-1) # define PTRDIFF_MAX (9223372036854775807L) # else # if __WORDSIZE32_PTRDIFF_LONG # define PTRDIFF_MIN (-2147483647L-1) # define PTRDIFF_MAX (2147483647L) # else # define PTRDIFF_MIN (-2147483647-1) # define PTRDIFF_MAX (2147483647) # endif # endif / Limits of `sig_atomic_t'. / # define SIG_ATOMIC_MIN (-2147483647-1) # define SIG_ATOMIC_MAX (2147483647) / Limit of `size_t' type. / # if __WORDSIZE == 64 # define SIZE_MAX (18446744073709551615UL) # else # if __WORDSIZE32_SIZE_ULONG # define SIZE_MAX (4294967295UL) # else # define SIZE_MAX (4294967295U) # endif # endif / Limits of `wchar_t'. / # ifndef WCHAR_MIN / These constants might also be defined in <wchar.h>. / # define WCHAR_MIN __WCHAR_MIN # define WCHAR_MAX __WCHAR_MAX # endif / Limits of `wint_t'. / # define WINT_MIN (0u) # define WINT_MAX (4294967295u) / Signed. / # define INT8_C(c) c # define INT16_C(c) c # define INT32_C(c) c # if __WORDSIZE == 64 # define INT64_C(c) c ## L # else # define INT64_C(c) c ## LL # endif / Unsigned. / # define UINT8_C(c) c # define UINT16_C(c) c # define UINT32_C(c) c ## U # if __WORDSIZE == 64 # define UINT64_C(c) c ## UL # else # define UINT64_C(c) c ## ULL # endif / Maximal type. / # if __WORDSIZE == 64 # define INTMAX_C(c) c ## L # define UINTMAX_C(c) c ## UL # else # define INTMAX_C(c) c ## LL # define UINTMAX_C(c) c ## ULL # endif #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) # define INT8_WIDTH 8 # define UINT8_WIDTH 8 # define INT16_WIDTH 16 # define UINT16_WIDTH 16 # define INT32_WIDTH 32 # define UINT32_WIDTH 32 # define INT64_WIDTH 64 # define UINT64_WIDTH 64 # define INT_LEAST8_WIDTH 8 # define UINT_LEAST8_WIDTH 8 # define INT_LEAST16_WIDTH 16 # define UINT_LEAST16_WIDTH 16 # define INT_LEAST32_WIDTH 32 # define UINT_LEAST32_WIDTH 32 # define INT_LEAST64_WIDTH 64 # define UINT_LEAST64_WIDTH 64 # define INT_FAST8_WIDTH 8 # define UINT_FAST8_WIDTH 8 # define INT_FAST16_WIDTH __WORDSIZE # define UINT_FAST16_WIDTH __WORDSIZE # define INT_FAST32_WIDTH __WORDSIZE # define UINT_FAST32_WIDTH __WORDSIZE # define INT_FAST64_WIDTH 64 # define UINT_FAST64_WIDTH 64 # define INTPTR_WIDTH __WORDSIZE # define UINTPTR_WIDTH __WORDSIZE # define INTMAX_WIDTH 64 # define UINTMAX_WIDTH 64 # define PTRDIFF_WIDTH __WORDSIZE # define SIG_ATOMIC_WIDTH 32 # define SIZE_WIDTH __WORDSIZE # define WCHAR_WIDTH 32 # define WINT_WIDTH 32 #endif #endif / stdint.h */	8.28 KB	2026-02-17 11:01
📄 stdio.h /* Define ISO C stdio on top of C++ iostreams. Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99 Standard: 7.19 Input/output <stdio.h> / #ifndef _STDIO_H #define _STDIO_H 1 #define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION #include <bits/libc-header-start.h> __BEGIN_DECLS #define __need_size_t #define __need_NULL #include <stddef.h> #define __need___va_list #include <stdarg.h> #include <bits/types.h> #include <bits/types/__fpos_t.h> #include <bits/types/__fpos64_t.h> #include <bits/types/__FILE.h> #include <bits/types/FILE.h> #include <bits/types/struct_FILE.h> #ifdef __USE_GNU # include <bits/types/cookie_io_functions_t.h> #endif #if defined __USE_XOPEN \|\| defined __USE_XOPEN2K8 # ifdef __GNUC__ # ifndef _VA_LIST_DEFINED typedef __gnuc_va_list va_list; # define _VA_LIST_DEFINED # endif # else # include <stdarg.h> # endif #endif #if defined __USE_UNIX98 \|\| defined __USE_XOPEN2K # ifndef __off_t_defined # ifndef __USE_FILE_OFFSET64 typedef __off_t off_t; # else typedef __off64_t off_t; # endif # define __off_t_defined # endif # if defined __USE_LARGEFILE64 && !defined __off64_t_defined typedef __off64_t off64_t; # define __off64_t_defined # endif #endif #ifdef __USE_XOPEN2K8 # ifndef __ssize_t_defined typedef __ssize_t ssize_t; # define __ssize_t_defined # endif #endif / The type of the second argument to `fgetpos' and `fsetpos'. / #ifndef __USE_FILE_OFFSET64 typedef __fpos_t fpos_t; #else typedef __fpos64_t fpos_t; #endif #ifdef __USE_LARGEFILE64 typedef __fpos64_t fpos64_t; #endif / The possibilities for the third argument to `setvbuf'. / #define _IOFBF 0 / Fully buffered. / #define _IOLBF 1 / Line buffered. / #define _IONBF 2 / No buffering. / / Default buffer size. / #define BUFSIZ 8192 / The value returned by fgetc and similar functions to indicate the end of the file. / #define EOF (-1) / The possibilities for the third argument to `fseek'. These values should not be changed. / #define SEEK_SET 0 / Seek from beginning of file. / #define SEEK_CUR 1 / Seek from current position. / #define SEEK_END 2 / Seek from end of file. / #ifdef __USE_GNU # define SEEK_DATA 3 / Seek to next data. / # define SEEK_HOLE 4 / Seek to next hole. / #endif #if defined __USE_MISC \|\| defined __USE_XOPEN / Default path prefix for `tempnam' and `tmpnam'. / # define P_tmpdir "/tmp" #endif / Get the values: L_tmpnam How long an array of chars must be to be passed to `tmpnam'. TMP_MAX The minimum number of unique filenames generated by tmpnam (and tempnam when it uses tmpnam's name space), or tempnam (the two are separate). L_ctermid How long an array to pass to `ctermid'. L_cuserid How long an array to pass to `cuserid'. FOPEN_MAX Minimum number of files that can be open at once. FILENAME_MAX Maximum length of a filename. / #include <bits/stdio_lim.h> / Standard streams. / extern FILE stdin; /* Standard input stream. / extern FILE stdout; /* Standard output stream. / extern FILE stderr; /* Standard error output stream. / / C89/C99 say they're macros. Make them happy. / #define stdin stdin #define stdout stdout #define stderr stderr / Remove file FILENAME. / extern int remove (const char __filename) __THROW; /* Rename file OLD to NEW. / extern int rename (const char __old, const char __new) __THROW; #ifdef __USE_ATFILE / Rename file OLD relative to OLDFD to NEW relative to NEWFD. / extern int renameat (int __oldfd, const char __old, int __newfd, const char __new) __THROW; #endif #ifdef __USE_GNU / Flags for renameat2. / # define RENAME_NOREPLACE (1 << 0) # define RENAME_EXCHANGE (1 << 1) # define RENAME_WHITEOUT (1 << 2) / Rename file OLD relative to OLDFD to NEW relative to NEWFD, with additional flags. / extern int renameat2 (int __oldfd, const char __old, int __newfd, const char __new, unsigned int __flags) __THROW; #endif / Close STREAM. This function is a possible cancellation point and therefore not marked with __THROW. / extern int fclose (FILE __stream); #undef __attr_dealloc_fclose #define __attr_dealloc_fclose __attr_dealloc (fclose, 1) /* Create a temporary file and open it read/write. This function is a possible cancellation point and therefore not marked with __THROW. / #ifndef __USE_FILE_OFFSET64 extern FILE tmpfile (void) __attribute_malloc__ __attr_dealloc_fclose __wur; #else # ifdef __REDIRECT extern FILE __REDIRECT (tmpfile, (void), tmpfile64) __attribute_malloc__ __attr_dealloc_fclose __wur; # else # define tmpfile tmpfile64 # endif #endif #ifdef __USE_LARGEFILE64 extern FILE tmpfile64 (void) __attribute_malloc__ __attr_dealloc_fclose __wur; #endif /* Generate a temporary filename. / extern char tmpnam (char[L_tmpnam]) __THROW __wur; #ifdef __USE_MISC /* This is the reentrant variant of `tmpnam'. The only difference is that it does not allow S to be NULL. / extern char tmpnam_r (char __s[L_tmpnam]) __THROW __wur; #endif #if defined __USE_MISC \|\| defined __USE_XOPEN /* Generate a unique temporary filename using up to five characters of PFX if it is not NULL. The directory to put this file in is searched for as follows: First the environment variable "TMPDIR" is checked. If it contains the name of a writable directory, that directory is used. If not and if DIR is not NULL, that value is checked. If that fails, P_tmpdir is tried and finally "/tmp". The storage for the filename is allocated by `malloc'. / extern char tempnam (const char __dir, const char __pfx) __THROW __attribute_malloc__ __wur __attr_dealloc_free; #endif /* Flush STREAM, or all streams if STREAM is NULL. This function is a possible cancellation point and therefore not marked with __THROW. / extern int fflush (FILE __stream); #ifdef __USE_MISC /* Faster versions when locking is not required. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int fflush_unlocked (FILE __stream); #endif #ifdef __USE_GNU /* Close all streams. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int fcloseall (void); #endif #ifndef __USE_FILE_OFFSET64 / Open a file and create a new stream for it. This function is a possible cancellation point and therefore not marked with __THROW. / extern FILE fopen (const char __restrict __filename, const char __restrict __modes) __attribute_malloc__ __attr_dealloc_fclose __wur; /* Open a file, replacing an existing stream with it. This function is a possible cancellation point and therefore not marked with __THROW. / extern FILE freopen (const char __restrict __filename, const char __restrict __modes, FILE __restrict __stream) __wur; #else # ifdef __REDIRECT extern FILE __REDIRECT (fopen, (const char __restrict __filename, const char __restrict __modes), fopen64) __attribute_malloc__ __attr_dealloc_fclose __wur; extern FILE __REDIRECT (freopen, (const char __restrict __filename, const char __restrict __modes, FILE __restrict __stream), freopen64) __wur; # else # define fopen fopen64 # define freopen freopen64 # endif #endif #ifdef __USE_LARGEFILE64 extern FILE fopen64 (const char __restrict __filename, const char __restrict __modes) __attribute_malloc__ __attr_dealloc_fclose __wur; extern FILE freopen64 (const char __restrict __filename, const char __restrict __modes, FILE __restrict __stream) __wur; #endif #ifdef __USE_POSIX / Create a new stream that refers to an existing system file descriptor. / extern FILE fdopen (int __fd, const char __modes) __THROW __attribute_malloc__ __attr_dealloc_fclose __wur; #endif #ifdef __USE_GNU / Create a new stream that refers to the given magic cookie, and uses the given functions for input and output. / extern FILE fopencookie (void __restrict __magic_cookie, const char __restrict __modes, cookie_io_functions_t __io_funcs) __THROW __attribute_malloc__ __attr_dealloc_fclose __wur; #endif #if defined __USE_XOPEN2K8 \|\| __GLIBC_USE (LIB_EXT2) /* Create a new stream that refers to a memory buffer. / extern FILE fmemopen (void __s, size_t __len, const char __modes) __THROW __attribute_malloc__ __attr_dealloc_fclose __wur; /* Open a stream that writes into a malloc'd buffer that is expanded as necessary. BUFLOC and SIZELOC are updated with the buffer's location and the number of characters written on fflush or fclose. / extern FILE open_memstream (char *__bufloc, size_t __sizeloc) __THROW __attribute_malloc__ __attr_dealloc_fclose __wur; #ifdef _WCHAR_H /* Like OPEN_MEMSTREAM, but the stream is wide oriented and produces a wide character string. Declared here only to add attribute malloc and only if <wchar.h> has been previously #included. / extern __FILE open_wmemstream (wchar_t *__bufloc, size_t __sizeloc) __THROW __attribute_malloc__ __attr_dealloc_fclose; # endif #endif /* If BUF is NULL, make STREAM unbuffered. Else make it use buffer BUF, of size BUFSIZ. / extern void setbuf (FILE __restrict __stream, char __restrict __buf) __THROW; / Make STREAM use buffering mode MODE. If BUF is not NULL, use N bytes of it for buffering; else allocate an internal buffer N bytes long. / extern int setvbuf (FILE __restrict __stream, char __restrict __buf, int __modes, size_t __n) __THROW; #ifdef __USE_MISC / If BUF is NULL, make STREAM unbuffered. Else make it use SIZE bytes of BUF for buffering. / extern void setbuffer (FILE __restrict __stream, char __restrict __buf, size_t __size) __THROW; / Make STREAM line-buffered. / extern void setlinebuf (FILE __stream) __THROW; #endif /* Write formatted output to STREAM. This function is a possible cancellation point and therefore not marked with __THROW. / extern int fprintf (FILE __restrict __stream, const char __restrict __format, ...); / Write formatted output to stdout. This function is a possible cancellation point and therefore not marked with __THROW. / extern int printf (const char __restrict __format, ...); /* Write formatted output to S. / extern int sprintf (char __restrict __s, const char __restrict __format, ...) __THROWNL; / Write formatted output to S from argument list ARG. This function is a possible cancellation point and therefore not marked with __THROW. / extern int vfprintf (FILE __restrict __s, const char __restrict __format, __gnuc_va_list __arg); / Write formatted output to stdout from argument list ARG. This function is a possible cancellation point and therefore not marked with __THROW. / extern int vprintf (const char __restrict __format, __gnuc_va_list __arg); /* Write formatted output to S from argument list ARG. / extern int vsprintf (char __restrict __s, const char __restrict __format, __gnuc_va_list __arg) __THROWNL; #if defined __USE_ISOC99 \|\| defined __USE_UNIX98 / Maximum chars of output to write in MAXLEN. / extern int snprintf (char __restrict __s, size_t __maxlen, const char __restrict __format, ...) __THROWNL __attribute__ ((__format__ (__printf__, 3, 4))); extern int vsnprintf (char __restrict __s, size_t __maxlen, const char __restrict __format, __gnuc_va_list __arg) __THROWNL __attribute__ ((__format__ (__printf__, 3, 0))); #endif #if __GLIBC_USE (LIB_EXT2) / Write formatted output to a string dynamically allocated with `malloc'. Store the address of the string in PTR. / extern int vasprintf (char *__restrict __ptr, const char __restrict __f, __gnuc_va_list __arg) __THROWNL __attribute__ ((__format__ (__printf__, 2, 0))) __wur; extern int __asprintf (char *__restrict __ptr, const char __restrict __fmt, ...) __THROWNL __attribute__ ((__format__ (__printf__, 2, 3))) __wur; extern int asprintf (char *__restrict __ptr, const char __restrict __fmt, ...) __THROWNL __attribute__ ((__format__ (__printf__, 2, 3))) __wur; #endif #ifdef __USE_XOPEN2K8 /* Write formatted output to a file descriptor. / extern int vdprintf (int __fd, const char __restrict __fmt, __gnuc_va_list __arg) __attribute__ ((__format__ (__printf__, 2, 0))); extern int dprintf (int __fd, const char __restrict __fmt, ...) __attribute__ ((__format__ (__printf__, 2, 3))); #endif / Read formatted input from STREAM. This function is a possible cancellation point and therefore not marked with __THROW. / extern int fscanf (FILE __restrict __stream, const char __restrict __format, ...) __wur; / Read formatted input from stdin. This function is a possible cancellation point and therefore not marked with __THROW. / extern int scanf (const char __restrict __format, ...) __wur; /* Read formatted input from S. / extern int sscanf (const char __restrict __s, const char __restrict __format, ...) __THROW; / For historical reasons, the C99-compliant versions of the scanf functions are at alternative names. When __LDBL_COMPAT or __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI are in effect, this is handled in bits/stdio-ldbl.h. / #include <bits/floatn.h> #if !__GLIBC_USE (DEPRECATED_SCANF) && !defined __LDBL_COMPAT \ && __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 0 # ifdef __REDIRECT extern int __REDIRECT (fscanf, (FILE __restrict __stream, const char __restrict __format, ...), __isoc99_fscanf) __wur; extern int __REDIRECT (scanf, (const char __restrict __format, ...), __isoc99_scanf) __wur; extern int __REDIRECT_NTH (sscanf, (const char __restrict __s, const char __restrict __format, ...), __isoc99_sscanf); # else extern int __isoc99_fscanf (FILE __restrict __stream, const char __restrict __format, ...) __wur; extern int __isoc99_scanf (const char __restrict __format, ...) __wur; extern int __isoc99_sscanf (const char __restrict __s, const char __restrict __format, ...) __THROW; # define fscanf __isoc99_fscanf # define scanf __isoc99_scanf # define sscanf __isoc99_sscanf # endif #endif #ifdef __USE_ISOC99 / Read formatted input from S into argument list ARG. This function is a possible cancellation point and therefore not marked with __THROW. / extern int vfscanf (FILE __restrict __s, const char __restrict __format, __gnuc_va_list __arg) __attribute__ ((__format__ (__scanf__, 2, 0))) __wur; / Read formatted input from stdin into argument list ARG. This function is a possible cancellation point and therefore not marked with __THROW. / extern int vscanf (const char __restrict __format, __gnuc_va_list __arg) __attribute__ ((__format__ (__scanf__, 1, 0))) __wur; /* Read formatted input from S into argument list ARG. / extern int vsscanf (const char __restrict __s, const char __restrict __format, __gnuc_va_list __arg) __THROW __attribute__ ((__format__ (__scanf__, 2, 0))); / Same redirection as above for the vscanf family. / # if !__GLIBC_USE (DEPRECATED_SCANF) # if defined __REDIRECT && !defined __LDBL_COMPAT \ && __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 0 extern int __REDIRECT (vfscanf, (FILE __restrict __s, const char __restrict __format, __gnuc_va_list __arg), __isoc99_vfscanf) __attribute__ ((__format__ (__scanf__, 2, 0))) __wur; extern int __REDIRECT (vscanf, (const char __restrict __format, __gnuc_va_list __arg), __isoc99_vscanf) __attribute__ ((__format__ (__scanf__, 1, 0))) __wur; extern int __REDIRECT_NTH (vsscanf, (const char __restrict __s, const char __restrict __format, __gnuc_va_list __arg), __isoc99_vsscanf) __attribute__ ((__format__ (__scanf__, 2, 0))); # elif !defined __REDIRECT extern int __isoc99_vfscanf (FILE __restrict __s, const char __restrict __format, __gnuc_va_list __arg) __wur; extern int __isoc99_vscanf (const char __restrict __format, __gnuc_va_list __arg) __wur; extern int __isoc99_vsscanf (const char __restrict __s, const char __restrict __format, __gnuc_va_list __arg) __THROW; # define vfscanf __isoc99_vfscanf # define vscanf __isoc99_vscanf # define vsscanf __isoc99_vsscanf # endif # endif #endif /* Use ISO C9x. / / Read a character from STREAM. These functions are possible cancellation points and therefore not marked with __THROW. / extern int fgetc (FILE __stream); extern int getc (FILE __stream); / Read a character from stdin. This function is a possible cancellation point and therefore not marked with __THROW. / extern int getchar (void); #ifdef __USE_POSIX199506 / These are defined in POSIX.1:1996. These functions are possible cancellation points and therefore not marked with __THROW. / extern int getc_unlocked (FILE __stream); extern int getchar_unlocked (void); #endif /* Use POSIX. / #ifdef __USE_MISC / Faster version when locking is not necessary. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int fgetc_unlocked (FILE __stream); #endif /* Use MISC. / / Write a character to STREAM. These functions are possible cancellation points and therefore not marked with __THROW. These functions is a possible cancellation point and therefore not marked with __THROW. / extern int fputc (int __c, FILE __stream); extern int putc (int __c, FILE __stream); / Write a character to stdout. This function is a possible cancellation point and therefore not marked with __THROW. / extern int putchar (int __c); #ifdef __USE_MISC / Faster version when locking is not necessary. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int fputc_unlocked (int __c, FILE __stream); #endif /* Use MISC. / #ifdef __USE_POSIX199506 / These are defined in POSIX.1:1996. These functions are possible cancellation points and therefore not marked with __THROW. / extern int putc_unlocked (int __c, FILE __stream); extern int putchar_unlocked (int __c); #endif /* Use POSIX. / #if defined __USE_MISC \ \|\| (defined __USE_XOPEN && !defined __USE_XOPEN2K) / Get a word (int) from STREAM. / extern int getw (FILE __stream); /* Write a word (int) to STREAM. / extern int putw (int __w, FILE __stream); #endif /* Get a newline-terminated string of finite length from STREAM. This function is a possible cancellation point and therefore not marked with __THROW. / extern char fgets (char __restrict __s, int __n, FILE __restrict __stream) __wur __fortified_attr_access (__write_only__, 1, 2); #if __GLIBC_USE (DEPRECATED_GETS) /* Get a newline-terminated string from stdin, removing the newline. This function is impossible to use safely. It has been officially removed from ISO C11 and ISO C++14, and we have also removed it from the _GNU_SOURCE feature list. It remains available when explicitly using an old ISO C, Unix, or POSIX standard. This function is a possible cancellation point and therefore not marked with __THROW. / extern char gets (char __s) __wur __attribute_deprecated__; #endif #ifdef __USE_GNU / This function does the same as `fgets' but does not lock the stream. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern char fgets_unlocked (char __restrict __s, int __n, FILE __restrict __stream) __wur __fortified_attr_access (__write_only__, 1, 2); #endif #if defined __USE_XOPEN2K8 \|\| __GLIBC_USE (LIB_EXT2) /* Read up to (and including) a DELIMITER from STREAM into LINEPTR (and null-terminate it). LINEPTR is a pointer returned from malloc (or NULL), pointing to N characters of space. It is realloc'd as necessary. Returns the number of characters read (not including the null terminator), or -1 on error or EOF. These functions are not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation they are cancellation points and therefore not marked with __THROW. / extern __ssize_t __getdelim (char *__restrict __lineptr, size_t __restrict __n, int __delimiter, FILE __restrict __stream) __wur; extern __ssize_t getdelim (char __restrict __lineptr, size_t __restrict __n, int __delimiter, FILE __restrict __stream) __wur; / Like `getdelim', but reads up to a newline. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern __ssize_t getline (char __restrict __lineptr, size_t __restrict __n, FILE __restrict __stream) __wur; #endif / Write a string to STREAM. This function is a possible cancellation point and therefore not marked with __THROW. / extern int fputs (const char __restrict __s, FILE __restrict __stream); / Write a string, followed by a newline, to stdout. This function is a possible cancellation point and therefore not marked with __THROW. / extern int puts (const char __s); /* Push a character back onto the input buffer of STREAM. This function is a possible cancellation point and therefore not marked with __THROW. / extern int ungetc (int __c, FILE __stream); /* Read chunks of generic data from STREAM. This function is a possible cancellation point and therefore not marked with __THROW. / extern size_t fread (void __restrict __ptr, size_t __size, size_t __n, FILE __restrict __stream) __wur; / Write chunks of generic data to STREAM. This function is a possible cancellation point and therefore not marked with __THROW. / extern size_t fwrite (const void __restrict __ptr, size_t __size, size_t __n, FILE __restrict __s); #ifdef __USE_GNU / This function does the same as `fputs' but does not lock the stream. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int fputs_unlocked (const char __restrict __s, FILE __restrict __stream); #endif #ifdef __USE_MISC / Faster versions when locking is not necessary. These functions are not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation they are cancellation points and therefore not marked with __THROW. / extern size_t fread_unlocked (void __restrict __ptr, size_t __size, size_t __n, FILE __restrict __stream) __wur; extern size_t fwrite_unlocked (const void __restrict __ptr, size_t __size, size_t __n, FILE __restrict __stream); #endif / Seek to a certain position on STREAM. This function is a possible cancellation point and therefore not marked with __THROW. / extern int fseek (FILE __stream, long int __off, int __whence); /* Return the current position of STREAM. This function is a possible cancellation point and therefore not marked with __THROW. / extern long int ftell (FILE __stream) __wur; /* Rewind to the beginning of STREAM. This function is a possible cancellation point and therefore not marked with __THROW. / extern void rewind (FILE __stream); /* The Single Unix Specification, Version 2, specifies an alternative, more adequate interface for the two functions above which deal with file offset. `long int' is not the right type. These definitions are originally defined in the Large File Support API. / #if defined __USE_LARGEFILE \|\| defined __USE_XOPEN2K # ifndef __USE_FILE_OFFSET64 / Seek to a certain position on STREAM. This function is a possible cancellation point and therefore not marked with __THROW. / extern int fseeko (FILE __stream, __off_t __off, int __whence); /* Return the current position of STREAM. This function is a possible cancellation point and therefore not marked with __THROW. / extern __off_t ftello (FILE __stream) __wur; # else # ifdef __REDIRECT extern int __REDIRECT (fseeko, (FILE __stream, __off64_t __off, int __whence), fseeko64); extern __off64_t __REDIRECT (ftello, (FILE __stream), ftello64); # else # define fseeko fseeko64 # define ftello ftello64 # endif # endif #endif #ifndef __USE_FILE_OFFSET64 /* Get STREAM's position. This function is a possible cancellation point and therefore not marked with __THROW. / extern int fgetpos (FILE __restrict __stream, fpos_t __restrict __pos); / Set STREAM's position. This function is a possible cancellation point and therefore not marked with __THROW. / extern int fsetpos (FILE __stream, const fpos_t __pos); #else # ifdef __REDIRECT extern int __REDIRECT (fgetpos, (FILE __restrict __stream, fpos_t __restrict __pos), fgetpos64); extern int __REDIRECT (fsetpos, (FILE __stream, const fpos_t __pos), fsetpos64); # else # define fgetpos fgetpos64 # define fsetpos fsetpos64 # endif #endif #ifdef __USE_LARGEFILE64 extern int fseeko64 (FILE __stream, __off64_t __off, int __whence); extern __off64_t ftello64 (FILE __stream) __wur; extern int fgetpos64 (FILE __restrict __stream, fpos64_t __restrict __pos); extern int fsetpos64 (FILE __stream, const fpos64_t __pos); #endif / Clear the error and EOF indicators for STREAM. / extern void clearerr (FILE __stream) __THROW; /* Return the EOF indicator for STREAM. / extern int feof (FILE __stream) __THROW __wur; /* Return the error indicator for STREAM. / extern int ferror (FILE __stream) __THROW __wur; #ifdef __USE_MISC /* Faster versions when locking is not required. / extern void clearerr_unlocked (FILE __stream) __THROW; extern int feof_unlocked (FILE __stream) __THROW __wur; extern int ferror_unlocked (FILE __stream) __THROW __wur; #endif /* Print a message describing the meaning of the value of errno. This function is a possible cancellation point and therefore not marked with __THROW. / extern void perror (const char __s); #ifdef __USE_POSIX /* Return the system file descriptor for STREAM. / extern int fileno (FILE __stream) __THROW __wur; #endif /* Use POSIX. / #ifdef __USE_MISC / Faster version when locking is not required. / extern int fileno_unlocked (FILE __stream) __THROW __wur; #endif #ifdef __USE_POSIX2 /* Close a stream opened by popen and return the status of its child. This function is a possible cancellation point and therefore not marked with __THROW. / extern int pclose (FILE __stream); /* Create a new stream connected to a pipe running the given command. This function is a possible cancellation point and therefore not marked with __THROW. / extern FILE popen (const char __command, const char __modes) __attribute_malloc__ __attr_dealloc (pclose, 1) __wur; #endif #ifdef __USE_POSIX /* Return the name of the controlling terminal. / extern char ctermid (char __s) __THROW __attr_access ((__write_only__, 1)); #endif / Use POSIX. / #if (defined __USE_XOPEN && !defined __USE_XOPEN2K) \|\| defined __USE_GNU / Return the name of the current user. / extern char cuserid (char __s) __attr_access ((__write_only__, 1)); #endif / Use X/Open, but not issue 6. / #ifdef __USE_GNU struct obstack; / See <obstack.h>. / / Write formatted output to an obstack. / extern int obstack_printf (struct obstack __restrict __obstack, const char __restrict __format, ...) __THROWNL __attribute__ ((__format__ (__printf__, 2, 3))); extern int obstack_vprintf (struct obstack __restrict __obstack, const char __restrict __format, __gnuc_va_list __args) __THROWNL __attribute__ ((__format__ (__printf__, 2, 0))); #endif / Use GNU. / #ifdef __USE_POSIX199506 / These are defined in POSIX.1:1996. / / Acquire ownership of STREAM. / extern void flockfile (FILE __stream) __THROW; /* Try to acquire ownership of STREAM but do not block if it is not possible. / extern int ftrylockfile (FILE __stream) __THROW __wur; /* Relinquish the ownership granted for STREAM. / extern void funlockfile (FILE __stream) __THROW; #endif /* POSIX / #if defined __USE_XOPEN && !defined __USE_XOPEN2K && !defined __USE_GNU / X/Open Issues 1-5 required getopt to be declared in this header. It was removed in Issue 6. GNU follows Issue 6. / # include <bits/getopt_posix.h> #endif / Slow-path routines used by the optimized inline functions in bits/stdio.h. / extern int __uflow (FILE ); extern int __overflow (FILE , int); #if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function / Declare all functions from bits/stdio2-decl.h first. / # include <bits/stdio2-decl.h> #endif / The following headers provide asm redirections. These redirections must appear before the first usage of these functions, e.g. in bits/stdio.h. / #if defined __LDBL_COMPAT \|\| __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 # include <bits/stdio-ldbl.h> #endif / If we are compiling with optimizing read this file. It contains several optimizing inline functions and macros. / #ifdef __USE_EXTERN_INLINES # include <bits/stdio.h> #endif #if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function / Now include the function definitions and redirects too. / # include <bits/stdio2.h> #endif __END_DECLS #endif / <stdio.h> included. */	30.67 KB	2026-02-17 11:01
📄 stdio_ext.h /* Functions to access FILE structure internals. Copyright (C) 2000-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / This header contains the same definitions as the header of the same name on Sun's Solaris OS. / #ifndef _STDIO_EXT_H #define _STDIO_EXT_H 1 #include <stdio.h> enum { / Query current state of the locking status. / FSETLOCKING_QUERY = 0, #define FSETLOCKING_QUERY FSETLOCKING_QUERY / The library protects all uses of the stream functions, except for uses of the _unlocked functions, by calls equivalent to flockfile(). / FSETLOCKING_INTERNAL, #define FSETLOCKING_INTERNAL FSETLOCKING_INTERNAL /* The user will take care of locking. / FSETLOCKING_BYCALLER #define FSETLOCKING_BYCALLER FSETLOCKING_BYCALLER }; __BEGIN_DECLS / Return the size of the buffer of FP in bytes currently in use by the given stream. / extern size_t __fbufsize (FILE __fp) __THROW; /* Return non-zero value iff the stream FP is opened readonly, or if the last operation on the stream was a read operation. / extern int __freading (FILE __fp) __THROW; /* Return non-zero value iff the stream FP is opened write-only or append-only, or if the last operation on the stream was a write operation. / extern int __fwriting (FILE __fp) __THROW; /* Return non-zero value iff stream FP is not opened write-only or append-only. / extern int __freadable (FILE __fp) __THROW; /* Return non-zero value iff stream FP is not opened read-only. / extern int __fwritable (FILE __fp) __THROW; /* Return non-zero value iff the stream FP is line-buffered. / extern int __flbf (FILE __fp) __THROW; /* Discard all pending buffered I/O on the stream FP. / extern void __fpurge (FILE __fp) __THROW; /* Return amount of output in bytes pending on a stream FP. / extern size_t __fpending (FILE __fp) __THROW; /* Flush all line-buffered files. / extern void _flushlbf (void); / Set locking status of stream FP to TYPE. / extern int __fsetlocking (FILE __fp, int __type) __THROW; __END_DECLS #endif /* stdio_ext.h */	2.73 KB	2026-02-17 11:01
📄 stdlib.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99 Standard: 7.20 General utilities <stdlib.h> / #ifndef _STDLIB_H #define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION #include <bits/libc-header-start.h> / Get size_t, wchar_t and NULL from <stddef.h>. / #define __need_size_t #define __need_wchar_t #define __need_NULL #include <stddef.h> __BEGIN_DECLS #define _STDLIB_H 1 #if (defined __USE_XOPEN \|\| defined __USE_XOPEN2K8) && !defined _SYS_WAIT_H / XPG requires a few symbols from <sys/wait.h> being defined. / # include <bits/waitflags.h> # include <bits/waitstatus.h> / Define the macros <sys/wait.h> also would define this way. / # define WEXITSTATUS(status) __WEXITSTATUS (status) # define WTERMSIG(status) __WTERMSIG (status) # define WSTOPSIG(status) __WSTOPSIG (status) # define WIFEXITED(status) __WIFEXITED (status) # define WIFSIGNALED(status) __WIFSIGNALED (status) # define WIFSTOPPED(status) __WIFSTOPPED (status) # ifdef __WIFCONTINUED # define WIFCONTINUED(status) __WIFCONTINUED (status) # endif #endif / X/Open or XPG7 and <sys/wait.h> not included. / / _FloatN API tests for enablement. / #include <bits/floatn.h> / Returned by `div'. / typedef struct { int quot; / Quotient. / int rem; / Remainder. / } div_t; / Returned by `ldiv'. / #ifndef __ldiv_t_defined typedef struct { long int quot; / Quotient. / long int rem; / Remainder. / } ldiv_t; # define __ldiv_t_defined 1 #endif #if defined __USE_ISOC99 && !defined __lldiv_t_defined / Returned by `lldiv'. / __extension__ typedef struct { long long int quot; / Quotient. / long long int rem; / Remainder. / } lldiv_t; # define __lldiv_t_defined 1 #endif / The largest number rand will return (same as INT_MAX). / #define RAND_MAX 2147483647 / We define these the same for all machines. Changes from this to the outside world should be done in `_exit'. / #define EXIT_FAILURE 1 / Failing exit status. / #define EXIT_SUCCESS 0 / Successful exit status. / / Maximum length of a multibyte character in the current locale. / #define MB_CUR_MAX (__ctype_get_mb_cur_max ()) extern size_t __ctype_get_mb_cur_max (void) __THROW __wur; / Convert a string to a floating-point number. / extern double atof (const char __nptr) __THROW __attribute_pure__ __nonnull ((1)) __wur; /* Convert a string to an integer. / extern int atoi (const char __nptr) __THROW __attribute_pure__ __nonnull ((1)) __wur; /* Convert a string to a long integer. / extern long int atol (const char __nptr) __THROW __attribute_pure__ __nonnull ((1)) __wur; #ifdef __USE_ISOC99 /* Convert a string to a long long integer. / __extension__ extern long long int atoll (const char __nptr) __THROW __attribute_pure__ __nonnull ((1)) __wur; #endif /* Convert a string to a floating-point number. / extern double strtod (const char __restrict __nptr, char *__restrict __endptr) __THROW __nonnull ((1)); #ifdef __USE_ISOC99 / Likewise for `float' and `long double' sizes of floating-point numbers. / extern float strtof (const char __restrict __nptr, char *__restrict __endptr) __THROW __nonnull ((1)); extern long double strtold (const char __restrict __nptr, char *__restrict __endptr) __THROW __nonnull ((1)); #endif / Likewise for '_FloatN' and '_FloatNx'. / #if __HAVE_FLOAT16 && __GLIBC_USE (IEC_60559_TYPES_EXT) extern _Float16 strtof16 (const char __restrict __nptr, char *__restrict __endptr) __THROW __nonnull ((1)); #endif #if __HAVE_FLOAT32 && __GLIBC_USE (IEC_60559_TYPES_EXT) extern _Float32 strtof32 (const char __restrict __nptr, char *__restrict __endptr) __THROW __nonnull ((1)); #endif #if __HAVE_FLOAT64 && __GLIBC_USE (IEC_60559_TYPES_EXT) extern _Float64 strtof64 (const char __restrict __nptr, char *__restrict __endptr) __THROW __nonnull ((1)); #endif #if __HAVE_FLOAT128 && __GLIBC_USE (IEC_60559_TYPES_EXT) extern _Float128 strtof128 (const char __restrict __nptr, char *__restrict __endptr) __THROW __nonnull ((1)); #endif #if __HAVE_FLOAT32X && __GLIBC_USE (IEC_60559_TYPES_EXT) extern _Float32x strtof32x (const char __restrict __nptr, char *__restrict __endptr) __THROW __nonnull ((1)); #endif #if __HAVE_FLOAT64X && __GLIBC_USE (IEC_60559_TYPES_EXT) extern _Float64x strtof64x (const char __restrict __nptr, char *__restrict __endptr) __THROW __nonnull ((1)); #endif #if __HAVE_FLOAT128X && __GLIBC_USE (IEC_60559_TYPES_EXT) extern _Float128x strtof128x (const char __restrict __nptr, char *__restrict __endptr) __THROW __nonnull ((1)); #endif / Convert a string to a long integer. / extern long int strtol (const char __restrict __nptr, char *__restrict __endptr, int __base) __THROW __nonnull ((1)); / Convert a string to an unsigned long integer. / extern unsigned long int strtoul (const char __restrict __nptr, char *__restrict __endptr, int __base) __THROW __nonnull ((1)); #ifdef __USE_MISC / Convert a string to a quadword integer. / __extension__ extern long long int strtoq (const char __restrict __nptr, char *__restrict __endptr, int __base) __THROW __nonnull ((1)); / Convert a string to an unsigned quadword integer. / __extension__ extern unsigned long long int strtouq (const char __restrict __nptr, char *__restrict __endptr, int __base) __THROW __nonnull ((1)); #endif / Use misc. / #ifdef __USE_ISOC99 / Convert a string to a quadword integer. / __extension__ extern long long int strtoll (const char __restrict __nptr, char *__restrict __endptr, int __base) __THROW __nonnull ((1)); / Convert a string to an unsigned quadword integer. / __extension__ extern unsigned long long int strtoull (const char __restrict __nptr, char *__restrict __endptr, int __base) __THROW __nonnull ((1)); #endif / ISO C99 or use MISC. / / Convert a floating-point number to a string. / #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) extern int strfromd (char __dest, size_t __size, const char __format, double __f) __THROW __nonnull ((3)); extern int strfromf (char __dest, size_t __size, const char __format, float __f) __THROW __nonnull ((3)); extern int strfroml (char __dest, size_t __size, const char __format, long double __f) __THROW __nonnull ((3)); #endif #if __HAVE_FLOAT16 && __GLIBC_USE (IEC_60559_TYPES_EXT) extern int strfromf16 (char __dest, size_t __size, const char * __format, _Float16 __f) __THROW __nonnull ((3)); #endif #if __HAVE_FLOAT32 && __GLIBC_USE (IEC_60559_TYPES_EXT) extern int strfromf32 (char __dest, size_t __size, const char __format, _Float32 __f) __THROW __nonnull ((3)); #endif #if __HAVE_FLOAT64 && __GLIBC_USE (IEC_60559_TYPES_EXT) extern int strfromf64 (char __dest, size_t __size, const char __format, _Float64 __f) __THROW __nonnull ((3)); #endif #if __HAVE_FLOAT128 && __GLIBC_USE (IEC_60559_TYPES_EXT) extern int strfromf128 (char __dest, size_t __size, const char __format, _Float128 __f) __THROW __nonnull ((3)); #endif #if __HAVE_FLOAT32X && __GLIBC_USE (IEC_60559_TYPES_EXT) extern int strfromf32x (char __dest, size_t __size, const char __format, _Float32x __f) __THROW __nonnull ((3)); #endif #if __HAVE_FLOAT64X && __GLIBC_USE (IEC_60559_TYPES_EXT) extern int strfromf64x (char __dest, size_t __size, const char __format, _Float64x __f) __THROW __nonnull ((3)); #endif #if __HAVE_FLOAT128X && __GLIBC_USE (IEC_60559_TYPES_EXT) extern int strfromf128x (char __dest, size_t __size, const char __format, _Float128x __f) __THROW __nonnull ((3)); #endif #ifdef __USE_GNU /* Parallel versions of the functions above which take the locale to use as an additional parameter. These are GNU extensions inspired by the POSIX.1-2008 extended locale API. / # include <bits/types/locale_t.h> extern long int strtol_l (const char __restrict __nptr, char *__restrict __endptr, int __base, locale_t __loc) __THROW __nonnull ((1, 4)); extern unsigned long int strtoul_l (const char __restrict __nptr, char *__restrict __endptr, int __base, locale_t __loc) __THROW __nonnull ((1, 4)); __extension__ extern long long int strtoll_l (const char __restrict __nptr, char *__restrict __endptr, int __base, locale_t __loc) __THROW __nonnull ((1, 4)); __extension__ extern unsigned long long int strtoull_l (const char __restrict __nptr, char *__restrict __endptr, int __base, locale_t __loc) __THROW __nonnull ((1, 4)); extern double strtod_l (const char __restrict __nptr, char *__restrict __endptr, locale_t __loc) __THROW __nonnull ((1, 3)); extern float strtof_l (const char __restrict __nptr, char *__restrict __endptr, locale_t __loc) __THROW __nonnull ((1, 3)); extern long double strtold_l (const char __restrict __nptr, char *__restrict __endptr, locale_t __loc) __THROW __nonnull ((1, 3)); # if __HAVE_FLOAT16 extern _Float16 strtof16_l (const char __restrict __nptr, char *__restrict __endptr, locale_t __loc) __THROW __nonnull ((1, 3)); # endif # if __HAVE_FLOAT32 extern _Float32 strtof32_l (const char __restrict __nptr, char *__restrict __endptr, locale_t __loc) __THROW __nonnull ((1, 3)); # endif # if __HAVE_FLOAT64 extern _Float64 strtof64_l (const char __restrict __nptr, char *__restrict __endptr, locale_t __loc) __THROW __nonnull ((1, 3)); # endif # if __HAVE_FLOAT128 extern _Float128 strtof128_l (const char __restrict __nptr, char *__restrict __endptr, locale_t __loc) __THROW __nonnull ((1, 3)); # endif # if __HAVE_FLOAT32X extern _Float32x strtof32x_l (const char __restrict __nptr, char *__restrict __endptr, locale_t __loc) __THROW __nonnull ((1, 3)); # endif # if __HAVE_FLOAT64X extern _Float64x strtof64x_l (const char __restrict __nptr, char *__restrict __endptr, locale_t __loc) __THROW __nonnull ((1, 3)); # endif # if __HAVE_FLOAT128X extern _Float128x strtof128x_l (const char __restrict __nptr, char *__restrict __endptr, locale_t __loc) __THROW __nonnull ((1, 3)); # endif #endif / GNU / #ifdef __USE_EXTERN_INLINES __extern_inline int __NTH (atoi (const char __nptr)) { return (int) strtol (__nptr, (char *) NULL, 10); } __extern_inline long int __NTH (atol (const char __nptr)) { return strtol (__nptr, (char *) NULL, 10); } # ifdef __USE_ISOC99 __extension__ __extern_inline long long int __NTH (atoll (const char __nptr)) { return strtoll (__nptr, (char *) NULL, 10); } # endif #endif / Optimizing and Inlining. / #if defined __USE_MISC \|\| defined __USE_XOPEN_EXTENDED / Convert N to base 64 using the digits "./0-9A-Za-z", least-significant digit first. Returns a pointer to static storage overwritten by the next call. / extern char l64a (long int __n) __THROW __wur; /* Read a number from a string S in base 64 as above. / extern long int a64l (const char __s) __THROW __attribute_pure__ __nonnull ((1)) __wur; #endif /* Use misc \|\| extended X/Open. / #if defined __USE_MISC \|\| defined __USE_XOPEN_EXTENDED # include <sys/types.h> / we need int32_t... / / These are the functions that actually do things. The `random', `srandom', `initstate' and `setstate' functions are those from BSD Unices. The `rand' and `srand' functions are required by the ANSI standard. We provide both interfaces to the same random number generator. / / Return a random long integer between 0 and 2^31-1 inclusive. / extern long int random (void) __THROW; / Seed the random number generator with the given number. / extern void srandom (unsigned int __seed) __THROW; / Initialize the random number generator to use state buffer STATEBUF, of length STATELEN, and seed it with SEED. Optimal lengths are 8, 16, 32, 64, 128 and 256, the bigger the better; values less than 8 will cause an error and values greater than 256 will be rounded down. / extern char initstate (unsigned int __seed, char __statebuf, size_t __statelen) __THROW __nonnull ((2)); / Switch the random number generator to state buffer STATEBUF, which should have been previously initialized by `initstate'. / extern char setstate (char __statebuf) __THROW __nonnull ((1)); # ifdef __USE_MISC / Reentrant versions of the `random' family of functions. These functions all use the following data structure to contain state, rather than global state variables. / struct random_data { int32_t fptr; /* Front pointer. / int32_t rptr; /* Rear pointer. / int32_t state; /* Array of state values. / int rand_type; / Type of random number generator. / int rand_deg; / Degree of random number generator. / int rand_sep; / Distance between front and rear. / int32_t end_ptr; /* Pointer behind state table. / }; extern int random_r (struct random_data __restrict __buf, int32_t __restrict __result) __THROW __nonnull ((1, 2)); extern int srandom_r (unsigned int __seed, struct random_data __buf) __THROW __nonnull ((2)); extern int initstate_r (unsigned int __seed, char __restrict __statebuf, size_t __statelen, struct random_data __restrict __buf) __THROW __nonnull ((2, 4)); extern int setstate_r (char __restrict __statebuf, struct random_data __restrict __buf) __THROW __nonnull ((1, 2)); # endif /* Use misc. / #endif / Use extended X/Open \|\| misc. / / Return a random integer between 0 and RAND_MAX inclusive. / extern int rand (void) __THROW; / Seed the random number generator with the given number. / extern void srand (unsigned int __seed) __THROW; #ifdef __USE_POSIX199506 / Reentrant interface according to POSIX.1. / extern int rand_r (unsigned int __seed) __THROW; #endif #if defined __USE_MISC \|\| defined __USE_XOPEN /* System V style 48-bit random number generator functions. / / Return non-negative, double-precision floating-point value in [0.0,1.0). / extern double drand48 (void) __THROW; extern double erand48 (unsigned short int __xsubi[3]) __THROW __nonnull ((1)); / Return non-negative, long integer in [0,2^31). / extern long int lrand48 (void) __THROW; extern long int nrand48 (unsigned short int __xsubi[3]) __THROW __nonnull ((1)); / Return signed, long integers in [-2^31,2^31). / extern long int mrand48 (void) __THROW; extern long int jrand48 (unsigned short int __xsubi[3]) __THROW __nonnull ((1)); / Seed random number generator. / extern void srand48 (long int __seedval) __THROW; extern unsigned short int seed48 (unsigned short int __seed16v[3]) __THROW __nonnull ((1)); extern void lcong48 (unsigned short int __param[7]) __THROW __nonnull ((1)); # ifdef __USE_MISC /* Data structure for communication with thread safe versions. This type is to be regarded as opaque. It's only exported because users have to allocate objects of this type. / struct drand48_data { unsigned short int __x[3]; / Current state. / unsigned short int __old_x[3]; / Old state. / unsigned short int __c; / Additive const. in congruential formula. / unsigned short int __init; / Flag for initializing. / __extension__ unsigned long long int __a; / Factor in congruential formula. / }; / Return non-negative, double-precision floating-point value in [0.0,1.0). / extern int drand48_r (struct drand48_data __restrict __buffer, double __restrict __result) __THROW __nonnull ((1, 2)); extern int erand48_r (unsigned short int __xsubi[3], struct drand48_data __restrict __buffer, double __restrict __result) __THROW __nonnull ((1, 2)); / Return non-negative, long integer in [0,2^31). / extern int lrand48_r (struct drand48_data __restrict __buffer, long int __restrict __result) __THROW __nonnull ((1, 2)); extern int nrand48_r (unsigned short int __xsubi[3], struct drand48_data __restrict __buffer, long int __restrict __result) __THROW __nonnull ((1, 2)); / Return signed, long integers in [-2^31,2^31). / extern int mrand48_r (struct drand48_data __restrict __buffer, long int __restrict __result) __THROW __nonnull ((1, 2)); extern int jrand48_r (unsigned short int __xsubi[3], struct drand48_data __restrict __buffer, long int __restrict __result) __THROW __nonnull ((1, 2)); / Seed random number generator. / extern int srand48_r (long int __seedval, struct drand48_data __buffer) __THROW __nonnull ((2)); extern int seed48_r (unsigned short int __seed16v[3], struct drand48_data __buffer) __THROW __nonnull ((1, 2)); extern int lcong48_r (unsigned short int __param[7], struct drand48_data __buffer) __THROW __nonnull ((1, 2)); # endif /* Use misc. / #endif / Use misc or X/Open. / / Allocate SIZE bytes of memory. / extern void malloc (size_t __size) __THROW __attribute_malloc__ __attribute_alloc_size__ ((1)) __wur; /* Allocate NMEMB elements of SIZE bytes each, all initialized to 0. / extern void calloc (size_t __nmemb, size_t __size) __THROW __attribute_malloc__ __attribute_alloc_size__ ((1, 2)) __wur; /* Re-allocate the previously allocated block in PTR, making the new block SIZE bytes long. / / __attribute_malloc__ is not used, because if realloc returns the same pointer that was passed to it, aliasing needs to be allowed between objects pointed by the old and new pointers. / extern void realloc (void __ptr, size_t __size) __THROW __attribute_warn_unused_result__ __attribute_alloc_size__ ((2)); / Free a block allocated by `malloc', `realloc' or `calloc'. / extern void free (void __ptr) __THROW; #ifdef __USE_MISC /* Re-allocate the previously allocated block in PTR, making the new block large enough for NMEMB elements of SIZE bytes each. / / __attribute_malloc__ is not used, because if reallocarray returns the same pointer that was passed to it, aliasing needs to be allowed between objects pointed by the old and new pointers. / extern void reallocarray (void __ptr, size_t __nmemb, size_t __size) __THROW __attribute_warn_unused_result__ __attribute_alloc_size__ ((2, 3)) __attr_dealloc_free; / Add reallocarray as its own deallocator. / extern void reallocarray (void __ptr, size_t __nmemb, size_t __size) __THROW __attr_dealloc (reallocarray, 1); #endif #ifdef __USE_MISC # include <alloca.h> #endif / Use misc. / #if (defined __USE_XOPEN_EXTENDED && !defined __USE_XOPEN2K) \ \|\| defined __USE_MISC / Allocate SIZE bytes on a page boundary. The storage cannot be freed. / extern void valloc (size_t __size) __THROW __attribute_malloc__ __attribute_alloc_size__ ((1)) __wur; #endif #ifdef __USE_XOPEN2K /* Allocate memory of SIZE bytes with an alignment of ALIGNMENT. / extern int posix_memalign (void __memptr, size_t __alignment, size_t __size) __THROW __nonnull ((1)) __wur; #endif #ifdef __USE_ISOC11 / ISO C variant of aligned allocation. / extern void aligned_alloc (size_t __alignment, size_t __size) __THROW __attribute_malloc__ __attribute_alloc_size__ ((2)) __wur; #endif /* Abort execution and generate a core-dump. / extern void abort (void) __THROW __attribute__ ((__noreturn__)); / Register a function to be called when `exit' is called. / extern int atexit (void (__func) (void)) __THROW __nonnull ((1)); #if defined __USE_ISOC11 \|\| defined __USE_ISOCXX11 /* Register a function to be called when `quick_exit' is called. / # ifdef __cplusplus extern "C++" int at_quick_exit (void (__func) (void)) __THROW __asm ("at_quick_exit") __nonnull ((1)); # else extern int at_quick_exit (void (__func) (void)) __THROW __nonnull ((1)); # endif #endif #ifdef __USE_MISC / Register a function to be called with the status given to `exit' and the given argument. / extern int on_exit (void (__func) (int __status, void __arg), void __arg) __THROW __nonnull ((1)); #endif /* Call all functions registered with `atexit' and `on_exit', in the reverse of the order in which they were registered, perform stdio cleanup, and terminate program execution with STATUS. / extern void exit (int __status) __THROW __attribute__ ((__noreturn__)); #if defined __USE_ISOC11 \|\| defined __USE_ISOCXX11 / Call all functions registered with `at_quick_exit' in the reverse of the order in which they were registered and terminate program execution with STATUS. / extern void quick_exit (int __status) __THROW __attribute__ ((__noreturn__)); #endif #ifdef __USE_ISOC99 / Terminate the program with STATUS without calling any of the functions registered with `atexit' or `on_exit'. / extern void _Exit (int __status) __THROW __attribute__ ((__noreturn__)); #endif / Return the value of envariable NAME, or NULL if it doesn't exist. / extern char getenv (const char __name) __THROW __nonnull ((1)) __wur; #ifdef __USE_GNU / This function is similar to the above but returns NULL if the programs is running with SUID or SGID enabled. / extern char secure_getenv (const char __name) __THROW __nonnull ((1)) __wur; #endif #if defined __USE_MISC \|\| defined __USE_XOPEN / The SVID says this is in <stdio.h>, but this seems a better place. / / Put STRING, which is of the form "NAME=VALUE", in the environment. If there is no `=', remove NAME from the environment. / extern int putenv (char __string) __THROW __nonnull ((1)); #endif #ifdef __USE_XOPEN2K /* Set NAME to VALUE in the environment. If REPLACE is nonzero, overwrite an existing value. / extern int setenv (const char __name, const char __value, int __replace) __THROW __nonnull ((2)); / Remove the variable NAME from the environment. / extern int unsetenv (const char __name) __THROW __nonnull ((1)); #endif #ifdef __USE_MISC /* The `clearenv' was planned to be added to POSIX.1 but probably never made it. Nevertheless the POSIX.9 standard (POSIX bindings for Fortran 77) requires this function. / extern int clearenv (void) __THROW; #endif #if defined __USE_MISC \ \|\| (defined __USE_XOPEN_EXTENDED && !defined __USE_XOPEN2K8) / Generate a unique temporary file name from TEMPLATE. The last six characters of TEMPLATE must be "XXXXXX"; they are replaced with a string that makes the file name unique. Always returns TEMPLATE, it's either a temporary file name or a null string if it cannot get a unique file name. / extern char mktemp (char __template) __THROW __nonnull ((1)); #endif #if defined __USE_XOPEN_EXTENDED \|\| defined __USE_XOPEN2K8 / Generate a unique temporary file name from TEMPLATE. The last six characters of TEMPLATE must be "XXXXXX"; they are replaced with a string that makes the filename unique. Returns a file descriptor open on the file for reading and writing, or -1 if it cannot create a uniquely-named file. This function is a possible cancellation point and therefore not marked with __THROW. / # ifndef __USE_FILE_OFFSET64 extern int mkstemp (char __template) __nonnull ((1)) __wur; # else # ifdef __REDIRECT extern int __REDIRECT (mkstemp, (char __template), mkstemp64) __nonnull ((1)) __wur; # else # define mkstemp mkstemp64 # endif # endif # ifdef __USE_LARGEFILE64 extern int mkstemp64 (char __template) __nonnull ((1)) __wur; # endif #endif #ifdef __USE_MISC /* Similar to mkstemp, but the template can have a suffix after the XXXXXX. The length of the suffix is specified in the second parameter. This function is a possible cancellation point and therefore not marked with __THROW. / # ifndef __USE_FILE_OFFSET64 extern int mkstemps (char __template, int __suffixlen) __nonnull ((1)) __wur; # else # ifdef __REDIRECT extern int __REDIRECT (mkstemps, (char __template, int __suffixlen), mkstemps64) __nonnull ((1)) __wur; # else # define mkstemps mkstemps64 # endif # endif # ifdef __USE_LARGEFILE64 extern int mkstemps64 (char __template, int __suffixlen) __nonnull ((1)) __wur; # endif #endif #ifdef __USE_XOPEN2K8 /* Create a unique temporary directory from TEMPLATE. The last six characters of TEMPLATE must be "XXXXXX"; they are replaced with a string that makes the directory name unique. Returns TEMPLATE, or a null pointer if it cannot get a unique name. The directory is created mode 700. / extern char mkdtemp (char __template) __THROW __nonnull ((1)) __wur; #endif #ifdef __USE_GNU / Generate a unique temporary file name from TEMPLATE similar to mkstemp. But allow the caller to pass additional flags which are used in the open call to create the file.. This function is a possible cancellation point and therefore not marked with __THROW. / # ifndef __USE_FILE_OFFSET64 extern int mkostemp (char __template, int __flags) __nonnull ((1)) __wur; # else # ifdef __REDIRECT extern int __REDIRECT (mkostemp, (char __template, int __flags), mkostemp64) __nonnull ((1)) __wur; # else # define mkostemp mkostemp64 # endif # endif # ifdef __USE_LARGEFILE64 extern int mkostemp64 (char __template, int __flags) __nonnull ((1)) __wur; # endif /* Similar to mkostemp, but the template can have a suffix after the XXXXXX. The length of the suffix is specified in the second parameter. This function is a possible cancellation point and therefore not marked with __THROW. / # ifndef __USE_FILE_OFFSET64 extern int mkostemps (char __template, int __suffixlen, int __flags) __nonnull ((1)) __wur; # else # ifdef __REDIRECT extern int __REDIRECT (mkostemps, (char __template, int __suffixlen, int __flags), mkostemps64) __nonnull ((1)) __wur; # else # define mkostemps mkostemps64 # endif # endif # ifdef __USE_LARGEFILE64 extern int mkostemps64 (char __template, int __suffixlen, int __flags) __nonnull ((1)) __wur; # endif #endif /* Execute the given line as a shell command. This function is a cancellation point and therefore not marked with __THROW. / extern int system (const char __command) __wur; #ifdef __USE_GNU /* Return a malloc'd string containing the canonical absolute name of the existing named file. / extern char canonicalize_file_name (const char __name) __THROW __nonnull ((1)) __attribute_malloc__ __attr_dealloc_free __wur; #endif #if defined __USE_MISC \|\| defined __USE_XOPEN_EXTENDED / Return the canonical absolute name of file NAME. If RESOLVED is null, the result is malloc'd; otherwise, if the canonical name is PATH_MAX chars or more, returns null with `errno' set to ENAMETOOLONG; if the name fits in fewer than PATH_MAX chars, returns the name in RESOLVED. / extern char realpath (const char __restrict __name, char __restrict __resolved) __THROW __wur; #endif /* Shorthand for type of comparison functions. / #ifndef __COMPAR_FN_T # define __COMPAR_FN_T typedef int (__compar_fn_t) (const void , const void ); # ifdef __USE_GNU typedef __compar_fn_t comparison_fn_t; # endif #endif #ifdef __USE_GNU typedef int (__compar_d_fn_t) (const void , const void , void ); #endif /* Do a binary search for KEY in BASE, which consists of NMEMB elements of SIZE bytes each, using COMPAR to perform the comparisons. / extern void bsearch (const void __key, const void __base, size_t __nmemb, size_t __size, __compar_fn_t __compar) __nonnull ((1, 2, 5)) __wur; #ifdef __USE_EXTERN_INLINES # include <bits/stdlib-bsearch.h> #endif /* Sort NMEMB elements of BASE, of SIZE bytes each, using COMPAR to perform the comparisons. / extern void qsort (void __base, size_t __nmemb, size_t __size, __compar_fn_t __compar) __nonnull ((1, 4)); #ifdef __USE_GNU extern void qsort_r (void __base, size_t __nmemb, size_t __size, __compar_d_fn_t __compar, void __arg) __nonnull ((1, 4)); #endif /* Return the absolute value of X. / extern int abs (int __x) __THROW __attribute__ ((__const__)) __wur; extern long int labs (long int __x) __THROW __attribute__ ((__const__)) __wur; #ifdef __USE_ISOC99 __extension__ extern long long int llabs (long long int __x) __THROW __attribute__ ((__const__)) __wur; #endif / Return the `div_t', `ldiv_t' or `lldiv_t' representation of the value of NUMER over DENOM. / / GCC may have built-ins for these someday. / extern div_t div (int __numer, int __denom) __THROW __attribute__ ((__const__)) __wur; extern ldiv_t ldiv (long int __numer, long int __denom) __THROW __attribute__ ((__const__)) __wur; #ifdef __USE_ISOC99 __extension__ extern lldiv_t lldiv (long long int __numer, long long int __denom) __THROW __attribute__ ((__const__)) __wur; #endif #if (defined __USE_XOPEN_EXTENDED && !defined __USE_XOPEN2K8) \ \|\| defined __USE_MISC / Convert floating point numbers to strings. The returned values are valid only until another call to the same function. / / Convert VALUE to a string with NDIGIT digits and return a pointer to this. Set DECPT with the position of the decimal character and SIGN with the sign of the number. / extern char ecvt (double __value, int __ndigit, int __restrict __decpt, int __restrict __sign) __THROW __nonnull ((3, 4)) __wur; /* Convert VALUE to a string rounded to NDIGIT decimal digits. Set DECPT with the position of the decimal character and SIGN with the sign of the number. / extern char fcvt (double __value, int __ndigit, int __restrict __decpt, int __restrict __sign) __THROW __nonnull ((3, 4)) __wur; /* If possible convert VALUE to a string with NDIGIT significant digits. Otherwise use exponential representation. The resulting string will be written to BUF. / extern char gcvt (double __value, int __ndigit, char __buf) __THROW __nonnull ((3)) __wur; #endif #ifdef __USE_MISC / Long double versions of above functions. / extern char qecvt (long double __value, int __ndigit, int __restrict __decpt, int __restrict __sign) __THROW __nonnull ((3, 4)) __wur; extern char qfcvt (long double __value, int __ndigit, int __restrict __decpt, int __restrict __sign) __THROW __nonnull ((3, 4)) __wur; extern char qgcvt (long double __value, int __ndigit, char __buf) __THROW __nonnull ((3)) __wur; / Reentrant version of the functions above which provide their own buffers. / extern int ecvt_r (double __value, int __ndigit, int __restrict __decpt, int __restrict __sign, char __restrict __buf, size_t __len) __THROW __nonnull ((3, 4, 5)); extern int fcvt_r (double __value, int __ndigit, int __restrict __decpt, int __restrict __sign, char __restrict __buf, size_t __len) __THROW __nonnull ((3, 4, 5)); extern int qecvt_r (long double __value, int __ndigit, int __restrict __decpt, int __restrict __sign, char __restrict __buf, size_t __len) __THROW __nonnull ((3, 4, 5)); extern int qfcvt_r (long double __value, int __ndigit, int __restrict __decpt, int __restrict __sign, char __restrict __buf, size_t __len) __THROW __nonnull ((3, 4, 5)); #endif / misc / / Return the length of the multibyte character in S, which is no longer than N. / extern int mblen (const char __s, size_t __n) __THROW; /* Return the length of the given multibyte character, putting its `wchar_t' representation in PWC. / extern int mbtowc (wchar_t __restrict __pwc, const char __restrict __s, size_t __n) __THROW; /* Put the multibyte character represented by WCHAR in S, returning its length. / extern int wctomb (char __s, wchar_t __wchar) __THROW; /* Convert a multibyte string to a wide char string. / extern size_t mbstowcs (wchar_t __restrict __pwcs, const char __restrict __s, size_t __n) __THROW __attr_access ((__read_only__, 2)); / Convert a wide char string to multibyte string. / extern size_t wcstombs (char __restrict __s, const wchar_t __restrict __pwcs, size_t __n) __THROW __fortified_attr_access (__write_only__, 1, 3) __attr_access ((__read_only__, 2)); #ifdef __USE_MISC / Determine whether the string value of RESPONSE matches the affirmation or negative response expression as specified by the LC_MESSAGES category in the program's current locale. Returns 1 if affirmative, 0 if negative, and -1 if not matching. / extern int rpmatch (const char __response) __THROW __nonnull ((1)) __wur; #endif #if defined __USE_XOPEN_EXTENDED \|\| defined __USE_XOPEN2K8 /* Parse comma separated suboption from OPTIONP and match against strings in TOKENS. If found return index and set VALUEP to optional value introduced by an equal sign. If the suboption is not part of TOKENS return in VALUEP beginning of unknown suboption. On exit OPTIONP is set to the beginning of the next token or at the terminating NUL character. / extern int getsubopt (char __restrict __optionp, char const __restrict __tokens, char __restrict __valuep) __THROW __nonnull ((1, 2, 3)) __wur; #endif / X/Open pseudo terminal handling. / #ifdef __USE_XOPEN2KXSI / Return a master pseudo-terminal handle. / extern int posix_openpt (int __oflag) __wur; #endif #ifdef __USE_XOPEN_EXTENDED / The next four functions all take a master pseudo-tty fd and perform an operation on the associated slave: / / Chown the slave to the calling user. / extern int grantpt (int __fd) __THROW; / Release an internal lock so the slave can be opened. Call after grantpt(). / extern int unlockpt (int __fd) __THROW; / Return the pathname of the pseudo terminal slave associated with the master FD is open on, or NULL on errors. The returned storage is good until the next call to this function. / extern char ptsname (int __fd) __THROW __wur; #endif #ifdef __USE_GNU /* Store at most BUFLEN characters of the pathname of the slave pseudo terminal associated with the master FD is open on in BUF. Return 0 on success, otherwise an error number. / extern int ptsname_r (int __fd, char __buf, size_t __buflen) __THROW __nonnull ((2)) __fortified_attr_access (__write_only__, 2, 3); /* Open a master pseudo terminal and return its file descriptor. / extern int getpt (void); #endif #ifdef __USE_MISC / Put the 1 minute, 5 minute and 15 minute load averages into the first NELEM elements of LOADAVG. Return the number written (never more than three, but may be less than NELEM), or -1 if an error occurred. / extern int getloadavg (double __loadavg[], int __nelem) __THROW __nonnull ((1)); #endif #if defined __USE_XOPEN_EXTENDED && !defined __USE_XOPEN2K / Return the index into the active-logins file (utmp) for the controlling terminal. / extern int ttyslot (void) __THROW; #endif #include <bits/stdlib-float.h> / Define some macros helping to catch buffer overflows. / #if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function # include <bits/stdlib.h> #endif #include <bits/floatn.h> #if defined __LDBL_COMPAT \|\| __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 # include <bits/stdlib-ldbl.h> #endif __END_DECLS #endif / stdlib.h */	35.46 KB	2026-02-17 11:01
📄 string.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99 Standard: 7.21 String handling <string.h> / #ifndef _STRING_H #define _STRING_H 1 #define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION #include <bits/libc-header-start.h> __BEGIN_DECLS / Get size_t and NULL from <stddef.h>. / #define __need_size_t #define __need_NULL #include <stddef.h> / Tell the caller that we provide correct C++ prototypes. / #if defined __cplusplus && (__GNUC_PREREQ (4, 4) \ \|\| __glibc_clang_prereq (3, 5)) # define __CORRECT_ISO_CPP_STRING_H_PROTO #endif / Copy N bytes of SRC to DEST. / extern void memcpy (void __restrict __dest, const void __restrict __src, size_t __n) __THROW __nonnull ((1, 2)); /* Copy N bytes of SRC to DEST, guaranteeing correct behavior for overlapping strings. / extern void memmove (void __dest, const void __src, size_t __n) __THROW __nonnull ((1, 2)); /* Copy no more than N bytes of SRC to DEST, stopping when C is found. Return the position in DEST one byte past where C was copied, or NULL if C was not found in the first N bytes of SRC. / #if defined __USE_MISC \|\| defined __USE_XOPEN \|\| __GLIBC_USE (ISOC2X) extern void memccpy (void __restrict __dest, const void __restrict __src, int __c, size_t __n) __THROW __nonnull ((1, 2)) __attr_access ((__write_only__, 1, 4)); #endif /* Misc \|\| X/Open. / / Set N bytes of S to C. / extern void memset (void __s, int __c, size_t __n) __THROW __nonnull ((1)); / Compare N bytes of S1 and S2. / extern int memcmp (const void __s1, const void __s2, size_t __n) __THROW __attribute_pure__ __nonnull ((1, 2)); / Compare N bytes of S1 and S2. Return zero if S1 and S2 are equal. Return some non-zero value otherwise. Essentially __memcmpeq has the exact same semantics as memcmp except the return value is less constrained. memcmp is always a correct implementation of __memcmpeq. As well !!memcmp, -memcmp, or bcmp are correct implementations. __memcmpeq is meant to be used by compilers when memcmp return is only used for its bolean value. __memcmpeq is declared only for use by compilers. Programs should continue to use memcmp. / extern int __memcmpeq (const void __s1, const void __s2, size_t __n) __THROW __attribute_pure__ __nonnull ((1, 2)); / Search N bytes of S for C. / #ifdef __CORRECT_ISO_CPP_STRING_H_PROTO extern "C++" { extern void memchr (void __s, int __c, size_t __n) __THROW __asm ("memchr") __attribute_pure__ __nonnull ((1)); extern const void memchr (const void __s, int __c, size_t __n) __THROW __asm ("memchr") __attribute_pure__ __nonnull ((1)); # ifdef __OPTIMIZE__ __extern_always_inline void memchr (void __s, int __c, size_t __n) __THROW { return __builtin_memchr (__s, __c, __n); } __extern_always_inline const void memchr (const void __s, int __c, size_t __n) __THROW { return __builtin_memchr (__s, __c, __n); } # endif } #else extern void memchr (const void __s, int __c, size_t __n) __THROW __attribute_pure__ __nonnull ((1)); #endif #ifdef __USE_GNU / Search in S for C. This is similar to `memchr' but there is no length limit. / # ifdef __CORRECT_ISO_CPP_STRING_H_PROTO extern "C++" void rawmemchr (void __s, int __c) __THROW __asm ("rawmemchr") __attribute_pure__ __nonnull ((1)); extern "C++" const void rawmemchr (const void __s, int __c) __THROW __asm ("rawmemchr") __attribute_pure__ __nonnull ((1)); # else extern void rawmemchr (const void __s, int __c) __THROW __attribute_pure__ __nonnull ((1)); # endif / Search N bytes of S for the final occurrence of C. / # ifdef __CORRECT_ISO_CPP_STRING_H_PROTO extern "C++" void memrchr (void __s, int __c, size_t __n) __THROW __asm ("memrchr") __attribute_pure__ __nonnull ((1)) __attr_access ((__read_only__, 1, 3)); extern "C++" const void memrchr (const void __s, int __c, size_t __n) __THROW __asm ("memrchr") __attribute_pure__ __nonnull ((1)) __attr_access ((__read_only__, 1, 3)); # else extern void memrchr (const void __s, int __c, size_t __n) __THROW __attribute_pure__ __nonnull ((1)) __attr_access ((__read_only__, 1, 3)); # endif #endif / Copy SRC to DEST. / extern char strcpy (char __restrict __dest, const char __restrict __src) __THROW __nonnull ((1, 2)); /* Copy no more than N characters of SRC to DEST. / extern char strncpy (char __restrict __dest, const char __restrict __src, size_t __n) __THROW __nonnull ((1, 2)); /* Append SRC onto DEST. / extern char strcat (char __restrict __dest, const char __restrict __src) __THROW __nonnull ((1, 2)); /* Append no more than N characters from SRC onto DEST. / extern char strncat (char __restrict __dest, const char __restrict __src, size_t __n) __THROW __nonnull ((1, 2)); /* Compare S1 and S2. / extern int strcmp (const char __s1, const char __s2) __THROW __attribute_pure__ __nonnull ((1, 2)); / Compare N characters of S1 and S2. / extern int strncmp (const char __s1, const char __s2, size_t __n) __THROW __attribute_pure__ __nonnull ((1, 2)); / Compare the collated forms of S1 and S2. / extern int strcoll (const char __s1, const char __s2) __THROW __attribute_pure__ __nonnull ((1, 2)); / Put a transformation of SRC into no more than N bytes of DEST. / extern size_t strxfrm (char __restrict __dest, const char __restrict __src, size_t __n) __THROW __nonnull ((2)) __attr_access ((__write_only__, 1, 3)); #ifdef __USE_XOPEN2K8 / POSIX.1-2008 extended locale interface (see locale.h). / # include <bits/types/locale_t.h> / Compare the collated forms of S1 and S2, using sorting rules from L. / extern int strcoll_l (const char __s1, const char __s2, locale_t __l) __THROW __attribute_pure__ __nonnull ((1, 2, 3)); / Put a transformation of SRC into no more than N bytes of DEST, using sorting rules from L. / extern size_t strxfrm_l (char __dest, const char __src, size_t __n, locale_t __l) __THROW __nonnull ((2, 4)) __attr_access ((__write_only__, 1, 3)); #endif #if (defined __USE_XOPEN_EXTENDED \|\| defined __USE_XOPEN2K8 \ \|\| __GLIBC_USE (LIB_EXT2) \|\| __GLIBC_USE (ISOC2X)) / Duplicate S, returning an identical malloc'd string. / extern char strdup (const char __s) __THROW __attribute_malloc__ __nonnull ((1)); #endif / Return a malloc'd copy of at most N bytes of STRING. The resultant string is terminated even if no null terminator appears before STRING[N]. / #if defined __USE_XOPEN2K8 \|\| __GLIBC_USE (LIB_EXT2) \|\| __GLIBC_USE (ISOC2X) extern char strndup (const char __string, size_t __n) __THROW __attribute_malloc__ __nonnull ((1)); #endif #if defined __USE_GNU && defined __GNUC__ / Duplicate S, returning an identical alloca'd string. / # define strdupa(s) \ (__extension__ \ ({ \ const char __old = (s); \ size_t __len = strlen (__old) + 1; \ char __new = (char ) __builtin_alloca (__len); \ (char ) memcpy (__new, __old, __len); \ })) / Return an alloca'd copy of at most N bytes of string. / # define strndupa(s, n) \ (__extension__ \ ({ \ const char __old = (s); \ size_t __len = strnlen (__old, (n)); \ char __new = (char ) __builtin_alloca (__len + 1); \ __new[__len] = '\0'; \ (char ) memcpy (__new, __old, __len); \ })) #endif / Find the first occurrence of C in S. / #ifdef __CORRECT_ISO_CPP_STRING_H_PROTO extern "C++" { extern char strchr (char __s, int __c) __THROW __asm ("strchr") __attribute_pure__ __nonnull ((1)); extern const char strchr (const char __s, int __c) __THROW __asm ("strchr") __attribute_pure__ __nonnull ((1)); # ifdef __OPTIMIZE__ __extern_always_inline char strchr (char __s, int __c) __THROW { return __builtin_strchr (__s, __c); } __extern_always_inline const char strchr (const char __s, int __c) __THROW { return __builtin_strchr (__s, __c); } # endif } #else extern char strchr (const char __s, int __c) __THROW __attribute_pure__ __nonnull ((1)); #endif / Find the last occurrence of C in S. / #ifdef __CORRECT_ISO_CPP_STRING_H_PROTO extern "C++" { extern char strrchr (char __s, int __c) __THROW __asm ("strrchr") __attribute_pure__ __nonnull ((1)); extern const char strrchr (const char __s, int __c) __THROW __asm ("strrchr") __attribute_pure__ __nonnull ((1)); # ifdef __OPTIMIZE__ __extern_always_inline char strrchr (char __s, int __c) __THROW { return __builtin_strrchr (__s, __c); } __extern_always_inline const char strrchr (const char __s, int __c) __THROW { return __builtin_strrchr (__s, __c); } # endif } #else extern char strrchr (const char __s, int __c) __THROW __attribute_pure__ __nonnull ((1)); #endif #ifdef __USE_GNU / This function is similar to `strchr'. But it returns a pointer to the closing NUL byte in case C is not found in S. / # ifdef __CORRECT_ISO_CPP_STRING_H_PROTO extern "C++" char strchrnul (char __s, int __c) __THROW __asm ("strchrnul") __attribute_pure__ __nonnull ((1)); extern "C++" const char strchrnul (const char __s, int __c) __THROW __asm ("strchrnul") __attribute_pure__ __nonnull ((1)); # else extern char strchrnul (const char __s, int __c) __THROW __attribute_pure__ __nonnull ((1)); # endif #endif / Return the length of the initial segment of S which consists entirely of characters not in REJECT. / extern size_t strcspn (const char __s, const char __reject) __THROW __attribute_pure__ __nonnull ((1, 2)); / Return the length of the initial segment of S which consists entirely of characters in ACCEPT. / extern size_t strspn (const char __s, const char __accept) __THROW __attribute_pure__ __nonnull ((1, 2)); / Find the first occurrence in S of any character in ACCEPT. / #ifdef __CORRECT_ISO_CPP_STRING_H_PROTO extern "C++" { extern char strpbrk (char __s, const char __accept) __THROW __asm ("strpbrk") __attribute_pure__ __nonnull ((1, 2)); extern const char strpbrk (const char __s, const char __accept) __THROW __asm ("strpbrk") __attribute_pure__ __nonnull ((1, 2)); # ifdef __OPTIMIZE__ __extern_always_inline char strpbrk (char __s, const char __accept) __THROW { return __builtin_strpbrk (__s, __accept); } __extern_always_inline const char * strpbrk (const char __s, const char __accept) __THROW { return __builtin_strpbrk (__s, __accept); } # endif } #else extern char strpbrk (const char __s, const char __accept) __THROW __attribute_pure__ __nonnull ((1, 2)); #endif / Find the first occurrence of NEEDLE in HAYSTACK. / #ifdef __CORRECT_ISO_CPP_STRING_H_PROTO extern "C++" { extern char strstr (char __haystack, const char __needle) __THROW __asm ("strstr") __attribute_pure__ __nonnull ((1, 2)); extern const char strstr (const char __haystack, const char __needle) __THROW __asm ("strstr") __attribute_pure__ __nonnull ((1, 2)); # ifdef __OPTIMIZE__ __extern_always_inline char strstr (char __haystack, const char __needle) __THROW { return __builtin_strstr (__haystack, __needle); } __extern_always_inline const char * strstr (const char __haystack, const char __needle) __THROW { return __builtin_strstr (__haystack, __needle); } # endif } #else extern char strstr (const char __haystack, const char __needle) __THROW __attribute_pure__ __nonnull ((1, 2)); #endif / Divide S into tokens separated by characters in DELIM. / extern char strtok (char __restrict __s, const char __restrict __delim) __THROW __nonnull ((2)); /* Divide S into tokens separated by characters in DELIM. Information passed between calls are stored in SAVE_PTR. / extern char __strtok_r (char __restrict __s, const char __restrict __delim, char *__restrict __save_ptr) __THROW __nonnull ((2, 3)); #ifdef __USE_POSIX extern char strtok_r (char __restrict __s, const char __restrict __delim, char *__restrict __save_ptr) __THROW __nonnull ((2, 3)); #endif #ifdef __USE_GNU / Similar to `strstr' but this function ignores the case of both strings. / # ifdef __CORRECT_ISO_CPP_STRING_H_PROTO extern "C++" char strcasestr (char __haystack, const char __needle) __THROW __asm ("strcasestr") __attribute_pure__ __nonnull ((1, 2)); extern "C++" const char strcasestr (const char __haystack, const char __needle) __THROW __asm ("strcasestr") __attribute_pure__ __nonnull ((1, 2)); # else extern char strcasestr (const char __haystack, const char __needle) __THROW __attribute_pure__ __nonnull ((1, 2)); # endif #endif #ifdef __USE_GNU /* Find the first occurrence of NEEDLE in HAYSTACK. NEEDLE is NEEDLELEN bytes long; HAYSTACK is HAYSTACKLEN bytes long. / extern void memmem (const void __haystack, size_t __haystacklen, const void __needle, size_t __needlelen) __THROW __attribute_pure__ __nonnull ((1, 3)) __attr_access ((__read_only__, 1, 2)) __attr_access ((__read_only__, 3, 4)); /* Copy N bytes of SRC to DEST, return pointer to bytes after the last written byte. / extern void __mempcpy (void __restrict __dest, const void __restrict __src, size_t __n) __THROW __nonnull ((1, 2)); extern void mempcpy (void __restrict __dest, const void __restrict __src, size_t __n) __THROW __nonnull ((1, 2)); #endif / Return the length of S. / extern size_t strlen (const char __s) __THROW __attribute_pure__ __nonnull ((1)); #ifdef __USE_XOPEN2K8 /* Find the length of STRING, but scan at most MAXLEN characters. If no '\0' terminator is found in that many characters, return MAXLEN. / extern size_t strnlen (const char __string, size_t __maxlen) __THROW __attribute_pure__ __nonnull ((1)); #endif /* Return a string describing the meaning of the `errno' code in ERRNUM. / extern char strerror (int __errnum) __THROW; #ifdef __USE_XOPEN2K /* Reentrant version of `strerror'. There are 2 flavors of `strerror_r', GNU which returns the string and may or may not use the supplied temporary buffer and POSIX one which fills the string into the buffer. To use the POSIX version, -D_XOPEN_SOURCE=600 or -D_POSIX_C_SOURCE=200112L without -D_GNU_SOURCE is needed, otherwise the GNU version is preferred. / # if defined __USE_XOPEN2K && !defined __USE_GNU / Fill BUF with a string describing the meaning of the `errno' code in ERRNUM. / # ifdef __REDIRECT_NTH extern int __REDIRECT_NTH (strerror_r, (int __errnum, char __buf, size_t __buflen), __xpg_strerror_r) __nonnull ((2)) __attr_access ((__write_only__, 2, 3)); # else extern int __xpg_strerror_r (int __errnum, char __buf, size_t __buflen) __THROW __nonnull ((2)) __attr_access ((__write_only__, 2, 3)); # define strerror_r __xpg_strerror_r # endif # else / If a temporary buffer is required, at most BUFLEN bytes of BUF will be used. / extern char strerror_r (int __errnum, char __buf, size_t __buflen) __THROW __nonnull ((2)) __wur __attr_access ((__write_only__, 2, 3)); # endif # ifdef __USE_GNU / Return a string describing the meaning of tthe error in ERR. / extern const char strerrordesc_np (int __err) __THROW; /* Return a string with the error name in ERR. / extern const char strerrorname_np (int __err) __THROW; # endif #endif #ifdef __USE_XOPEN2K8 /* Translate error number to string according to the locale L. / extern char strerror_l (int __errnum, locale_t __l) __THROW; #endif #ifdef __USE_MISC # include <strings.h> /* Set N bytes of S to 0. The compiler will not delete a call to this function, even if S is dead after the call. / extern void explicit_bzero (void __s, size_t __n) __THROW __nonnull ((1)) __fortified_attr_access (__write_only__, 1, 2); /* Return the next DELIM-delimited token from STRINGP, terminating it with a '\0', and update STRINGP to point past it. / extern char strsep (char *__restrict __stringp, const char __restrict __delim) __THROW __nonnull ((1, 2)); #endif #ifdef __USE_XOPEN2K8 /* Return a string describing the meaning of the signal number in SIG. / extern char strsignal (int __sig) __THROW; # ifdef __USE_GNU /* Return an abbreviation string for the signal number SIG. / extern const char sigabbrev_np (int __sig) __THROW; /* Return a string describing the meaning of the signal number in SIG, the result is not translated. / extern const char sigdescr_np (int __sig) __THROW; # endif /* Copy SRC to DEST, returning the address of the terminating '\0' in DEST. / extern char __stpcpy (char __restrict __dest, const char __restrict __src) __THROW __nonnull ((1, 2)); extern char stpcpy (char __restrict __dest, const char __restrict __src) __THROW __nonnull ((1, 2)); / Copy no more than N characters of SRC to DEST, returning the address of the last character written into DEST. / extern char __stpncpy (char __restrict __dest, const char __restrict __src, size_t __n) __THROW __nonnull ((1, 2)); extern char stpncpy (char __restrict __dest, const char __restrict __src, size_t __n) __THROW __nonnull ((1, 2)); #endif #ifdef __USE_GNU / Compare S1 and S2 as strings holding name & indices/version numbers. / extern int strverscmp (const char __s1, const char __s2) __THROW __attribute_pure__ __nonnull ((1, 2)); / Sautee STRING briskly. / extern char strfry (char __string) __THROW __nonnull ((1)); / Frobnicate N bytes of S. / extern void memfrob (void __s, size_t __n) __THROW __nonnull ((1)) __attr_access ((__write_only__, 1, 2)); # ifndef basename / Return the file name within directory of FILENAME. We don't declare the function if the `basename' macro is available (defined in <libgen.h>) which makes the XPG version of this function available. / # ifdef __CORRECT_ISO_CPP_STRING_H_PROTO extern "C++" char basename (char __filename) __THROW __asm ("basename") __nonnull ((1)); extern "C++" const char basename (const char __filename) __THROW __asm ("basename") __nonnull ((1)); # else extern char basename (const char __filename) __THROW __nonnull ((1)); # endif # endif #endif #if __GNUC_PREREQ (3,4) # if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function / Functions with security checks. / # include <bits/string_fortified.h> # endif #endif __END_DECLS #endif / string.h */	19 KB	2026-02-17 11:01
📄 strings.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _STRINGS_H #define _STRINGS_H 1 #include <features.h> #define __need_size_t #include <stddef.h> / Tell the caller that we provide correct C++ prototypes. / #if defined __cplusplus && __GNUC_PREREQ (4, 4) # define __CORRECT_ISO_CPP_STRINGS_H_PROTO #endif __BEGIN_DECLS #if defined __USE_MISC \|\| !defined __USE_XOPEN2K8 / Compare N bytes of S1 and S2 (same as memcmp). / extern int bcmp (const void __s1, const void __s2, size_t __n) __THROW __attribute_pure__ __nonnull ((1, 2)); / Copy N bytes of SRC to DEST (like memmove, but args reversed). / extern void bcopy (const void __src, void __dest, size_t __n) __THROW __nonnull ((1, 2)); / Set N bytes of S to 0. / extern void bzero (void __s, size_t __n) __THROW __nonnull ((1)); /* Find the first occurrence of C in S (same as strchr). / # ifdef __CORRECT_ISO_CPP_STRINGS_H_PROTO extern "C++" { extern char index (char __s, int __c) __THROW __asm ("index") __attribute_pure__ __nonnull ((1)); extern const char index (const char __s, int __c) __THROW __asm ("index") __attribute_pure__ __nonnull ((1)); # if defined __OPTIMIZE__ __extern_always_inline char index (char __s, int __c) __THROW { return __builtin_index (__s, __c); } __extern_always_inline const char index (const char __s, int __c) __THROW { return __builtin_index (__s, __c); } # endif } # else extern char index (const char __s, int __c) __THROW __attribute_pure__ __nonnull ((1)); # endif / Find the last occurrence of C in S (same as strrchr). / # ifdef __CORRECT_ISO_CPP_STRINGS_H_PROTO extern "C++" { extern char rindex (char __s, int __c) __THROW __asm ("rindex") __attribute_pure__ __nonnull ((1)); extern const char rindex (const char __s, int __c) __THROW __asm ("rindex") __attribute_pure__ __nonnull ((1)); # if defined __OPTIMIZE__ __extern_always_inline char rindex (char __s, int __c) __THROW { return __builtin_rindex (__s, __c); } __extern_always_inline const char rindex (const char __s, int __c) __THROW { return __builtin_rindex (__s, __c); } # endif } # else extern char rindex (const char __s, int __c) __THROW __attribute_pure__ __nonnull ((1)); # endif #endif #if defined __USE_MISC \|\| !defined __USE_XOPEN2K8 \|\| defined __USE_XOPEN2K8XSI / Return the position of the first bit set in I, or 0 if none are set. The least-significant bit is position 1, the most-significant 32. / extern int ffs (int __i) __THROW __attribute_const__; #endif / The following two functions are non-standard but necessary for non-32 bit platforms. / # ifdef __USE_MISC extern int ffsl (long int __l) __THROW __attribute_const__; __extension__ extern int ffsll (long long int __ll) __THROW __attribute_const__; # endif / Compare S1 and S2, ignoring case. / extern int strcasecmp (const char __s1, const char __s2) __THROW __attribute_pure__ __nonnull ((1, 2)); / Compare no more than N chars of S1 and S2, ignoring case. / extern int strncasecmp (const char __s1, const char __s2, size_t __n) __THROW __attribute_pure__ __nonnull ((1, 2)); #ifdef __USE_XOPEN2K8 / POSIX.1-2008 extended locale interface (see locale.h). / # include <bits/types/locale_t.h> / Compare S1 and S2, ignoring case, using collation rules from LOC. / extern int strcasecmp_l (const char __s1, const char __s2, locale_t __loc) __THROW __attribute_pure__ __nonnull ((1, 2, 3)); / Compare no more than N chars of S1 and S2, ignoring case, using collation rules from LOC. / extern int strncasecmp_l (const char __s1, const char __s2, size_t __n, locale_t __loc) __THROW __attribute_pure__ __nonnull ((1, 2, 4)); #endif __END_DECLS #if __GNUC_PREREQ (3,4) && __USE_FORTIFY_LEVEL > 0 \ && defined __fortify_function / Functions with security checks. / # if defined __USE_MISC \|\| !defined __USE_XOPEN2K8 # include <bits/strings_fortified.h> # endif #endif #endif / strings.h */	4.64 KB	2026-02-17 11:01
📁 sys	-	2026-03-21 15:44
📄 syscall.h #include <sys/syscall.h>	25 B	2026-02-17 11:01
📄 sysexits.h /* * Copyright (c) 1987, 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. * * @(#)sysexits.h 8.1 (Berkeley) 6/2/93 / #ifndef _SYSEXITS_H #define _SYSEXITS_H 1 / * 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, /etc/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 NOINPUT or * CANTCREAT, but rather for higher level permissions. / #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 */	5.11 KB	2026-02-17 11:01
📄 syslog.h #include <sys/syslog.h>	24 B	2026-02-17 11:01
📄 tar.h /* Extended tar format from POSIX.1. Copyright (C) 1992-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. Written by David J. MacKenzie. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _TAR_H #define _TAR_H 1 #include <features.h> / A tar archive consists of 512-byte blocks. Each file in the archive has a header block followed by 0+ data blocks. Two blocks of NUL bytes indicate the end of the archive. / / The fields of header blocks: All strings are stored as ISO 646 (approximately ASCII) strings. Fields are numeric unless otherwise noted below; numbers are ISO 646 representations of octal numbers, with leading zeros as needed. linkname is only valid when typeflag==LNKTYPE. It doesn't use prefix; files that are links to pathnames >100 chars long can not be stored in a tar archive. If typeflag=={LNKTYPE,SYMTYPE,DIRTYPE} then size must be 0. devmajor and devminor are only valid for typeflag=={BLKTYPE,CHRTYPE}. chksum contains the sum of all 512 bytes in the header block, treating each byte as an 8-bit unsigned value and treating the 8 bytes of chksum as blank characters. uname and gname are used in preference to uid and gid, if those names exist locally. Field Name Byte Offset Length in Bytes Field Type name 0 100 NUL-terminated if NUL fits mode 100 8 uid 108 8 gid 116 8 size 124 12 mtime 136 12 chksum 148 8 typeflag 156 1 see below linkname 157 100 NUL-terminated if NUL fits magic 257 6 must be TMAGIC (NUL term.) version 263 2 must be TVERSION uname 265 32 NUL-terminated gname 297 32 NUL-terminated devmajor 329 8 devminor 337 8 prefix 345 155 NUL-terminated if NUL fits If the first character of prefix is '\0', the file name is name; otherwise, it is prefix/name. Files whose pathnames don't fit in that length can not be stored in a tar archive. / / The bits in mode: / #define TSUID 04000 #define TSGID 02000 #if defined __USE_XOPEN \|\| !defined __USE_XOPEN2K # define TSVTX 01000 #endif #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 / The values for typeflag: Values 'A'-'Z' are reserved for custom implementations. All other values are reserved for future POSIX.1 revisions. / #define REGTYPE '0' / Regular file (preferred code). / #define AREGTYPE '\0' / Regular file (alternate code). / #define LNKTYPE '1' / Hard link. / #define SYMTYPE '2' / Symbolic link (hard if not supported). / #define CHRTYPE '3' / Character special. / #define BLKTYPE '4' / Block special. / #define DIRTYPE '5' / Directory. / #define FIFOTYPE '6' / Named pipe. / #define CONTTYPE '7' / Contiguous file / / (regular file if not supported). / / Contents of magic field and its length. / #define TMAGIC "ustar" #define TMAGLEN 6 / Contents of the version field and its length. / #define TVERSION "00" #define TVERSLEN 2 #endif / tar.h */	3.7 KB	2026-02-17 11:01
📄 termio.h /* Compatible <termio.h> for old `struct termio' ioctl interface. This is obsolete; use the POSIX.1 `struct termios' interface defined in <termios.h> instead. */ #include <termios.h> #include <sys/ioctl.h>	214 B	2026-02-17 11:01
📄 termios.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * POSIX Standard: 7.1-2 General Terminal Interface <termios.h> / #ifndef _TERMIOS_H #define _TERMIOS_H 1 #include <features.h> #if defined __USE_XOPEN_EXTENDED \|\| defined __USE_XOPEN2K8 / We need `pid_t'. / # include <bits/types.h> # ifndef __pid_t_defined typedef __pid_t pid_t; # define __pid_t_defined # endif #endif __BEGIN_DECLS / Get the system-dependent definitions of `struct termios', `tcflag_t', `cc_t', `speed_t', and all the macros specifying the flag bits. / #include <bits/termios.h> #ifdef __USE_MISC / Compare a character C to a value VAL from the `c_cc' array in a `struct termios'. If VAL is _POSIX_VDISABLE, no character can match it. / # define CCEQ(val, c) ((c) == (val) && (val) != _POSIX_VDISABLE) #endif / Return the output baud rate stored in TERMIOS_P. / extern speed_t cfgetospeed (const struct termios __termios_p) __THROW; / Return the input baud rate stored in TERMIOS_P. / extern speed_t cfgetispeed (const struct termios __termios_p) __THROW; / Set the output baud rate stored in TERMIOS_P to SPEED. / extern int cfsetospeed (struct termios __termios_p, speed_t __speed) __THROW; / Set the input baud rate stored in TERMIOS_P to SPEED. / extern int cfsetispeed (struct termios __termios_p, speed_t __speed) __THROW; #ifdef __USE_MISC / Set both the input and output baud rates in TERMIOS_OP to SPEED. / extern int cfsetspeed (struct termios __termios_p, speed_t __speed) __THROW; #endif / Put the state of FD into TERMIOS_P. / extern int tcgetattr (int __fd, struct termios __termios_p) __THROW; / Set the state of FD to TERMIOS_P. Values for OPTIONAL_ACTIONS (TCSA) are in <bits/termios.h>. / extern int tcsetattr (int __fd, int __optional_actions, const struct termios __termios_p) __THROW; #ifdef __USE_MISC /* Set TERMIOS_P to indicate raw mode. / extern void cfmakeraw (struct termios __termios_p) __THROW; #endif / Send zero bits on FD. / extern int tcsendbreak (int __fd, int __duration) __THROW; / Wait for pending output to be written on FD. This function is a cancellation point and therefore not marked with __THROW. / extern int tcdrain (int __fd); / Flush pending data on FD. Values for QUEUE_SELECTOR (TC{I,O,IO}FLUSH) are in <bits/termios.h>. / extern int tcflush (int __fd, int __queue_selector) __THROW; / Suspend or restart transmission on FD. Values for ACTION (TC[IO]{OFF,ON}) are in <bits/termios.h>. / extern int tcflow (int __fd, int __action) __THROW; #if defined __USE_XOPEN_EXTENDED \|\| defined __USE_XOPEN2K8 / Get process group ID for session leader for controlling terminal FD. / extern __pid_t tcgetsid (int __fd) __THROW; #endif #ifdef __USE_MISC # include <sys/ttydefaults.h> #endif __END_DECLS #endif / termios.h */	3.51 KB	2026-02-17 11:01
📄 tgmath.h /* Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99 Standard: 7.22 Type-generic math <tgmath.h> / #ifndef _TGMATH_H #define _TGMATH_H 1 #define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION #include <bits/libc-header-start.h> / Include the needed headers. / #include <bits/floatn.h> #include <math.h> #include <complex.h> / There are two variant implementations of type-generic macros in this file: one for GCC 8 and later, using __builtin_tgmath and where each macro expands each of its arguments only once, and one for older GCC, using other compiler extensions but with macros expanding their arguments many times (so resulting in exponential blowup of the size of expansions when calls to such macros are nested inside arguments to such macros). Because of a long series of defect fixes made after the initial release of TS 18661-1, GCC versions before GCC 13 have __builtin_tgmath semantics that, when integer arguments are passed to narrowing macros returning _Float32x, or non-narrowing macros with at least two generic arguments, do not always correspond to the C2X semantics, so more complicated macro definitions are also used in some cases for versions from GCC 8 to GCC 12. / #define __HAVE_BUILTIN_TGMATH __GNUC_PREREQ (8, 0) #define __HAVE_BUILTIN_TGMATH_C2X __GNUC_PREREQ (13, 0) #if __GNUC_PREREQ (2, 7) / Certain cases of narrowing macros only need to call a single function so cannot use __builtin_tgmath and do not need any complicated logic. / # if __HAVE_FLOAT128X # error "Unsupported _Float128x type for <tgmath.h>." # endif # if ((__HAVE_FLOAT64X && !__HAVE_FLOAT128) \ \|\| (__HAVE_FLOAT128 && !__HAVE_FLOAT64X)) # error "Unsupported combination of types for <tgmath.h>." # endif # define __TGMATH_2_NARROW_D(F, X, Y) \ (F ## l (X, Y)) # define __TGMATH_2_NARROW_F64X(F, X, Y) \ (F ## f128 (X, Y)) # if !__HAVE_FLOAT128 # define __TGMATH_2_NARROW_F32X(F, X, Y) \ (F ## f64 (X, Y)) # endif # if __HAVE_BUILTIN_TGMATH # if __HAVE_FLOAT16 && __GLIBC_USE (IEC_60559_TYPES_EXT) # define __TG_F16_ARG(X) X ## f16, # else # define __TG_F16_ARG(X) # endif # if __HAVE_FLOAT32 && __GLIBC_USE (IEC_60559_TYPES_EXT) # define __TG_F32_ARG(X) X ## f32, # else # define __TG_F32_ARG(X) # endif # if __HAVE_FLOAT64 && __GLIBC_USE (IEC_60559_TYPES_EXT) # define __TG_F64_ARG(X) X ## f64, # else # define __TG_F64_ARG(X) # endif # if __HAVE_FLOAT128 && __GLIBC_USE (IEC_60559_TYPES_EXT) # define __TG_F128_ARG(X) X ## f128, # else # define __TG_F128_ARG(X) # endif # if __HAVE_FLOAT32X && __GLIBC_USE (IEC_60559_TYPES_EXT) # define __TG_F32X_ARG(X) X ## f32x, # else # define __TG_F32X_ARG(X) # endif # if __HAVE_FLOAT64X && __GLIBC_USE (IEC_60559_TYPES_EXT) # define __TG_F64X_ARG(X) X ## f64x, # else # define __TG_F64X_ARG(X) # endif # if __HAVE_FLOAT128X && __GLIBC_USE (IEC_60559_TYPES_EXT) # define __TG_F128X_ARG(X) X ## f128x, # else # define __TG_F128X_ARG(X) # endif # define __TGMATH_FUNCS(X) X ## f, X, X ## l, \ __TG_F16_ARG (X) __TG_F32_ARG (X) __TG_F64_ARG (X) __TG_F128_ARG (X) \ __TG_F32X_ARG (X) __TG_F64X_ARG (X) __TG_F128X_ARG (X) # define __TGMATH_RCFUNCS(F, C) __TGMATH_FUNCS (F) __TGMATH_FUNCS (C) # define __TGMATH_1(F, X) __builtin_tgmath (__TGMATH_FUNCS (F) (X)) # define __TGMATH_2(F, X, Y) __builtin_tgmath (__TGMATH_FUNCS (F) (X), (Y)) # define __TGMATH_2STD(F, X, Y) __builtin_tgmath (F ## f, F, F ## l, (X), (Y)) # define __TGMATH_3(F, X, Y, Z) __builtin_tgmath (__TGMATH_FUNCS (F) \ (X), (Y), (Z)) # define __TGMATH_1C(F, C, X) __builtin_tgmath (__TGMATH_RCFUNCS (F, C) (X)) # define __TGMATH_2C(F, C, X, Y) __builtin_tgmath (__TGMATH_RCFUNCS (F, C) \ (X), (Y)) # define __TGMATH_NARROW_FUNCS_F(X) X, X ## l, # define __TGMATH_NARROW_FUNCS_F16(X) \ __TG_F32_ARG (X) __TG_F64_ARG (X) __TG_F128_ARG (X) \ __TG_F32X_ARG (X) __TG_F64X_ARG (X) __TG_F128X_ARG (X) # define __TGMATH_NARROW_FUNCS_F32(X) \ __TG_F64_ARG (X) __TG_F128_ARG (X) \ __TG_F32X_ARG (X) __TG_F64X_ARG (X) __TG_F128X_ARG (X) # define __TGMATH_NARROW_FUNCS_F64(X) \ __TG_F128_ARG (X) \ __TG_F64X_ARG (X) __TG_F128X_ARG (X) # define __TGMATH_NARROW_FUNCS_F32X(X) \ __TG_F64X_ARG (X) __TG_F128X_ARG (X) \ __TG_F64_ARG (X) __TG_F128_ARG (X) # define __TGMATH_2_NARROW_F(F, X, Y) \ __builtin_tgmath (__TGMATH_NARROW_FUNCS_F (F) (X), (Y)) # define __TGMATH_2_NARROW_F16(F, X, Y) \ __builtin_tgmath (__TGMATH_NARROW_FUNCS_F16 (F) (X), (Y)) # define __TGMATH_2_NARROW_F32(F, X, Y) \ __builtin_tgmath (__TGMATH_NARROW_FUNCS_F32 (F) (X), (Y)) # define __TGMATH_2_NARROW_F64(F, X, Y) \ __builtin_tgmath (__TGMATH_NARROW_FUNCS_F64 (F) (X), (Y)) # if __HAVE_FLOAT128 && __HAVE_BUILTIN_TGMATH_C2X # define __TGMATH_2_NARROW_F32X(F, X, Y) \ __builtin_tgmath (__TGMATH_NARROW_FUNCS_F32X (F) (X), (Y)) # endif # endif # if !__HAVE_BUILTIN_TGMATH_C2X # ifdef __NO_LONG_DOUBLE_MATH # define __tgml(fct) fct # else # define __tgml(fct) fct ## l # endif / __floating_type expands to 1 if TYPE is a floating type (including complex floating types), 0 if TYPE is an integer type (including complex integer types). __real_integer_type expands to 1 if TYPE is a real integer type. __complex_integer_type expands to 1 if TYPE is a complex integer type. All these macros expand to integer constant expressions. All these macros can assume their argument has an arithmetic type (not vector, decimal floating-point or fixed-point), valid to pass to tgmath.h macros. / # if __GNUC_PREREQ (3, 1) / __builtin_classify_type expands to an integer constant expression in GCC 3.1 and later. Default conversions applied to the argument of __builtin_classify_type mean it always returns 1 for real integer types rather than ever returning different values for character, boolean or enumerated types. / # define __floating_type(type) \ (__builtin_classify_type (__real__ ((type) 0)) == 8) # define __real_integer_type(type) \ (__builtin_classify_type ((type) 0) == 1) # define __complex_integer_type(type) \ (__builtin_classify_type ((type) 0) == 9 \ && __builtin_classify_type (__real__ ((type) 0)) == 1) # else / GCC versions predating __builtin_classify_type are also looser on what counts as an integer constant expression. / # define __floating_type(type) (((type) 1.25) != 1) # define __real_integer_type(type) (((type) (1.25 + _Complex_I)) == 1) # define __complex_integer_type(type) \ (((type) (1.25 + _Complex_I)) == (1 + _Complex_I)) # endif / Whether an expression (of arithmetic type) has a real type. / # define __expr_is_real(E) (__builtin_classify_type (E) != 9) / Type T1 if E is 1, type T2 is E is 0. / # define __tgmath_type_if(T1, T2, E) \ __typeof__ ((0 ? (__typeof__ (0 ? (T2 ) 0 : (void ) (E))) 0 \ : (__typeof__ (0 ? (T1 ) 0 : (void ) (!(E)))) 0)) /* The tgmath real type for T, where E is 0 if T is an integer type and 1 for a floating type. If T has a complex type, it is unspecified whether the return type is real or complex (but it has the correct corresponding real type). / # define __tgmath_real_type_sub(T, E) \ __tgmath_type_if (T, double, E) / The tgmath real type of EXPR. / # define __tgmath_real_type(expr) \ __tgmath_real_type_sub (__typeof__ ((__typeof__ (+(expr))) 0), \ __floating_type (__typeof__ (+(expr)))) / The tgmath complex type for T, where E1 is 1 if T has a floating type and 0 otherwise, E2 is 1 if T has a real integer type and 0 otherwise, and E3 is 1 if T has a complex type and 0 otherwise. / # define __tgmath_complex_type_sub(T, E1, E2, E3) \ __typeof__ ((0 \ ? (__typeof__ (0 ? (T ) 0 : (void ) (!(E1)))) 0 \ : (__typeof__ (0 \ ? (__typeof__ (0 \ ? (double ) 0 \ : (void ) (!(E2)))) 0 \ : (__typeof__ (0 \ ? (_Complex double ) 0 \ : (void ) (!(E3)))) 0)) 0)) /* The tgmath complex type of EXPR. / # define __tgmath_complex_type(expr) \ __tgmath_complex_type_sub (__typeof__ ((__typeof__ (+(expr))) 0), \ __floating_type (__typeof__ (+(expr))), \ __real_integer_type (__typeof__ (+(expr))), \ __complex_integer_type (__typeof__ (+(expr)))) / The tgmath real type of EXPR1 combined with EXPR2, without handling the C2X rule of interpreting integer arguments as _Float32x if any argument is _FloatNx. / # define __tgmath_real_type2_base(expr1, expr2) \ __typeof ((__tgmath_real_type (expr1)) 0 + (__tgmath_real_type (expr2)) 0) / The tgmath complex type of EXPR1 combined with EXPR2, without handling the C2X rule of interpreting integer arguments as _Float32x if any argument is _FloatNx. / # define __tgmath_complex_type2_base(expr1, expr2) \ __typeof ((__tgmath_complex_type (expr1)) 0 \ + (__tgmath_complex_type (expr2)) 0) / The tgmath real type of EXPR1 combined with EXPR2 and EXPR3, without handling the C2X rule of interpreting integer arguments as _Float32x if any argument is _FloatNx. / # define __tgmath_real_type3_base(expr1, expr2, expr3) \ __typeof ((__tgmath_real_type (expr1)) 0 \ + (__tgmath_real_type (expr2)) 0 \ + (__tgmath_real_type (expr3)) 0) / The tgmath real or complex type of EXPR1 combined with EXPR2 (and EXPR3 if applicable). / # if __HAVE_FLOATN_NOT_TYPEDEF # define __tgmath_real_type2(expr1, expr2) \ __tgmath_type_if (_Float32x, __tgmath_real_type2_base (expr1, expr2), \ _Generic ((expr1) + (expr2), _Float32x: 1, default: 0)) # define __tgmath_complex_type2(expr1, expr2) \ __tgmath_type_if (_Float32x, \ __tgmath_type_if (_Complex _Float32x, \ __tgmath_complex_type2_base (expr1, \ expr2), \ _Generic ((expr1) + (expr2), \ _Complex _Float32x: 1, \ default: 0)), \ _Generic ((expr1) + (expr2), _Float32x: 1, default: 0)) # define __tgmath_real_type3(expr1, expr2, expr3) \ __tgmath_type_if (_Float32x, \ __tgmath_real_type3_base (expr1, expr2, expr3), \ _Generic ((expr1) + (expr2) + (expr3), \ _Float32x: 1, default: 0)) # else # define __tgmath_real_type2(expr1, expr2) \ __tgmath_real_type2_base (expr1, expr2) # define __tgmath_complex_type2(expr1, expr2) \ __tgmath_complex_type2_base (expr1, expr2) # define __tgmath_real_type3(expr1, expr2, expr3) \ __tgmath_real_type3_base (expr1, expr2, expr3) # endif # if (__HAVE_DISTINCT_FLOAT16 \ \|\| __HAVE_DISTINCT_FLOAT32 \ \|\| __HAVE_DISTINCT_FLOAT64 \ \|\| __HAVE_DISTINCT_FLOAT32X \ \|\| __HAVE_DISTINCT_FLOAT64X \ \|\| __HAVE_DISTINCT_FLOAT128X) # error "Unsupported _FloatN or _FloatNx types for <tgmath.h>." # endif / Expand to text that checks if ARG_COMB has type _Float128, and if so calls the appropriately suffixed FCT (which may include a cast), or FCT and CFCT for complex functions, with arguments ARG_CALL. __TGMATH_F128LD (only used in the __HAVE_FLOAT64X_LONG_DOUBLE case, for narrowing macros) handles long double the same as _Float128. / # if __HAVE_DISTINCT_FLOAT128 && __GLIBC_USE (IEC_60559_TYPES_EXT) # if (!__HAVE_FLOAT64X \ \|\| __HAVE_FLOAT64X_LONG_DOUBLE \ \|\| !__HAVE_FLOATN_NOT_TYPEDEF) # define __TGMATH_F128(arg_comb, fct, arg_call) \ __builtin_types_compatible_p (__typeof (+(arg_comb)), _Float128) \ ? fct ## f128 arg_call : # define __TGMATH_F128LD(arg_comb, fct, arg_call) \ (__builtin_types_compatible_p (__typeof (+(arg_comb)), _Float128) \ \|\| __builtin_types_compatible_p (__typeof (+(arg_comb)), long double)) \ ? fct ## f128 arg_call : # define __TGMATH_CF128(arg_comb, fct, cfct, arg_call) \ __builtin_types_compatible_p (__typeof (+__real__ (arg_comb)), _Float128) \ ? (__expr_is_real (arg_comb) \ ? fct ## f128 arg_call \ : cfct ## f128 arg_call) : # else / _Float64x is a distinct type at the C language level, which must be handled like _Float128. / # define __TGMATH_F128(arg_comb, fct, arg_call) \ (__builtin_types_compatible_p (__typeof (+(arg_comb)), _Float128) \ \|\| __builtin_types_compatible_p (__typeof (+(arg_comb)), _Float64x)) \ ? fct ## f128 arg_call : # define __TGMATH_CF128(arg_comb, fct, cfct, arg_call) \ (__builtin_types_compatible_p (__typeof (+__real__ (arg_comb)), _Float128) \ \|\| __builtin_types_compatible_p (__typeof (+__real__ (arg_comb)), \ _Float64x)) \ ? (__expr_is_real (arg_comb) \ ? fct ## f128 arg_call \ : cfct ## f128 arg_call) : # endif # else # define __TGMATH_F128(arg_comb, fct, arg_call) / Nothing. / # define __TGMATH_CF128(arg_comb, fct, cfct, arg_call) / Nothing. / # endif # endif / !__HAVE_BUILTIN_TGMATH_C2X. / / We have two kinds of generic macros: to support functions which are only defined on real valued parameters and those which are defined for complex functions as well. / # if __HAVE_BUILTIN_TGMATH # define __TGMATH_UNARY_REAL_ONLY(Val, Fct) __TGMATH_1 (Fct, (Val)) # define __TGMATH_UNARY_REAL_RET_ONLY(Val, Fct) __TGMATH_1 (Fct, (Val)) # define __TGMATH_BINARY_FIRST_REAL_ONLY(Val1, Val2, Fct) \ __TGMATH_2 (Fct, (Val1), (Val2)) # define __TGMATH_BINARY_FIRST_REAL_STD_ONLY(Val1, Val2, Fct) \ __TGMATH_2STD (Fct, (Val1), (Val2)) # if __HAVE_BUILTIN_TGMATH_C2X # define __TGMATH_BINARY_REAL_ONLY(Val1, Val2, Fct) \ __TGMATH_2 (Fct, (Val1), (Val2)) # endif # define __TGMATH_BINARY_REAL_STD_ONLY(Val1, Val2, Fct) \ __TGMATH_2STD (Fct, (Val1), (Val2)) # if __HAVE_BUILTIN_TGMATH_C2X # define __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY(Val1, Val2, Val3, Fct) \ __TGMATH_3 (Fct, (Val1), (Val2), (Val3)) # define __TGMATH_TERNARY_REAL_ONLY(Val1, Val2, Val3, Fct) \ __TGMATH_3 (Fct, (Val1), (Val2), (Val3)) # endif # define __TGMATH_TERNARY_FIRST_REAL_RET_ONLY(Val1, Val2, Val3, Fct) \ __TGMATH_3 (Fct, (Val1), (Val2), (Val3)) # define __TGMATH_UNARY_REAL_IMAG(Val, Fct, Cfct) \ __TGMATH_1C (Fct, Cfct, (Val)) # define __TGMATH_UNARY_IMAG(Val, Cfct) __TGMATH_1 (Cfct, (Val)) # define __TGMATH_UNARY_REAL_IMAG_RET_REAL(Val, Fct, Cfct) \ __TGMATH_1C (Fct, Cfct, (Val)) # define __TGMATH_UNARY_REAL_IMAG_RET_REAL_SAME(Val, Cfct) \ __TGMATH_1 (Cfct, (Val)) # if __HAVE_BUILTIN_TGMATH_C2X # define __TGMATH_BINARY_REAL_IMAG(Val1, Val2, Fct, Cfct) \ __TGMATH_2C (Fct, Cfct, (Val1), (Val2)) # endif # endif # if !__HAVE_BUILTIN_TGMATH # define __TGMATH_UNARY_REAL_ONLY(Val, Fct) \ (__extension__ ((sizeof (+(Val)) == sizeof (double) \ \|\| __builtin_classify_type (Val) != 8) \ ? (__tgmath_real_type (Val)) Fct (Val) \ : (sizeof (+(Val)) == sizeof (float)) \ ? (__tgmath_real_type (Val)) Fct##f (Val) \ : __TGMATH_F128 ((Val), (__tgmath_real_type (Val)) Fct, \ (Val)) \ (__tgmath_real_type (Val)) __tgml(Fct) (Val))) # define __TGMATH_UNARY_REAL_RET_ONLY(Val, Fct) \ (__extension__ ((sizeof (+(Val)) == sizeof (double) \ \|\| __builtin_classify_type (Val) != 8) \ ? Fct (Val) \ : (sizeof (+(Val)) == sizeof (float)) \ ? Fct##f (Val) \ : __TGMATH_F128 ((Val), Fct, (Val)) \ __tgml(Fct) (Val))) # define __TGMATH_BINARY_FIRST_REAL_ONLY(Val1, Val2, Fct) \ (__extension__ ((sizeof (+(Val1)) == sizeof (double) \ \|\| __builtin_classify_type (Val1) != 8) \ ? (__tgmath_real_type (Val1)) Fct (Val1, Val2) \ : (sizeof (+(Val1)) == sizeof (float)) \ ? (__tgmath_real_type (Val1)) Fct##f (Val1, Val2) \ : __TGMATH_F128 ((Val1), (__tgmath_real_type (Val1)) Fct, \ (Val1, Val2)) \ (__tgmath_real_type (Val1)) __tgml(Fct) (Val1, Val2))) # define __TGMATH_BINARY_FIRST_REAL_STD_ONLY(Val1, Val2, Fct) \ (__extension__ ((sizeof (+(Val1)) == sizeof (double) \ \|\| __builtin_classify_type (Val1) != 8) \ ? (__tgmath_real_type (Val1)) Fct (Val1, Val2) \ : (sizeof (+(Val1)) == sizeof (float)) \ ? (__tgmath_real_type (Val1)) Fct##f (Val1, Val2) \ : (__tgmath_real_type (Val1)) __tgml(Fct) (Val1, Val2))) # endif # if !__HAVE_BUILTIN_TGMATH_C2X # define __TGMATH_BINARY_REAL_ONLY(Val1, Val2, Fct) \ (__extension__ ((sizeof ((Val1) + (Val2)) > sizeof (double) \ && __builtin_classify_type ((Val1) + (Val2)) == 8) \ ? __TGMATH_F128 ((Val1) + (Val2), \ (__tgmath_real_type2 (Val1, Val2)) Fct, \ (Val1, Val2)) \ (__tgmath_real_type2 (Val1, Val2)) \ __tgml(Fct) (Val1, Val2) \ : (sizeof (+(Val1)) == sizeof (double) \ \|\| sizeof (+(Val2)) == sizeof (double) \ \|\| __builtin_classify_type (Val1) != 8 \ \|\| __builtin_classify_type (Val2) != 8) \ ? (__tgmath_real_type2 (Val1, Val2)) \ Fct (Val1, Val2) \ : (__tgmath_real_type2 (Val1, Val2)) \ Fct##f (Val1, Val2))) # endif # if !__HAVE_BUILTIN_TGMATH # define __TGMATH_BINARY_REAL_STD_ONLY(Val1, Val2, Fct) \ (__extension__ ((sizeof ((Val1) + (Val2)) > sizeof (double) \ && __builtin_classify_type ((Val1) + (Val2)) == 8) \ ? (__typeof ((__tgmath_real_type (Val1)) 0 \ + (__tgmath_real_type (Val2)) 0)) \ __tgml(Fct) (Val1, Val2) \ : (sizeof (+(Val1)) == sizeof (double) \ \|\| sizeof (+(Val2)) == sizeof (double) \ \|\| __builtin_classify_type (Val1) != 8 \ \|\| __builtin_classify_type (Val2) != 8) \ ? (__typeof ((__tgmath_real_type (Val1)) 0 \ + (__tgmath_real_type (Val2)) 0)) \ Fct (Val1, Val2) \ : (__typeof ((__tgmath_real_type (Val1)) 0 \ + (__tgmath_real_type (Val2)) 0)) \ Fct##f (Val1, Val2))) # endif # if !__HAVE_BUILTIN_TGMATH_C2X # define __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY(Val1, Val2, Val3, Fct) \ (__extension__ ((sizeof ((Val1) + (Val2)) > sizeof (double) \ && __builtin_classify_type ((Val1) + (Val2)) == 8) \ ? __TGMATH_F128 ((Val1) + (Val2), \ (__tgmath_real_type2 (Val1, Val2)) Fct, \ (Val1, Val2, Val3)) \ (__tgmath_real_type2 (Val1, Val2)) \ __tgml(Fct) (Val1, Val2, Val3) \ : (sizeof (+(Val1)) == sizeof (double) \ \|\| sizeof (+(Val2)) == sizeof (double) \ \|\| __builtin_classify_type (Val1) != 8 \ \|\| __builtin_classify_type (Val2) != 8) \ ? (__tgmath_real_type2 (Val1, Val2)) \ Fct (Val1, Val2, Val3) \ : (__tgmath_real_type2 (Val1, Val2)) \ Fct##f (Val1, Val2, Val3))) # define __TGMATH_TERNARY_REAL_ONLY(Val1, Val2, Val3, Fct) \ (__extension__ ((sizeof ((Val1) + (Val2) + (Val3)) > sizeof (double) \ && __builtin_classify_type ((Val1) + (Val2) + (Val3)) \ == 8) \ ? __TGMATH_F128 ((Val1) + (Val2) + (Val3), \ (__tgmath_real_type3 (Val1, Val2, \ Val3)) Fct, \ (Val1, Val2, Val3)) \ (__tgmath_real_type3 (Val1, Val2, Val3)) \ __tgml(Fct) (Val1, Val2, Val3) \ : (sizeof (+(Val1)) == sizeof (double) \ \|\| sizeof (+(Val2)) == sizeof (double) \ \|\| sizeof (+(Val3)) == sizeof (double) \ \|\| __builtin_classify_type (Val1) != 8 \ \|\| __builtin_classify_type (Val2) != 8 \ \|\| __builtin_classify_type (Val3) != 8) \ ? (__tgmath_real_type3 (Val1, Val2, Val3)) \ Fct (Val1, Val2, Val3) \ : (__tgmath_real_type3 (Val1, Val2, Val3)) \ Fct##f (Val1, Val2, Val3))) # endif # if !__HAVE_BUILTIN_TGMATH # define __TGMATH_TERNARY_FIRST_REAL_RET_ONLY(Val1, Val2, Val3, Fct) \ (__extension__ ((sizeof (+(Val1)) == sizeof (double) \ \|\| __builtin_classify_type (Val1) != 8) \ ? Fct (Val1, Val2, Val3) \ : (sizeof (+(Val1)) == sizeof (float)) \ ? Fct##f (Val1, Val2, Val3) \ : __TGMATH_F128 ((Val1), Fct, (Val1, Val2, Val3)) \ __tgml(Fct) (Val1, Val2, Val3))) / XXX This definition has to be changed as soon as the compiler understands the imaginary keyword. / # define __TGMATH_UNARY_REAL_IMAG(Val, Fct, Cfct) \ (__extension__ ((sizeof (+__real__ (Val)) == sizeof (double) \ \|\| __builtin_classify_type (__real__ (Val)) != 8) \ ? (__expr_is_real (Val) \ ? (__tgmath_complex_type (Val)) Fct (Val) \ : (__tgmath_complex_type (Val)) Cfct (Val)) \ : (sizeof (+__real__ (Val)) == sizeof (float)) \ ? (__expr_is_real (Val) \ ? (__tgmath_complex_type (Val)) Fct##f (Val) \ : (__tgmath_complex_type (Val)) Cfct##f (Val)) \ : __TGMATH_CF128 ((Val), \ (__tgmath_complex_type (Val)) Fct, \ (__tgmath_complex_type (Val)) Cfct, \ (Val)) \ (__expr_is_real (Val) \ ? (__tgmath_complex_type (Val)) __tgml(Fct) (Val) \ : (__tgmath_complex_type (Val)) __tgml(Cfct) (Val)))) # define __TGMATH_UNARY_IMAG(Val, Cfct) \ (__extension__ ((sizeof (+__real__ (Val)) == sizeof (double) \ \|\| __builtin_classify_type (__real__ (Val)) != 8) \ ? (__typeof__ ((__tgmath_real_type (Val)) 0 \ + _Complex_I)) Cfct (Val) \ : (sizeof (+__real__ (Val)) == sizeof (float)) \ ? (__typeof__ ((__tgmath_real_type (Val)) 0 \ + _Complex_I)) Cfct##f (Val) \ : __TGMATH_F128 (__real__ (Val), \ (__typeof__ \ ((__tgmath_real_type (Val)) 0 \ + _Complex_I)) Cfct, (Val)) \ (__typeof__ ((__tgmath_real_type (Val)) 0 \ + _Complex_I)) __tgml(Cfct) (Val))) / XXX This definition has to be changed as soon as the compiler understands the imaginary keyword. / # define __TGMATH_UNARY_REAL_IMAG_RET_REAL(Val, Fct, Cfct) \ (__extension__ ((sizeof (+__real__ (Val)) == sizeof (double) \ \|\| __builtin_classify_type (__real__ (Val)) != 8) \ ? (__expr_is_real (Val) \ ? (__typeof__ (__real__ (__tgmath_real_type (Val)) 0))\ Fct (Val) \ : (__typeof__ (__real__ (__tgmath_real_type (Val)) 0))\ Cfct (Val)) \ : (sizeof (+__real__ (Val)) == sizeof (float)) \ ? (__expr_is_real (Val) \ ? (__typeof__ (__real__ (__tgmath_real_type (Val)) 0))\ Fct##f (Val) \ : (__typeof__ (__real__ (__tgmath_real_type (Val)) 0))\ Cfct##f (Val)) \ : __TGMATH_CF128 ((Val), \ (__typeof__ \ (__real__ \ (__tgmath_real_type (Val)) 0)) Fct, \ (__typeof__ \ (__real__ \ (__tgmath_real_type (Val)) 0)) Cfct, \ (Val)) \ (__expr_is_real (Val) \ ? (__typeof__ (__real__ (__tgmath_real_type (Val)) 0)) \ __tgml(Fct) (Val) \ : (__typeof__ (__real__ (__tgmath_real_type (Val)) 0)) \ __tgml(Cfct) (Val)))) # define __TGMATH_UNARY_REAL_IMAG_RET_REAL_SAME(Val, Cfct) \ __TGMATH_UNARY_REAL_IMAG_RET_REAL ((Val), Cfct, Cfct) # endif # if !__HAVE_BUILTIN_TGMATH_C2X / XXX This definition has to be changed as soon as the compiler understands the imaginary keyword. / # define __TGMATH_BINARY_REAL_IMAG(Val1, Val2, Fct, Cfct) \ (__extension__ ((sizeof (__real__ (Val1) \ + __real__ (Val2)) > sizeof (double) \ && __builtin_classify_type (__real__ (Val1) \ + __real__ (Val2)) == 8) \ ? __TGMATH_CF128 ((Val1) + (Val2), \ (__tgmath_complex_type2 (Val1, Val2)) \ Fct, \ (__tgmath_complex_type2 (Val1, Val2)) \ Cfct, \ (Val1, Val2)) \ (__expr_is_real ((Val1) + (Val2)) \ ? (__tgmath_complex_type2 (Val1, Val2)) \ __tgml(Fct) (Val1, Val2) \ : (__tgmath_complex_type2 (Val1, Val2)) \ __tgml(Cfct) (Val1, Val2)) \ : (sizeof (+__real__ (Val1)) == sizeof (double) \ \|\| sizeof (+__real__ (Val2)) == sizeof (double) \ \|\| __builtin_classify_type (__real__ (Val1)) != 8 \ \|\| __builtin_classify_type (__real__ (Val2)) != 8) \ ? (__expr_is_real ((Val1) + (Val2)) \ ? (__tgmath_complex_type2 (Val1, Val2)) \ Fct (Val1, Val2) \ : (__tgmath_complex_type2 (Val1, Val2)) \ Cfct (Val1, Val2)) \ : (__expr_is_real ((Val1) + (Val2)) \ ? (__tgmath_complex_type2 (Val1, Val2)) \ Fct##f (Val1, Val2) \ : (__tgmath_complex_type2 (Val1, Val2)) \ Cfct##f (Val1, Val2)))) # endif # if !__HAVE_BUILTIN_TGMATH # define __TGMATH_2_NARROW_F(F, X, Y) \ (__extension__ (sizeof ((__tgmath_real_type (X)) 0 \ + (__tgmath_real_type (Y)) 0) > sizeof (double) \ ? F ## l (X, Y) \ : F (X, Y))) # endif / In most cases, these narrowing macro definitions based on sizeof ensure that the function called has the right argument format, as for other <tgmath.h> macros for compilers before GCC 8, but may not have exactly the argument type (among the types with that format) specified in the standard logic. In the case of macros for _Float32x return type, when _Float64x exists, _Float64 arguments should result in the f64 function being called while _Float32x, float and double arguments should result in the f64x function being called (and integer arguments are considered to have type _Float32x if any argument has type _FloatNx, or double otherwise). These cases cannot be distinguished using sizeof (or at all if the types are typedefs rather than different types, in which case we err on the side of using the wider type if unsure). / # if !__HAVE_BUILTIN_TGMATH_C2X # if __HAVE_FLOATN_NOT_TYPEDEF # define __TGMATH_NARROW_F32X_USE_F64X(X) \ !__builtin_types_compatible_p (__typeof (+(X)), _Float64) # else # define __TGMATH_NARROW_F32X_USE_F64X(X) \ (__builtin_types_compatible_p (__typeof (+(X)), double) \ \|\| __builtin_types_compatible_p (__typeof (+(X)), float) \ \|\| !__floating_type (__typeof (+(X)))) # endif # endif # if __HAVE_FLOAT64X_LONG_DOUBLE && __HAVE_DISTINCT_FLOAT128 # if !__HAVE_BUILTIN_TGMATH # define __TGMATH_2_NARROW_F32(F, X, Y) \ (__extension__ (sizeof ((__tgmath_real_type (X)) 0 \ + (__tgmath_real_type (Y)) 0) > sizeof (_Float64) \ ? __TGMATH_F128LD ((X) + (Y), F, (X, Y)) \ F ## f64x (X, Y) \ : F ## f64 (X, Y))) # define __TGMATH_2_NARROW_F64(F, X, Y) \ (__extension__ (sizeof ((__tgmath_real_type (X)) 0 \ + (__tgmath_real_type (Y)) 0) > sizeof (_Float64) \ ? __TGMATH_F128LD ((X) + (Y), F, (X, Y)) \ F ## f64x (X, Y) \ : F ## f128 (X, Y))) # endif # if !__HAVE_BUILTIN_TGMATH_C2X # define __TGMATH_2_NARROW_F32X(F, X, Y) \ (__extension__ (sizeof ((__tgmath_real_type (X)) 0 \ + (__tgmath_real_type (Y)) 0) > sizeof (_Float64) \ \|\| __TGMATH_NARROW_F32X_USE_F64X ((X) + (Y)) \ ? __TGMATH_F128 ((X) + (Y), F, (X, Y)) \ F ## f64x (X, Y) \ : F ## f64 (X, Y))) # endif # elif __HAVE_FLOAT128 # if !__HAVE_BUILTIN_TGMATH # define __TGMATH_2_NARROW_F32(F, X, Y) \ (__extension__ (sizeof ((__tgmath_real_type (X)) 0 \ + (__tgmath_real_type (Y)) 0) > sizeof (_Float64) \ ? F ## f128 (X, Y) \ : F ## f64 (X, Y))) # define __TGMATH_2_NARROW_F64(F, X, Y) \ (F ## f128 (X, Y)) # endif # if !__HAVE_BUILTIN_TGMATH_C2X # define __TGMATH_2_NARROW_F32X(F, X, Y) \ (__extension__ (sizeof ((__tgmath_real_type (X)) 0 \ + (__tgmath_real_type (Y)) 0) > sizeof (_Float32x) \ \|\| __TGMATH_NARROW_F32X_USE_F64X ((X) + (Y)) \ ? F ## f64x (X, Y) \ : F ## f64 (X, Y))) # endif # else # if !__HAVE_BUILTIN_TGMATH # define __TGMATH_2_NARROW_F32(F, X, Y) \ (F ## f64 (X, Y)) # endif # endif #else # error "Unsupported compiler; you cannot use <tgmath.h>" #endif / Unary functions defined for real and complex values. / / Trigonometric functions. / / Arc cosine of X. / #define acos(Val) __TGMATH_UNARY_REAL_IMAG (Val, acos, cacos) / Arc sine of X. / #define asin(Val) __TGMATH_UNARY_REAL_IMAG (Val, asin, casin) / Arc tangent of X. / #define atan(Val) __TGMATH_UNARY_REAL_IMAG (Val, atan, catan) / Arc tangent of Y/X. / #define atan2(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, atan2) / Cosine of X. / #define cos(Val) __TGMATH_UNARY_REAL_IMAG (Val, cos, ccos) / Sine of X. / #define sin(Val) __TGMATH_UNARY_REAL_IMAG (Val, sin, csin) / Tangent of X. / #define tan(Val) __TGMATH_UNARY_REAL_IMAG (Val, tan, ctan) / Hyperbolic functions. / / Hyperbolic arc cosine of X. / #define acosh(Val) __TGMATH_UNARY_REAL_IMAG (Val, acosh, cacosh) / Hyperbolic arc sine of X. / #define asinh(Val) __TGMATH_UNARY_REAL_IMAG (Val, asinh, casinh) / Hyperbolic arc tangent of X. / #define atanh(Val) __TGMATH_UNARY_REAL_IMAG (Val, atanh, catanh) / Hyperbolic cosine of X. / #define cosh(Val) __TGMATH_UNARY_REAL_IMAG (Val, cosh, ccosh) / Hyperbolic sine of X. / #define sinh(Val) __TGMATH_UNARY_REAL_IMAG (Val, sinh, csinh) / Hyperbolic tangent of X. / #define tanh(Val) __TGMATH_UNARY_REAL_IMAG (Val, tanh, ctanh) / Exponential and logarithmic functions. / / Exponential function of X. / #define exp(Val) __TGMATH_UNARY_REAL_IMAG (Val, exp, cexp) / Break VALUE into a normalized fraction and an integral power of 2. / #define frexp(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, frexp) / X times (two to the EXP power). / #define ldexp(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, ldexp) / Natural logarithm of X. / #define log(Val) __TGMATH_UNARY_REAL_IMAG (Val, log, clog) / Base-ten logarithm of X. / #ifdef __USE_GNU # define log10(Val) __TGMATH_UNARY_REAL_IMAG (Val, log10, clog10) #else # define log10(Val) __TGMATH_UNARY_REAL_ONLY (Val, log10) #endif / Return exp(X) - 1. / #define expm1(Val) __TGMATH_UNARY_REAL_ONLY (Val, expm1) / Return log(1 + X). / #define log1p(Val) __TGMATH_UNARY_REAL_ONLY (Val, log1p) / Return the base 2 signed integral exponent of X. / #define logb(Val) __TGMATH_UNARY_REAL_ONLY (Val, logb) / Compute base-2 exponential of X. / #define exp2(Val) __TGMATH_UNARY_REAL_ONLY (Val, exp2) / Compute base-2 logarithm of X. / #define log2(Val) __TGMATH_UNARY_REAL_ONLY (Val, log2) / Power functions. / / Return X to the Y power. / #define pow(Val1, Val2) __TGMATH_BINARY_REAL_IMAG (Val1, Val2, pow, cpow) / Return the square root of X. / #define sqrt(Val) __TGMATH_UNARY_REAL_IMAG (Val, sqrt, csqrt) / Return `sqrt(XX + YY)'. / #define hypot(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, hypot) / Return the cube root of X. / #define cbrt(Val) __TGMATH_UNARY_REAL_ONLY (Val, cbrt) / Nearest integer, absolute value, and remainder functions. / / Smallest integral value not less than X. / #define ceil(Val) __TGMATH_UNARY_REAL_ONLY (Val, ceil) / Absolute value of X. / #define fabs(Val) __TGMATH_UNARY_REAL_IMAG_RET_REAL (Val, fabs, cabs) / Largest integer not greater than X. / #define floor(Val) __TGMATH_UNARY_REAL_ONLY (Val, floor) / Floating-point modulo remainder of X/Y. / #define fmod(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmod) / Round X to integral valuein floating-point format using current rounding direction, but do not raise inexact exception. / #define nearbyint(Val) __TGMATH_UNARY_REAL_ONLY (Val, nearbyint) / Round X to nearest integral value, rounding halfway cases away from zero. / #define round(Val) __TGMATH_UNARY_REAL_ONLY (Val, round) / Round X to the integral value in floating-point format nearest but not larger in magnitude. / #define trunc(Val) __TGMATH_UNARY_REAL_ONLY (Val, trunc) / Compute remainder of X and Y and put in QUO a value with sign of x/y and magnitude congruent `mod 2^n' to the magnitude of the integral quotient x/y, with n >= 3. / #define remquo(Val1, Val2, Val3) \ __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY (Val1, Val2, Val3, remquo) /* Round X to nearest integral value according to current rounding direction. / #define lrint(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, lrint) #define llrint(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, llrint) / Round X to nearest integral value, rounding halfway cases away from zero. / #define lround(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, lround) #define llround(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, llround) / Return X with its signed changed to Y's. / #define copysign(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, copysign) / Error and gamma functions. / #define erf(Val) __TGMATH_UNARY_REAL_ONLY (Val, erf) #define erfc(Val) __TGMATH_UNARY_REAL_ONLY (Val, erfc) #define tgamma(Val) __TGMATH_UNARY_REAL_ONLY (Val, tgamma) #define lgamma(Val) __TGMATH_UNARY_REAL_ONLY (Val, lgamma) / Return the integer nearest X in the direction of the prevailing rounding mode. / #define rint(Val) __TGMATH_UNARY_REAL_ONLY (Val, rint) #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) / Return X - epsilon. / # define nextdown(Val) __TGMATH_UNARY_REAL_ONLY (Val, nextdown) / Return X + epsilon. / # define nextup(Val) __TGMATH_UNARY_REAL_ONLY (Val, nextup) #endif / Return X + epsilon if X < Y, X - epsilon if X > Y. / #define nextafter(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, nextafter) #define nexttoward(Val1, Val2) \ __TGMATH_BINARY_FIRST_REAL_STD_ONLY (Val1, Val2, nexttoward) / Return the remainder of integer divison X / Y with infinite precision. / #define remainder(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, remainder) / Return X times (2 to the Nth power). / #ifdef __USE_MISC # define scalb(Val1, Val2) __TGMATH_BINARY_REAL_STD_ONLY (Val1, Val2, scalb) #endif / Return X times (2 to the Nth power). / #define scalbn(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, scalbn) / Return X times (2 to the Nth power). / #define scalbln(Val1, Val2) \ __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, scalbln) / Return the binary exponent of X, which must be nonzero. / #define ilogb(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, ilogb) / Return positive difference between X and Y. / #define fdim(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fdim) / Return maximum numeric value from X and Y. / #define fmax(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmax) / Return minimum numeric value from X and Y. / #define fmin(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmin) / Multiply-add function computed as a ternary operation. / #define fma(Val1, Val2, Val3) \ __TGMATH_TERNARY_REAL_ONLY (Val1, Val2, Val3, fma) #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) / Round X to nearest integer value, rounding halfway cases to even. / # define roundeven(Val) __TGMATH_UNARY_REAL_ONLY (Val, roundeven) # define fromfp(Val1, Val2, Val3) \ __TGMATH_TERNARY_FIRST_REAL_RET_ONLY (Val1, Val2, Val3, fromfp) # define ufromfp(Val1, Val2, Val3) \ __TGMATH_TERNARY_FIRST_REAL_RET_ONLY (Val1, Val2, Val3, ufromfp) # define fromfpx(Val1, Val2, Val3) \ __TGMATH_TERNARY_FIRST_REAL_RET_ONLY (Val1, Val2, Val3, fromfpx) # define ufromfpx(Val1, Val2, Val3) \ __TGMATH_TERNARY_FIRST_REAL_RET_ONLY (Val1, Val2, Val3, ufromfpx) / Like ilogb, but returning long int. / # define llogb(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, llogb) / Return value with maximum magnitude. / # define fmaxmag(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmaxmag) / Return value with minimum magnitude. / # define fminmag(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fminmag) #endif / Absolute value, conjugates, and projection. / / Argument value of Z. / #define carg(Val) __TGMATH_UNARY_REAL_IMAG_RET_REAL_SAME (Val, carg) / Complex conjugate of Z. / #define conj(Val) __TGMATH_UNARY_IMAG (Val, conj) / Projection of Z onto the Riemann sphere. / #define cproj(Val) __TGMATH_UNARY_IMAG (Val, cproj) / Decomposing complex values. / / Imaginary part of Z. / #define cimag(Val) __TGMATH_UNARY_REAL_IMAG_RET_REAL_SAME (Val, cimag) / Real part of Z. / #define creal(Val) __TGMATH_UNARY_REAL_IMAG_RET_REAL_SAME (Val, creal) / Narrowing functions. / #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) / Add. / # define fadd(Val1, Val2) __TGMATH_2_NARROW_F (fadd, Val1, Val2) # define dadd(Val1, Val2) __TGMATH_2_NARROW_D (dadd, Val1, Val2) / Divide. / # define fdiv(Val1, Val2) __TGMATH_2_NARROW_F (fdiv, Val1, Val2) # define ddiv(Val1, Val2) __TGMATH_2_NARROW_D (ddiv, Val1, Val2) / Multiply. / # define fmul(Val1, Val2) __TGMATH_2_NARROW_F (fmul, Val1, Val2) # define dmul(Val1, Val2) __TGMATH_2_NARROW_D (dmul, Val1, Val2) / Subtract. / # define fsub(Val1, Val2) __TGMATH_2_NARROW_F (fsub, Val1, Val2) # define dsub(Val1, Val2) __TGMATH_2_NARROW_D (dsub, Val1, Val2) #endif #if __GLIBC_USE (IEC_60559_TYPES_EXT) # if __HAVE_FLOAT16 # define f16add(Val1, Val2) __TGMATH_2_NARROW_F16 (f16add, Val1, Val2) # define f16div(Val1, Val2) __TGMATH_2_NARROW_F16 (f16div, Val1, Val2) # define f16mul(Val1, Val2) __TGMATH_2_NARROW_F16 (f16mul, Val1, Val2) # define f16sub(Val1, Val2) __TGMATH_2_NARROW_F16 (f16sub, Val1, Val2) # endif # if __HAVE_FLOAT32 # define f32add(Val1, Val2) __TGMATH_2_NARROW_F32 (f32add, Val1, Val2) # define f32div(Val1, Val2) __TGMATH_2_NARROW_F32 (f32div, Val1, Val2) # define f32mul(Val1, Val2) __TGMATH_2_NARROW_F32 (f32mul, Val1, Val2) # define f32sub(Val1, Val2) __TGMATH_2_NARROW_F32 (f32sub, Val1, Val2) # endif # if __HAVE_FLOAT64 && (__HAVE_FLOAT64X \|\| __HAVE_FLOAT128) # define f64add(Val1, Val2) __TGMATH_2_NARROW_F64 (f64add, Val1, Val2) # define f64div(Val1, Val2) __TGMATH_2_NARROW_F64 (f64div, Val1, Val2) # define f64mul(Val1, Val2) __TGMATH_2_NARROW_F64 (f64mul, Val1, Val2) # define f64sub(Val1, Val2) __TGMATH_2_NARROW_F64 (f64sub, Val1, Val2) # endif # if __HAVE_FLOAT32X # define f32xadd(Val1, Val2) __TGMATH_2_NARROW_F32X (f32xadd, Val1, Val2) # define f32xdiv(Val1, Val2) __TGMATH_2_NARROW_F32X (f32xdiv, Val1, Val2) # define f32xmul(Val1, Val2) __TGMATH_2_NARROW_F32X (f32xmul, Val1, Val2) # define f32xsub(Val1, Val2) __TGMATH_2_NARROW_F32X (f32xsub, Val1, Val2) # endif # if __HAVE_FLOAT64X && (__HAVE_FLOAT128X \|\| __HAVE_FLOAT128) # define f64xadd(Val1, Val2) __TGMATH_2_NARROW_F64X (f64xadd, Val1, Val2) # define f64xdiv(Val1, Val2) __TGMATH_2_NARROW_F64X (f64xdiv, Val1, Val2) # define f64xmul(Val1, Val2) __TGMATH_2_NARROW_F64X (f64xmul, Val1, Val2) # define f64xsub(Val1, Val2) __TGMATH_2_NARROW_F64X (f64xsub, Val1, Val2) # endif #endif #endif / tgmath.h */	39.24 KB	2026-02-17 11:01
📄 thread_db.h /* thread_db.h -- interface to libthread_db.so library for debugging -lpthread Copyright (C) 1999-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _THREAD_DB_H #define _THREAD_DB_H 1 / This is the debugger interface for the NPTL library. It is modelled closely after the interface with same names in Solaris with the goal to share the same code in the debugger. / #include <pthread.h> #include <stdint.h> #include <sys/types.h> #include <sys/procfs.h> / Error codes of the library. / typedef enum { TD_OK, / No error. / TD_ERR, / No further specified error. / TD_NOTHR, / No matching thread found. / TD_NOSV, / No matching synchronization handle found. / TD_NOLWP, / No matching light-weighted process found. / TD_BADPH, / Invalid process handle. / TD_BADTH, / Invalid thread handle. / TD_BADSH, / Invalid synchronization handle. / TD_BADTA, / Invalid thread agent. / TD_BADKEY, / Invalid key. / TD_NOMSG, / No event available. / TD_NOFPREGS, / No floating-point register content available. / TD_NOLIBTHREAD, / Application not linked with thread library. / TD_NOEVENT, / Requested event is not supported. / TD_NOCAPAB, / Capability not available. / TD_DBERR, / Internal debug library error. / TD_NOAPLIC, / Operation is not applicable. / TD_NOTSD, / No thread-specific data available. / TD_MALLOC, / Out of memory. / TD_PARTIALREG, / Not entire register set was read or written. / TD_NOXREGS, / X register set not available for given thread. / TD_TLSDEFER, / Thread has not yet allocated TLS for given module. / TD_NOTALLOC = TD_TLSDEFER, TD_VERSION, / Version if libpthread and libthread_db do not match. / TD_NOTLS / There is no TLS segment in the given module. / } td_err_e; / Possible thread states. TD_THR_ANY_STATE is a pseudo-state used to select threads regardless of state in td_ta_thr_iter(). / typedef enum { TD_THR_ANY_STATE, TD_THR_UNKNOWN, TD_THR_STOPPED, TD_THR_RUN, TD_THR_ACTIVE, TD_THR_ZOMBIE, TD_THR_SLEEP, TD_THR_STOPPED_ASLEEP } td_thr_state_e; / Thread type: user or system. TD_THR_ANY_TYPE is a pseudo-type used to select threads regardless of type in td_ta_thr_iter(). / typedef enum { TD_THR_ANY_TYPE, TD_THR_USER, TD_THR_SYSTEM } td_thr_type_e; / Types of the debugging library. / / Handle for a process. This type is opaque. / typedef struct td_thragent td_thragent_t; / The actual thread handle type. This is also opaque. / typedef struct td_thrhandle { td_thragent_t th_ta_p; psaddr_t th_unique; } td_thrhandle_t; /* Forward declaration of a type defined by and for the dynamic linker. / struct link_map; / Flags for `td_ta_thr_iter'. / #define TD_THR_ANY_USER_FLAGS 0xffffffff #define TD_THR_LOWEST_PRIORITY -20 #define TD_SIGNO_MASK NULL #define TD_EVENTSIZE 2 #define BT_UISHIFT 5 / log base 2 of BT_NBIPUI, to extract word index / #define BT_NBIPUI (1 << BT_UISHIFT) / n bits per unsigned int / #define BT_UIMASK (BT_NBIPUI - 1) / to extract bit index / / Bitmask of enabled events. / typedef struct td_thr_events { uint32_t event_bits[TD_EVENTSIZE]; } td_thr_events_t; / Event set manipulation macros. / #define __td_eventmask(n) \ (UINT32_C (1) << (((n) - 1) & BT_UIMASK)) #define __td_eventword(n) \ ((UINT32_C ((n) - 1)) >> BT_UISHIFT) #define td_event_emptyset(setp) \ do { \ int __i; \ for (__i = TD_EVENTSIZE; __i > 0; --__i) \ (setp)->event_bits[__i - 1] = 0; \ } while (0) #define td_event_fillset(setp) \ do { \ int __i; \ for (__i = TD_EVENTSIZE; __i > 0; --__i) \ (setp)->event_bits[__i - 1] = UINT32_C (0xffffffff); \ } while (0) #define td_event_addset(setp, n) \ (((setp)->event_bits[__td_eventword (n)]) \|= __td_eventmask (n)) #define td_event_delset(setp, n) \ (((setp)->event_bits[__td_eventword (n)]) &= ~__td_eventmask (n)) #define td_eventismember(setp, n) \ (__td_eventmask (n) & ((setp)->event_bits[__td_eventword (n)])) #if TD_EVENTSIZE == 2 # define td_eventisempty(setp) \ (!((setp)->event_bits[0]) && !((setp)->event_bits[1])) #else # error "td_eventisempty must be changed to match TD_EVENTSIZE" #endif / Events reportable by the thread implementation. / typedef enum { TD_ALL_EVENTS, / Pseudo-event number. / TD_EVENT_NONE = TD_ALL_EVENTS, / Depends on context. / TD_READY, / Is executable now. / TD_SLEEP, / Blocked in a synchronization obj. / TD_SWITCHTO, / Now assigned to a process. / TD_SWITCHFROM, / Not anymore assigned to a process. / TD_LOCK_TRY, / Trying to get an unavailable lock. / TD_CATCHSIG, / Signal posted to the thread. / TD_IDLE, / Process getting idle. / TD_CREATE, / New thread created. / TD_DEATH, / Thread terminated. / TD_PREEMPT, / Preempted. / TD_PRI_INHERIT, / Inherited elevated priority. / TD_REAP, / Reaped. / TD_CONCURRENCY, / Number of processes changing. / TD_TIMEOUT, / Conditional variable wait timed out. / TD_MIN_EVENT_NUM = TD_READY, TD_MAX_EVENT_NUM = TD_TIMEOUT, TD_EVENTS_ENABLE = 31 / Event reporting enabled. / } td_event_e; / Values representing the different ways events are reported. / typedef enum { NOTIFY_BPT, / User must insert breakpoint at u.bptaddr. / NOTIFY_AUTOBPT, / Breakpoint at u.bptaddr is automatically inserted. / NOTIFY_SYSCALL / System call u.syscallno will be invoked. / } td_notify_e; / Description how event type is reported. / typedef struct td_notify { td_notify_e type; / Way the event is reported. / union { psaddr_t bptaddr; / Address of breakpoint. / int syscallno; / Number of system call used. / } u; } td_notify_t; / Structure used to report event. / typedef struct td_event_msg { td_event_e event; / Event type being reported. / const td_thrhandle_t th_p; /* Thread reporting the event. / union { # if 0 td_synchandle_t sh; /* Handle of synchronization object. / #endif uintptr_t data; / Event specific data. / } msg; } td_event_msg_t; / Structure containing event data available in each thread structure. / typedef struct { td_thr_events_t eventmask; / Mask of enabled events. / td_event_e eventnum; / Number of last event. / void eventdata; /* Data associated with event. / } td_eventbuf_t; / Gathered statistics about the process. / typedef struct td_ta_stats { int nthreads; / Total number of threads in use. / int r_concurrency; / Concurrency level requested by user. / int nrunnable_num; / Average runnable threads, numerator. / int nrunnable_den; / Average runnable threads, denominator. / int a_concurrency_num; / Achieved concurrency level, numerator. / int a_concurrency_den; / Achieved concurrency level, denominator. / int nlwps_num; / Average number of processes in use, numerator. / int nlwps_den; / Average number of processes in use, denominator. / int nidle_num; / Average number of idling processes, numerator. / int nidle_den; / Average number of idling processes, denominator. / } td_ta_stats_t; / Since Sun's library is based on Solaris threads we have to define a few types to map them to POSIX threads. / typedef pthread_t thread_t; typedef pthread_key_t thread_key_t; / Callback for iteration over threads. / typedef int td_thr_iter_f (const td_thrhandle_t , void ); / Callback for iteration over thread local data. / typedef int td_key_iter_f (thread_key_t, void () (void ), void ); /* Forward declaration. This has to be defined by the user. / struct ps_prochandle; / Information about the thread. / typedef struct td_thrinfo { td_thragent_t ti_ta_p; /* Process handle. / unsigned int ti_user_flags; / Unused. / thread_t ti_tid; / Thread ID returned by pthread_create(). / char ti_tls; /* Pointer to thread-local data. / psaddr_t ti_startfunc; / Start function passed to pthread_create(). / psaddr_t ti_stkbase; / Base of thread's stack. / long int ti_stksize; / Size of thread's stack. / psaddr_t ti_ro_area; / Unused. / int ti_ro_size; / Unused. / td_thr_state_e ti_state; / Thread state. / unsigned char ti_db_suspended; / Nonzero if suspended by debugger. / td_thr_type_e ti_type; / Type of the thread (system vs user thread). / intptr_t ti_pc; / Unused. / intptr_t ti_sp; / Unused. / short int ti_flags; / Unused. / int ti_pri; / Thread priority. / lwpid_t ti_lid; / Kernel PID for this thread. / sigset_t ti_sigmask; / Signal mask. / unsigned char ti_traceme; / Nonzero if event reporting enabled. / unsigned char ti_preemptflag; / Unused. / unsigned char ti_pirecflag; / Unused. / sigset_t ti_pending; / Set of pending signals. / td_thr_events_t ti_events; / Set of enabled events. / } td_thrinfo_t; / Prototypes for exported library functions. / / Initialize the thread debug support library. / extern td_err_e td_init (void); / Historical relict. Should not be used anymore. / extern td_err_e td_log (void); / Return list of symbols the library can request. / extern const char td_symbol_list (void); / Generate new thread debug library handle for process PS. / extern td_err_e td_ta_new (struct ps_prochandle __ps, td_thragent_t *__ta); / Free resources allocated for TA. / extern td_err_e td_ta_delete (td_thragent_t __ta); /* Get number of currently running threads in process associated with TA. / extern td_err_e td_ta_get_nthreads (const td_thragent_t __ta, int __np); / Return process handle passed in `td_ta_new' for process associated with TA. / extern td_err_e td_ta_get_ph (const td_thragent_t __ta, struct ps_prochandle *__ph); / Map thread library handle PT to thread debug library handle for process associated with TA and store result in TH. / extern td_err_e td_ta_map_id2thr (const td_thragent_t __ta, pthread_t __pt, td_thrhandle_t __th); /* Map process ID LWPID to thread debug library handle for process associated with TA and store result in TH. / extern td_err_e td_ta_map_lwp2thr (const td_thragent_t __ta, lwpid_t __lwpid, td_thrhandle_t __th); /* Call for each thread in a process associated with TA the callback function CALLBACK. / extern td_err_e td_ta_thr_iter (const td_thragent_t __ta, td_thr_iter_f __callback, void __cbdata_p, td_thr_state_e __state, int __ti_pri, sigset_t __ti_sigmask_p, unsigned int __ti_user_flags); / Call for each defined thread local data entry the callback function KI. / extern td_err_e td_ta_tsd_iter (const td_thragent_t __ta, td_key_iter_f __ki, void __p); /* Get event address for EVENT. / extern td_err_e td_ta_event_addr (const td_thragent_t __ta, td_event_e __event, td_notify_t __ptr); / Enable EVENT in global mask. / extern td_err_e td_ta_set_event (const td_thragent_t __ta, td_thr_events_t __event); / Disable EVENT in global mask. / extern td_err_e td_ta_clear_event (const td_thragent_t __ta, td_thr_events_t __event); / Return information about last event. / extern td_err_e td_ta_event_getmsg (const td_thragent_t __ta, td_event_msg_t __msg); / Set suggested concurrency level for process associated with TA. / extern td_err_e td_ta_setconcurrency (const td_thragent_t __ta, int __level); /* Enable collecting statistics for process associated with TA. / extern td_err_e td_ta_enable_stats (const td_thragent_t __ta, int __enable); /* Reset statistics. / extern td_err_e td_ta_reset_stats (const td_thragent_t __ta); /* Retrieve statistics from process associated with TA. / extern td_err_e td_ta_get_stats (const td_thragent_t __ta, td_ta_stats_t __statsp); / Validate that TH is a thread handle. / extern td_err_e td_thr_validate (const td_thrhandle_t __th); /* Return information about thread TH. / extern td_err_e td_thr_get_info (const td_thrhandle_t __th, td_thrinfo_t __infop); / Retrieve floating-point register contents of process running thread TH. / extern td_err_e td_thr_getfpregs (const td_thrhandle_t __th, prfpregset_t __regset); / Retrieve general register contents of process running thread TH. / extern td_err_e td_thr_getgregs (const td_thrhandle_t __th, prgregset_t __gregs); /* Retrieve extended register contents of process running thread TH. / extern td_err_e td_thr_getxregs (const td_thrhandle_t __th, void __xregs); / Get size of extended register set of process running thread TH. / extern td_err_e td_thr_getxregsize (const td_thrhandle_t __th, int __sizep); / Set floating-point register contents of process running thread TH. / extern td_err_e td_thr_setfpregs (const td_thrhandle_t __th, const prfpregset_t __fpregs); / Set general register contents of process running thread TH. / extern td_err_e td_thr_setgregs (const td_thrhandle_t __th, prgregset_t __gregs); /* Set extended register contents of process running thread TH. / extern td_err_e td_thr_setxregs (const td_thrhandle_t __th, const void __addr); / Get address of the given module's TLS storage area for the given thread. / extern td_err_e td_thr_tlsbase (const td_thrhandle_t __th, unsigned long int __modid, psaddr_t __base); / Get address of thread local variable. / extern td_err_e td_thr_tls_get_addr (const td_thrhandle_t __th, psaddr_t __map_address, size_t __offset, psaddr_t __address); / Enable reporting for EVENT for thread TH. / extern td_err_e td_thr_event_enable (const td_thrhandle_t __th, int __event); /* Enable EVENT for thread TH. / extern td_err_e td_thr_set_event (const td_thrhandle_t __th, td_thr_events_t __event); / Disable EVENT for thread TH. / extern td_err_e td_thr_clear_event (const td_thrhandle_t __th, td_thr_events_t __event); / Get event message for thread TH. / extern td_err_e td_thr_event_getmsg (const td_thrhandle_t __th, td_event_msg_t __msg); / Set priority of thread TH. / extern td_err_e td_thr_setprio (const td_thrhandle_t __th, int __prio); /* Set pending signals for thread TH. / extern td_err_e td_thr_setsigpending (const td_thrhandle_t __th, unsigned char __n, const sigset_t __ss); / Set signal mask for thread TH. / extern td_err_e td_thr_sigsetmask (const td_thrhandle_t __th, const sigset_t __ss); / Return thread local data associated with key TK in thread TH. / extern td_err_e td_thr_tsd (const td_thrhandle_t __th, const thread_key_t __tk, void *__data); / Suspend execution of thread TH. / extern td_err_e td_thr_dbsuspend (const td_thrhandle_t __th); /* Resume execution of thread TH. / extern td_err_e td_thr_dbresume (const td_thrhandle_t __th); #endif /* thread_db.h */	15.65 KB	2026-02-17 11:02
📄 threads.h /* ISO C11 Standard: 7.26 - Thread support library <threads.h>. Copyright (C) 2018-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _THREADS_H #define _THREADS_H 1 #include <features.h> #include <time.h> __BEGIN_DECLS #include <bits/thread-shared-types.h> #include <bits/types/struct_timespec.h> #ifndef __cplusplus # define thread_local _Thread_local #endif #define TSS_DTOR_ITERATIONS 4 typedef __tss_t tss_t; typedef void (tss_dtor_t) (void); typedef __thrd_t thrd_t; typedef int (thrd_start_t) (void); / Exit and error codes. / enum { thrd_success = 0, thrd_busy = 1, thrd_error = 2, thrd_nomem = 3, thrd_timedout = 4 }; / Mutex types. / enum { mtx_plain = 0, mtx_recursive = 1, mtx_timed = 2 }; typedef __once_flag once_flag; #define ONCE_FLAG_INIT __ONCE_FLAG_INIT typedef union { char __size[__SIZEOF_PTHREAD_MUTEX_T]; long int __align __LOCK_ALIGNMENT; } mtx_t; typedef union { char __size[__SIZEOF_PTHREAD_COND_T]; __extension__ long long int __align __LOCK_ALIGNMENT; } cnd_t; / Threads functions. / / Create a new thread executing the function __FUNC. Arguments for __FUNC are passed through __ARG. If succesful, __THR is set to new thread identifier. / extern int thrd_create (thrd_t __thr, thrd_start_t __func, void __arg); / Check if __LHS and __RHS point to the same thread. / extern int thrd_equal (thrd_t __lhs, thrd_t __rhs); / Return current thread identifier. / extern thrd_t thrd_current (void); / Block current thread execution for at least the time pointed by __TIME_POINT. The current thread may resume if receives a signal. In that case, if __REMAINING is not NULL, the remaining time is stored in the object pointed by it. / #ifndef __USE_TIME_BITS64 extern int thrd_sleep (const struct timespec __time_point, struct timespec __remaining); #else # ifdef __REDIRECT extern int __REDIRECT (thrd_sleep, (const struct timespec __time_point, struct timespec __remaining), __thrd_sleep64); # else # define thrd_sleep __thrd_sleep64 # endif #endif / Terminate current thread execution, cleaning up any thread local storage and freeing resources. Returns the value specified in __RES. / extern void thrd_exit (int __res) __attribute__ ((__noreturn__)); / Detach the thread identified by __THR from the current environment (it does not allow join or wait for it). / extern int thrd_detach (thrd_t __thr); / Block current thread until execution of __THR is complete. In case that __RES is not NULL, will store the return value of __THR when exiting. / extern int thrd_join (thrd_t __thr, int __res); /* Stop current thread execution and call the scheduler to decide which thread should execute next. The current thread may be selected by the scheduler to keep running. / extern void thrd_yield (void); #ifdef __USE_EXTERN_INLINES / Optimizations. / __extern_inline int thrd_equal (thrd_t __thread1, thrd_t __thread2) { return __thread1 == __thread2; } #endif / Mutex functions. / / Creates a new mutex object with type __TYPE. If successful the new object is pointed by __MUTEX. / extern int mtx_init (mtx_t __mutex, int __type); /* Block the current thread until the mutex pointed to by __MUTEX is unlocked. In that case current thread will not be blocked. / extern int mtx_lock (mtx_t __mutex); /* Block the current thread until the mutex pointed by __MUTEX is unlocked or time pointed by __TIME_POINT is reached. In case the mutex is unlock, the current thread will not be blocked. / #ifndef __USE_TIME_BITS64 extern int mtx_timedlock (mtx_t __restrict __mutex, const struct timespec __restrict __time_point); #else # ifdef __REDIRECT extern int __REDIRECT (mtx_timedlock, (mtx_t __restrict __mutex, const struct timespec __restrict __time_point), __mtx_timedlock64); # else # define mtx_timedlock __mtx_timedlock64 # endif #endif / Try to lock the mutex pointed by __MUTEX without blocking. If the mutex is free the current threads takes control of it, otherwise it returns immediately. / extern int mtx_trylock (mtx_t __mutex); /* Unlock the mutex pointed by __MUTEX. It may potentially awake other threads waiting on this mutex. / extern int mtx_unlock (mtx_t __mutex); /* Destroy the mutex object pointed by __MUTEX. / extern void mtx_destroy (mtx_t __mutex); /* Call function __FUNC exactly once, even if invoked from several threads. All calls must be made with the same __FLAGS object. / extern void call_once (once_flag __flag, void (__func)(void)); / Condition variable functions. / / Initialize new condition variable pointed by __COND. / extern int cnd_init (cnd_t __cond); /* Unblock one thread that currently waits on condition variable pointed by __COND. / extern int cnd_signal (cnd_t __cond); /* Unblock all threads currently waiting on condition variable pointed by __COND. / extern int cnd_broadcast (cnd_t __cond); /* Block current thread on the condition variable pointed by __COND. / extern int cnd_wait (cnd_t __cond, mtx_t __mutex); / Block current thread on the condition variable until condition variable pointed by __COND is signaled or time pointed by __TIME_POINT is reached. / #ifndef __USE_TIME_BITS64 extern int cnd_timedwait (cnd_t __restrict __cond, mtx_t __restrict __mutex, const struct timespec __restrict __time_point); #else # ifdef __REDIRECT extern int __REDIRECT (cnd_timedwait, (cnd_t __restrict __cond, mtx_t __restrict __mutex, const struct timespec __restrict __time_point), __cnd_timedwait64); # else # define cnd_timedwait __cnd_timedwait64 # endif #endif / Destroy condition variable pointed by __cond and free all of its resources. / extern void cnd_destroy (cnd_t __COND); /* Thread specific storage functions. / / Create new thread-specific storage key and stores it in the object pointed by __TSS_ID. If __DESTRUCTOR is not NULL, the function will be called when the thread terminates. / extern int tss_create (tss_t __tss_id, tss_dtor_t __destructor); /* Return the value held in thread-specific storage for the current thread identified by __TSS_ID. / extern void tss_get (tss_t __tss_id); /* Sets the value of the thread-specific storage identified by __TSS_ID for the current thread to __VAL. / extern int tss_set (tss_t __tss_id, void __val); /* Destroys the thread-specific storage identified by __TSS_ID. The destructor is not called until thrd_exit is called. / extern void tss_delete (tss_t __tss_id); __END_DECLS #endif / _THREADS_H */	7.51 KB	2026-02-17 11:01
📄 time.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99 Standard: 7.23 Date and time <time.h> / #ifndef _TIME_H #define _TIME_H 1 #include <features.h> #define __need_size_t #define __need_NULL #include <stddef.h> / This defines CLOCKS_PER_SEC, which is the number of processor clock ticks per second, and possibly a number of other constants. / #include <bits/time.h> / Many of the typedefs and structs whose official home is this header may also need to be defined by other headers. / #include <bits/types/clock_t.h> #include <bits/types/time_t.h> #include <bits/types/struct_tm.h> #if defined __USE_POSIX199309 \|\| defined __USE_ISOC11 # include <bits/types/struct_timespec.h> #endif #ifdef __USE_POSIX199309 # include <bits/types/clockid_t.h> # include <bits/types/timer_t.h> # include <bits/types/struct_itimerspec.h> struct sigevent; #endif #ifdef __USE_XOPEN2K # ifndef __pid_t_defined typedef __pid_t pid_t; # define __pid_t_defined # endif #endif #ifdef __USE_XOPEN2K8 # include <bits/types/locale_t.h> #endif #ifdef __USE_ISOC11 / Time base values for timespec_get. / # define TIME_UTC 1 #endif __BEGIN_DECLS / Time used by the program so far (user time + system time). The result / CLOCKS_PER_SEC is program time in seconds. / extern clock_t clock (void) __THROW; #ifndef __USE_TIME_BITS64 / Return the current time and put it in TIMER if TIMER is not NULL. / extern time_t time (time_t __timer) __THROW; / Return the difference between TIME1 and TIME0. / extern double difftime (time_t __time1, time_t __time0) __THROW __attribute__ ((__const__)); / Return the `time_t' representation of TP and normalize TP. / extern time_t mktime (struct tm __tp) __THROW; #else # ifdef __REDIRECT_NTH extern time_t __REDIRECT_NTH (time, (time_t __timer), __time64); extern double __REDIRECT_NTH (difftime, (time_t __time1, time_t __time0), __difftime64) __attribute__ ((__const__)); extern time_t __REDIRECT_NTH (mktime, (struct tm __tp), __mktime64); # else # define time __time64 # define difftime __difftime64 # define mktime __mktime64 # endif #endif /* Format TP into S according to FORMAT. Write no more than MAXSIZE characters and return the number of characters written, or 0 if it would exceed MAXSIZE. / extern size_t strftime (char __restrict __s, size_t __maxsize, const char __restrict __format, const struct tm __restrict __tp) __THROW; #ifdef __USE_XOPEN /* Parse S according to FORMAT and store binary time information in TP. The return value is a pointer to the first unparsed character in S. / extern char strptime (const char __restrict __s, const char __restrict __fmt, struct tm __tp) __THROW; #endif #ifdef __USE_XOPEN2K8 / Similar to the two functions above but take the information from the provided locale and not the global locale. / extern size_t strftime_l (char __restrict __s, size_t __maxsize, const char __restrict __format, const struct tm __restrict __tp, locale_t __loc) __THROW; #endif #ifdef __USE_GNU extern char strptime_l (const char __restrict __s, const char __restrict __fmt, struct tm __tp, locale_t __loc) __THROW; #endif #ifndef __USE_TIME_BITS64 /* Return the `struct tm' representation of TIMER in Universal Coordinated Time (aka Greenwich Mean Time). / extern struct tm gmtime (const time_t __timer) __THROW; /* Return the `struct tm' representation of TIMER in the local timezone. / extern struct tm localtime (const time_t __timer) __THROW; #else # ifdef __REDIRECT_NTH extern struct tm__REDIRECT_NTH (gmtime, (const time_t __timer), __gmtime64); extern struct tm __REDIRECT_NTH (localtime, (const time_t __timer), __localtime64); # else # define gmtime __gmtime64 # define localtime __localtime64 # endif #endif #if defined __USE_POSIX \|\| __GLIBC_USE (ISOC2X) # ifndef __USE_TIME_BITS64 /* Return the `struct tm' representation of TIMER in UTC, using TP to store the result. / extern struct tm gmtime_r (const time_t __restrict __timer, struct tm __restrict __tp) __THROW; /* Return the `struct tm' representation of TIMER in local time, using TP to store the result. / extern struct tm localtime_r (const time_t __restrict __timer, struct tm __restrict __tp) __THROW; # else # ifdef __REDIRECT_NTH extern struct tm__REDIRECT_NTH (gmtime_r, (const time_t __restrict __timer, struct tm __restrict __tp), __gmtime64_r); extern struct tm__REDIRECT_NTH (localtime_r, (const time_t __restrict __t, struct tm __restrict __tp), __localtime64_r); # else # define gmtime_r __gmtime64_r # define localtime_r __localtime_r # endif # endif #endif /* POSIX \|\| C2X / / Return a string of the form "Day Mon dd hh:mm:ss yyyy\n" that is the representation of TP in this format. / extern char asctime (const struct tm __tp) __THROW; / Equivalent to `asctime (localtime (timer))'. / #ifndef __USE_TIME_BITS64 extern char ctime (const time_t __timer) __THROW; #else # ifdef __REDIRECT_NTH extern char __REDIRECT_NTH (ctime, (const time_t __timer), __ctime64); # else # define ctime __ctime64 # endif #endif #ifdef __USE_POSIX / Reentrant versions of the above functions. / / Return in BUF a string of the form "Day Mon dd hh:mm:ss yyyy\n" that is the representation of TP in this format. / extern char asctime_r (const struct tm __restrict __tp, char __restrict __buf) __THROW; /* Equivalent to `asctime_r (localtime_r (timer, TMP), buf)'. / #ifndef __USE_TIME_BITS64 extern char ctime_r (const time_t __restrict __timer, char __restrict __buf) __THROW; #else # ifdef __REDIRECT_NTH extern char __REDIRECT_NTH (ctime_r, (const time_t __restrict __timer, char __restrict __buf), __ctime64_r); # else # define ctime_r __ctime64_r # endif #endif #endif / POSIX / / Defined in localtime.c. / extern char __tzname[2]; /* Current time zone abbreviations. / extern int __daylight; / If daylight-saving time is ever in use. / extern long int __timezone; / Seconds west of UTC. / #ifdef __USE_POSIX / Same as above. / extern char tzname[2]; /* Set time conversion information from the TZ environment variable. If TZ is not defined, a locale-dependent default is used. / extern void tzset (void) __THROW; #endif #if defined __USE_MISC \|\| defined __USE_XOPEN extern int daylight; extern long int timezone; #endif / Nonzero if YEAR is a leap year (every 4 years, except every 100th isn't, and every 400th is). / #define __isleap(year) \ ((year) % 4 == 0 && ((year) % 100 != 0 \|\| (year) % 400 == 0)) #ifdef __USE_MISC / Miscellaneous functions many Unices inherited from the public domain localtime package. These are included only for compatibility. / #ifndef __USE_TIME_BITS64 / Like `mktime', but for TP represents Universal Time, not local time. / extern time_t timegm (struct tm __tp) __THROW; /* Another name for `mktime'. / extern time_t timelocal (struct tm __tp) __THROW; #else # ifdef __REDIRECT_NTH extern time_t __REDIRECT_NTH (timegm, (struct tm __tp), __timegm64); extern time_t __REDIRECT_NTH (timelocal, (struct tm __tp), __mktime64); # else # define timegm __timegm64 # endif #endif /* Return the number of days in YEAR. / extern int dysize (int __year) __THROW __attribute__ ((__const__)); #endif #ifdef __USE_POSIX199309 # ifndef __USE_TIME_BITS64 / Pause execution for a number of nanoseconds. This function is a cancellation point and therefore not marked with __THROW. / extern int nanosleep (const struct timespec __requested_time, struct timespec __remaining); / Get resolution of clock CLOCK_ID. / extern int clock_getres (clockid_t __clock_id, struct timespec __res) __THROW; /* Get current value of clock CLOCK_ID and store it in TP. / extern int clock_gettime (clockid_t __clock_id, struct timespec __tp) __THROW; /* Set clock CLOCK_ID to value TP. / extern int clock_settime (clockid_t __clock_id, const struct timespec __tp) __THROW; # else # ifdef __REDIRECT extern int __REDIRECT (nanosleep, (const struct timespec __requested_time, struct timespec __remaining), __nanosleep64); extern int __REDIRECT_NTH (clock_getres, (clockid_t __clock_id, struct timespec __res), __clock_getres64); extern int __REDIRECT_NTH (clock_gettime, (clockid_t __clock_id, struct timespec __tp), __clock_gettime64); extern int __REDIRECT_NTH (clock_settime, (clockid_t __clock_id, const struct timespec __tp), __clock_settime64); # else # define nanosleep __nanosleep64 # define clock_getres __clock_getres64 # define clock_gettime __clock_gettime64 # define clock_settime __clock_settime64 # endif # endif # ifdef __USE_XOPEN2K / High-resolution sleep with the specified clock. This function is a cancellation point and therefore not marked with __THROW. / # ifndef __USE_TIME_BITS64 extern int clock_nanosleep (clockid_t __clock_id, int __flags, const struct timespec __req, struct timespec __rem); # else # ifdef __REDIRECT extern int __REDIRECT (clock_nanosleep, (clockid_t __clock_id, int __flags, const struct timespec __req, struct timespec __rem), __clock_nanosleep_time64); # else # define clock_nanosleep __clock_nanosleep_time64 # endif # endif / Return clock ID for CPU-time clock. / extern int clock_getcpuclockid (pid_t __pid, clockid_t __clock_id) __THROW; # endif /* Create new per-process timer using CLOCK_ID. / extern int timer_create (clockid_t __clock_id, struct sigevent __restrict __evp, timer_t __restrict __timerid) __THROW; / Delete timer TIMERID. / extern int timer_delete (timer_t __timerid) __THROW; / Set timer TIMERID to VALUE, returning old value in OVALUE. / # ifndef __USE_TIME_BITS64 extern int timer_settime (timer_t __timerid, int __flags, const struct itimerspec __restrict __value, struct itimerspec __restrict __ovalue) __THROW; / Get current value of timer TIMERID and store it in VALUE. / extern int timer_gettime (timer_t __timerid, struct itimerspec __value) __THROW; # else # ifdef __REDIRECT_NTH extern int __REDIRECT_NTH (timer_settime, (timer_t __timerid, int __flags, const struct itimerspec __restrict __value, struct itimerspec __restrict __ovalue), __timer_settime64); extern int __REDIRECT_NTH (timer_gettime, (timer_t __timerid, struct itimerspec __value), __timer_gettime64); # else # define timer_settime __timer_settime64 # define timer_gettime __timer_gettime64 # endif # endif / Get expiration overrun for timer TIMERID. / extern int timer_getoverrun (timer_t __timerid) __THROW; #endif #ifdef __USE_ISOC11 # ifndef __USE_TIME_BITS64 / Set TS to calendar time based in time base BASE. / extern int timespec_get (struct timespec __ts, int __base) __THROW __nonnull ((1)); # else # ifdef __REDIRECT_NTH extern int __REDIRECT_NTH (timespec_get, (struct timespec __ts, int __base), __timespec_get64) __nonnull ((1)); # else # define timespec_get __timespec_get64 # endif # endif #endif #if __GLIBC_USE (ISOC2X) # ifndef __USE_TIME_BITS64 / Set TS to resolution of time base BASE. / extern int timespec_getres (struct timespec __ts, int __base) __THROW; # else # ifdef __REDIRECT_NTH extern int __REDIRECT_NTH (timespec_getres, (struct timespec __ts, int __base), __timespec_getres64); # else # define timespec_getres __timespec_getres64 # endif # endif #endif #ifdef __USE_XOPEN_EXTENDED / Set to one of the following values to indicate an error. 1 the DATEMSK environment variable is null or undefined, 2 the template file cannot be opened for reading, 3 failed to get file status information, 4 the template file is not a regular file, 5 an error is encountered while reading the template file, 6 memory allication failed (not enough memory available), 7 there is no line in the template that matches the input, 8 invalid input specification Example: February 31 or a time is specified that can not be represented in a time_t (representing the time in seconds since 00:00:00 UTC, January 1, 1970) / extern int getdate_err; / Parse the given string as a date specification and return a value representing the value. The templates from the file identified by the environment variable DATEMSK are used. In case of an error `getdate_err' is set. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct tm getdate (const char __string); #endif #ifdef __USE_GNU / Since `getdate' is not reentrant because of the use of `getdate_err' and the static buffer to return the result in, we provide a thread-safe variant. The functionality is the same. The result is returned in the buffer pointed to by RESBUFP and in case of an error the return value is != 0 with the same values as given above for `getdate_err'. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int getdate_r (const char __restrict __string, struct tm __restrict __resbufp); #endif __END_DECLS #endif / time.h. */	14.5 KB	2026-02-17 11:01
📄 ttyent.h /* * 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. * * @(#)ttyent.h 8.1 (Berkeley) 6/2/93 / #ifndef _TTYENT_H #define _TTYENT_H 1 #include <features.h> #define _PATH_TTYS "/etc/ttys" #define _TTYS_OFF "off" #define _TTYS_ON "on" #define _TTYS_SECURE "secure" #define _TTYS_WINDOW "window" struct ttyent { char ty_name; /* terminal device name / char ty_getty; /* command to execute, usually getty / char ty_type; /* terminal type for termcap / #define TTY_ON 0x01 / enable logins (start ty_getty program) / #define TTY_SECURE 0x02 / allow uid of 0 to login / int ty_status; / status flags / char ty_window; /* command to start up window manager / char ty_comment; /* comment field / }; __BEGIN_DECLS extern struct ttyent getttyent (void) __THROW; extern struct ttyent getttynam (const char __tty) __THROW; extern int setttyent (void) __THROW; extern int endttyent (void) __THROW; __END_DECLS #endif /* ttyent.h */	2.44 KB	2026-02-17 11:01
📄 uchar.h /* Copyright (C) 2011-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C11 Standard: 7.28 * Unicode utilities <uchar.h> / #ifndef _UCHAR_H #define _UCHAR_H 1 #include <features.h> #define __need_size_t #include <stddef.h> #include <bits/types.h> #include <bits/types/mbstate_t.h> #ifndef __USE_ISOCXX11 / Define the 16-bit and 32-bit character types. / typedef __uint_least16_t char16_t; typedef __uint_least32_t char32_t; #endif __BEGIN_DECLS / Write char16_t representation of multibyte character pointed to by S to PC16. / extern size_t mbrtoc16 (char16_t __restrict __pc16, const char __restrict __s, size_t __n, mbstate_t __restrict __p) __THROW; /* Write multibyte representation of char16_t C16 to S. / extern size_t c16rtomb (char __restrict __s, char16_t __c16, mbstate_t __restrict __ps) __THROW; / Write char32_t representation of multibyte character pointed to by S to PC32. / extern size_t mbrtoc32 (char32_t __restrict __pc32, const char __restrict __s, size_t __n, mbstate_t __restrict __p) __THROW; /* Write multibyte representation of char32_t C32 to S. / extern size_t c32rtomb (char __restrict __s, char32_t __c32, mbstate_t __restrict __ps) __THROW; __END_DECLS #endif / uchar.h */	1.96 KB	2026-02-17 11:01
📄 ucontext.h /* Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / System V ABI compliant user-level context switching support. / #ifndef _UCONTEXT_H #define _UCONTEXT_H 1 #include <features.h> / Get definition of __INDIRECT_RETURN. / #include <bits/indirect-return.h> / Get machine dependent definition of data structures. / #include <sys/ucontext.h> __BEGIN_DECLS / Get user context and store it in variable pointed to by UCP. / extern int getcontext (ucontext_t __ucp) __THROWNL; /* Set user context from information of variable pointed to by UCP. / extern int setcontext (const ucontext_t __ucp) __THROWNL; /* Save current context in context variable pointed to by OUCP and set context from variable pointed to by UCP. / extern int swapcontext (ucontext_t __restrict __oucp, const ucontext_t __restrict __ucp) __THROWNL __INDIRECT_RETURN; / Manipulate user context UCP to continue with calling functions FUNC and the ARGC-1 parameters following ARGC when the context is used the next time in `setcontext' or `swapcontext'. We cannot say anything about the parameters FUNC takes; `void' is as good as any other choice. / extern void makecontext (ucontext_t __ucp, void (__func) (void), int __argc, ...) __THROW; __END_DECLS #endif / ucontext.h */	1.99 KB	2026-02-17 11:01
📄 ulimit.h /* Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _ULIMIT_H #define _ULIMIT_H 1 #include <features.h> / Constants used as the first parameter for `ulimit'. They denote limits which can be set or retrieved using this function. / enum { UL_GETFSIZE = 1, / Return limit on the size of a file, in units of 512 bytes. / #define UL_GETFSIZE UL_GETFSIZE UL_SETFSIZE, / Set limit on the size of a file to second argument. / #define UL_SETFSIZE UL_SETFSIZE __UL_GETMAXBRK, / Return the maximum possible address of the data segment. / __UL_GETOPENMAX / Return the maximum number of files that the calling process can open./ }; __BEGIN_DECLS / Control process limits according to CMD. / extern long int ulimit (int __cmd, ...) __THROW; __END_DECLS #endif / ulimit.h */	1.55 KB	2026-02-17 11:01
📄 unistd.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * POSIX Standard: 2.10 Symbolic Constants <unistd.h> / #ifndef _UNISTD_H #define _UNISTD_H 1 #include <features.h> __BEGIN_DECLS / These may be used to determine what facilities are present at compile time. Their values can be obtained at run time from `sysconf'. / #ifdef __USE_XOPEN2K8 / POSIX Standard approved as ISO/IEC 9945-1 as of September 2008. / # define _POSIX_VERSION 200809L #elif defined __USE_XOPEN2K / POSIX Standard approved as ISO/IEC 9945-1 as of December 2001. / # define _POSIX_VERSION 200112L #elif defined __USE_POSIX199506 / POSIX Standard approved as ISO/IEC 9945-1 as of June 1995. / # define _POSIX_VERSION 199506L #elif defined __USE_POSIX199309 / POSIX Standard approved as ISO/IEC 9945-1 as of September 1993. / # define _POSIX_VERSION 199309L #else / POSIX Standard approved as ISO/IEC 9945-1 as of September 1990. / # define _POSIX_VERSION 199009L #endif / These are not #ifdef __USE_POSIX2 because they are in the theoretically application-owned namespace. / #ifdef __USE_XOPEN2K8 # define __POSIX2_THIS_VERSION 200809L / The utilities on GNU systems also correspond to this version. / #elif defined __USE_XOPEN2K / The utilities on GNU systems also correspond to this version. / # define __POSIX2_THIS_VERSION 200112L #elif defined __USE_POSIX199506 / The utilities on GNU systems also correspond to this version. / # define __POSIX2_THIS_VERSION 199506L #else / The utilities on GNU systems also correspond to this version. / # define __POSIX2_THIS_VERSION 199209L #endif / The utilities on GNU systems also correspond to this version. / #define _POSIX2_VERSION __POSIX2_THIS_VERSION / This symbol was required until the 2001 edition of POSIX. / #define _POSIX2_C_VERSION __POSIX2_THIS_VERSION / If defined, the implementation supports the C Language Bindings Option. / #define _POSIX2_C_BIND __POSIX2_THIS_VERSION / If defined, the implementation supports the C Language Development Utilities Option. / #define _POSIX2_C_DEV __POSIX2_THIS_VERSION / If defined, the implementation supports the Software Development Utilities Option. / #define _POSIX2_SW_DEV __POSIX2_THIS_VERSION / If defined, the implementation supports the creation of locales with the localedef utility. / #define _POSIX2_LOCALEDEF __POSIX2_THIS_VERSION / X/Open version number to which the library conforms. It is selectable. / #ifdef __USE_XOPEN2K8 # define _XOPEN_VERSION 700 #elif defined __USE_XOPEN2K # define _XOPEN_VERSION 600 #elif defined __USE_UNIX98 # define _XOPEN_VERSION 500 #else # define _XOPEN_VERSION 4 #endif / Commands and utilities from XPG4 are available. / #define _XOPEN_XCU_VERSION 4 / We are compatible with the old published standards as well. / #define _XOPEN_XPG2 1 #define _XOPEN_XPG3 1 #define _XOPEN_XPG4 1 / The X/Open Unix extensions are available. / #define _XOPEN_UNIX 1 / The enhanced internationalization capabilities according to XPG4.2 are present. / #define _XOPEN_ENH_I18N 1 / The legacy interfaces are also available. / #define _XOPEN_LEGACY 1 / Get values of POSIX options: If these symbols are defined, the corresponding features are always available. If not, they may be available sometimes. The current values can be obtained with `sysconf'. _POSIX_JOB_CONTROL Job control is supported. _POSIX_SAVED_IDS Processes have a saved set-user-ID and a saved set-group-ID. _POSIX_REALTIME_SIGNALS Real-time, queued signals are supported. _POSIX_PRIORITY_SCHEDULING Priority scheduling is supported. _POSIX_TIMERS POSIX.4 clocks and timers are supported. _POSIX_ASYNCHRONOUS_IO Asynchronous I/O is supported. _POSIX_PRIORITIZED_IO Prioritized asynchronous I/O is supported. _POSIX_SYNCHRONIZED_IO Synchronizing file data is supported. _POSIX_FSYNC The fsync function is present. _POSIX_MAPPED_FILES Mapping of files to memory is supported. _POSIX_MEMLOCK Locking of all memory is supported. _POSIX_MEMLOCK_RANGE Locking of ranges of memory is supported. _POSIX_MEMORY_PROTECTION Setting of memory protections is supported. _POSIX_MESSAGE_PASSING POSIX.4 message queues are supported. _POSIX_SEMAPHORES POSIX.4 counting semaphores are supported. _POSIX_SHARED_MEMORY_OBJECTS POSIX.4 shared memory objects are supported. _POSIX_THREADS POSIX.1c pthreads are supported. _POSIX_THREAD_ATTR_STACKADDR Thread stack address attribute option supported. _POSIX_THREAD_ATTR_STACKSIZE Thread stack size attribute option supported. _POSIX_THREAD_SAFE_FUNCTIONS Thread-safe functions are supported. _POSIX_THREAD_PRIORITY_SCHEDULING POSIX.1c thread execution scheduling supported. _POSIX_THREAD_PRIO_INHERIT Thread priority inheritance option supported. _POSIX_THREAD_PRIO_PROTECT Thread priority protection option supported. _POSIX_THREAD_PROCESS_SHARED Process-shared synchronization supported. _POSIX_PII Protocol-independent interfaces are supported. _POSIX_PII_XTI XTI protocol-indep. interfaces are supported. _POSIX_PII_SOCKET Socket protocol-indep. interfaces are supported. _POSIX_PII_INTERNET Internet family of protocols supported. _POSIX_PII_INTERNET_STREAM Connection-mode Internet protocol supported. _POSIX_PII_INTERNET_DGRAM Connectionless Internet protocol supported. _POSIX_PII_OSI ISO/OSI family of protocols supported. _POSIX_PII_OSI_COTS Connection-mode ISO/OSI service supported. _POSIX_PII_OSI_CLTS Connectionless ISO/OSI service supported. _POSIX_POLL Implementation supports `poll' function. _POSIX_SELECT Implementation supports `select' and `pselect'. _XOPEN_REALTIME X/Open realtime support is available. _XOPEN_REALTIME_THREADS X/Open realtime thread support is available. _XOPEN_SHM Shared memory interface according to XPG4.2. _XBS5_ILP32_OFF32 Implementation provides environment with 32-bit int, long, pointer, and off_t types. _XBS5_ILP32_OFFBIG Implementation provides environment with 32-bit int, long, and pointer and off_t with at least 64 bits. _XBS5_LP64_OFF64 Implementation provides environment with 32-bit int, and 64-bit long, pointer, and off_t types. _XBS5_LPBIG_OFFBIG Implementation provides environment with at least 32 bits int and long, pointer, and off_t with at least 64 bits. If any of these symbols is defined as -1, the corresponding option is not true for any file. If any is defined as other than -1, the corresponding option is true for all files. If a symbol is not defined at all, the value for a specific file can be obtained from `pathconf' and `fpathconf'. _POSIX_CHOWN_RESTRICTED Only the super user can use `chown' to change the owner of a file. `chown' can only be used to change the group ID of a file to a group of which the calling process is a member. _POSIX_NO_TRUNC Pathname components longer than NAME_MAX generate an error. _POSIX_VDISABLE If defined, if the value of an element of the `c_cc' member of `struct termios' is _POSIX_VDISABLE, no character will have the effect associated with that element. _POSIX_SYNC_IO Synchronous I/O may be performed. _POSIX_ASYNC_IO Asynchronous I/O may be performed. _POSIX_PRIO_IO Prioritized Asynchronous I/O may be performed. Support for the Large File Support interface is not generally available. If it is available the following constants are defined to one. _LFS64_LARGEFILE Low-level I/O supports large files. _LFS64_STDIO Standard I/O supports large files. / #include <bits/posix_opt.h> / Get the environment definitions from Unix98. / #if defined __USE_UNIX98 \|\| defined __USE_XOPEN2K # include <bits/environments.h> #endif / Standard file descriptors. / #define STDIN_FILENO 0 / Standard input. / #define STDOUT_FILENO 1 / Standard output. / #define STDERR_FILENO 2 / Standard error output. / / All functions that are not declared anywhere else. / #include <bits/types.h> #ifndef __ssize_t_defined typedef __ssize_t ssize_t; # define __ssize_t_defined #endif #define __need_size_t #define __need_NULL #include <stddef.h> #if defined __USE_XOPEN \|\| defined __USE_XOPEN2K / The Single Unix specification says that some more types are available here. / # ifndef __gid_t_defined typedef __gid_t gid_t; # define __gid_t_defined # endif # ifndef __uid_t_defined typedef __uid_t uid_t; # define __uid_t_defined # endif # ifndef __off_t_defined # ifndef __USE_FILE_OFFSET64 typedef __off_t off_t; # else typedef __off64_t off_t; # endif # define __off_t_defined # endif # if defined __USE_LARGEFILE64 && !defined __off64_t_defined typedef __off64_t off64_t; # define __off64_t_defined # endif # ifndef __useconds_t_defined typedef __useconds_t useconds_t; # define __useconds_t_defined # endif # ifndef __pid_t_defined typedef __pid_t pid_t; # define __pid_t_defined # endif #endif / X/Open / #if defined __USE_XOPEN_EXTENDED \|\| defined __USE_XOPEN2K # ifndef __intptr_t_defined typedef __intptr_t intptr_t; # define __intptr_t_defined # endif #endif #if defined __USE_MISC \|\| defined __USE_XOPEN # ifndef __socklen_t_defined typedef __socklen_t socklen_t; # define __socklen_t_defined # endif #endif / Values for the second argument to access. These may be OR'd together. / #define R_OK 4 / Test for read permission. / #define W_OK 2 / Test for write permission. / #define X_OK 1 / Test for execute permission. / #define F_OK 0 / Test for existence. / / Test for access to NAME using the real UID and real GID. / extern int access (const char __name, int __type) __THROW __nonnull ((1)); #ifdef __USE_GNU /* Test for access to NAME using the effective UID and GID (as normal file operations use). / extern int euidaccess (const char __name, int __type) __THROW __nonnull ((1)); /* An alias for `euidaccess', used by some other systems. / extern int eaccess (const char __name, int __type) __THROW __nonnull ((1)); /* Execute program relative to a directory file descriptor. / extern int execveat (int __fd, const char __path, char const __argv[], char const __envp[], int __flags) __THROW __nonnull ((2, 3)); #endif #ifdef __USE_ATFILE /* Test for access to FILE relative to the directory FD is open on. If AT_EACCESS is set in FLAG, then use effective IDs like `eaccess', otherwise use real IDs like `access'. / extern int faccessat (int __fd, const char __file, int __type, int __flag) __THROW __nonnull ((2)) __wur; #endif /* Use GNU. / / Values for the WHENCE argument to lseek. / #ifndef _STDIO_H / <stdio.h> has the same definitions. / # define SEEK_SET 0 / Seek from beginning of file. / # define SEEK_CUR 1 / Seek from current position. / # define SEEK_END 2 / Seek from end of file. / # ifdef __USE_GNU # define SEEK_DATA 3 / Seek to next data. / # define SEEK_HOLE 4 / Seek to next hole. / # endif #endif #if defined __USE_MISC && !defined L_SET / Old BSD names for the same constants; just for compatibility. / # define L_SET SEEK_SET # define L_INCR SEEK_CUR # define L_XTND SEEK_END #endif / Move FD's file position to OFFSET bytes from the beginning of the file (if WHENCE is SEEK_SET), the current position (if WHENCE is SEEK_CUR), or the end of the file (if WHENCE is SEEK_END). Return the new file position. / #ifndef __USE_FILE_OFFSET64 extern __off_t lseek (int __fd, __off_t __offset, int __whence) __THROW; #else # ifdef __REDIRECT_NTH extern __off64_t __REDIRECT_NTH (lseek, (int __fd, __off64_t __offset, int __whence), lseek64); # else # define lseek lseek64 # endif #endif #ifdef __USE_LARGEFILE64 extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence) __THROW; #endif / Close the file descriptor FD. This function is a cancellation point and therefore not marked with __THROW. / extern int close (int __fd); #ifdef __USE_MISC / Close all open file descriptors greater than or equal to LOWFD. Negative LOWFD is clamped to 0. / extern void closefrom (int __lowfd) __THROW; #endif / Read NBYTES into BUF from FD. Return the number read, -1 for errors or 0 for EOF. This function is a cancellation point and therefore not marked with __THROW. / extern ssize_t read (int __fd, void __buf, size_t __nbytes) __wur __fortified_attr_access (__write_only__, 2, 3); /* Write N bytes of BUF to FD. Return the number written, or -1. This function is a cancellation point and therefore not marked with __THROW. / extern ssize_t write (int __fd, const void __buf, size_t __n) __wur __attr_access ((__read_only__, 2, 3)); #if defined __USE_UNIX98 \|\| defined __USE_XOPEN2K8 # ifndef __USE_FILE_OFFSET64 /* Read NBYTES into BUF from FD at the given position OFFSET without changing the file pointer. Return the number read, -1 for errors or 0 for EOF. This function is a cancellation point and therefore not marked with __THROW. / extern ssize_t pread (int __fd, void __buf, size_t __nbytes, __off_t __offset) __wur __fortified_attr_access (__write_only__, 2, 3); /* Write N bytes of BUF to FD at the given position OFFSET without changing the file pointer. Return the number written, or -1. This function is a cancellation point and therefore not marked with __THROW. / extern ssize_t pwrite (int __fd, const void __buf, size_t __n, __off_t __offset) __wur __attr_access ((__read_only__, 2, 3)); # else # ifdef __REDIRECT extern ssize_t __REDIRECT (pread, (int __fd, void __buf, size_t __nbytes, __off64_t __offset), pread64) __wur __fortified_attr_access (__write_only__, 2, 3); extern ssize_t __REDIRECT (pwrite, (int __fd, const void __buf, size_t __nbytes, __off64_t __offset), pwrite64) __wur __attr_access ((__read_only__, 2, 3)); # else # define pread pread64 # define pwrite pwrite64 # endif # endif # ifdef __USE_LARGEFILE64 /* Read NBYTES into BUF from FD at the given position OFFSET without changing the file pointer. Return the number read, -1 for errors or 0 for EOF. / extern ssize_t pread64 (int __fd, void __buf, size_t __nbytes, __off64_t __offset) __wur __fortified_attr_access (__write_only__, 2, 3); /* Write N bytes of BUF to FD at the given position OFFSET without changing the file pointer. Return the number written, or -1. / extern ssize_t pwrite64 (int __fd, const void __buf, size_t __n, __off64_t __offset) __wur __attr_access ((__read_only__, 2, 3)); # endif #endif /* Create a one-way communication channel (pipe). If successful, two file descriptors are stored in PIPEDES; bytes written on PIPEDES[1] can be read from PIPEDES[0]. Returns 0 if successful, -1 if not. / extern int pipe (int __pipedes[2]) __THROW __wur; #ifdef __USE_GNU / Same as pipe but apply flags passed in FLAGS to the new file descriptors. / extern int pipe2 (int __pipedes[2], int __flags) __THROW __wur; #endif / Schedule an alarm. In SECONDS seconds, the process will get a SIGALRM. If SECONDS is zero, any currently scheduled alarm will be cancelled. The function returns the number of seconds remaining until the last alarm scheduled would have signaled, or zero if there wasn't one. There is no return value to indicate an error, but you can set `errno' to 0 and check its value after calling `alarm', and this might tell you. The signal may come late due to processor scheduling. / extern unsigned int alarm (unsigned int __seconds) __THROW; / Make the process sleep for SECONDS seconds, or until a signal arrives and is not ignored. The function returns the number of seconds less than SECONDS which it actually slept (thus zero if it slept the full time). If a signal handler does a `longjmp' or modifies the handling of the SIGALRM signal while inside `sleep' call, the handling of the SIGALRM signal afterwards is undefined. There is no return value to indicate error, but if `sleep' returns SECONDS, it probably didn't work. This function is a cancellation point and therefore not marked with __THROW. / extern unsigned int sleep (unsigned int __seconds); #if (defined __USE_XOPEN_EXTENDED && !defined __USE_XOPEN2K8) \ \|\| defined __USE_MISC / Set an alarm to go off (generating a SIGALRM signal) in VALUE microseconds. If INTERVAL is nonzero, when the alarm goes off, the timer is reset to go off every INTERVAL microseconds thereafter. Returns the number of microseconds remaining before the alarm. / extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval) __THROW; / Sleep USECONDS microseconds, or until a signal arrives that is not blocked or ignored. This function is a cancellation point and therefore not marked with __THROW. / extern int usleep (__useconds_t __useconds); #endif / Suspend the process until a signal arrives. This always returns -1 and sets `errno' to EINTR. This function is a cancellation point and therefore not marked with __THROW. / extern int pause (void); / Change the owner and group of FILE. / extern int chown (const char __file, __uid_t __owner, __gid_t __group) __THROW __nonnull ((1)) __wur; #if defined __USE_XOPEN_EXTENDED \|\| defined __USE_XOPEN2K8 /* Change the owner and group of the file that FD is open on. / extern int fchown (int __fd, __uid_t __owner, __gid_t __group) __THROW __wur; / Change owner and group of FILE, if it is a symbolic link the ownership of the symbolic link is changed. / extern int lchown (const char __file, __uid_t __owner, __gid_t __group) __THROW __nonnull ((1)) __wur; #endif /* Use X/Open Unix. / #ifdef __USE_ATFILE / Change the owner and group of FILE relative to the directory FD is open on. / extern int fchownat (int __fd, const char __file, __uid_t __owner, __gid_t __group, int __flag) __THROW __nonnull ((2)) __wur; #endif /* Use GNU. / / Change the process's working directory to PATH. / extern int chdir (const char __path) __THROW __nonnull ((1)) __wur; #if defined __USE_XOPEN_EXTENDED \|\| defined __USE_XOPEN2K8 /* Change the process's working directory to the one FD is open on. / extern int fchdir (int __fd) __THROW __wur; #endif / Get the pathname of the current working directory, and put it in SIZE bytes of BUF. Returns NULL if the directory couldn't be determined or SIZE was too small. If successful, returns BUF. In GNU, if BUF is NULL, an array is allocated with `malloc'; the array is SIZE bytes long, unless SIZE == 0, in which case it is as big as necessary. / extern char getcwd (char __buf, size_t __size) __THROW __wur; #ifdef __USE_GNU / Return a malloc'd string containing the current directory name. If the environment variable `PWD' is set, and its value is correct, that value is used. / extern char get_current_dir_name (void) __THROW; #endif #if (defined __USE_XOPEN_EXTENDED && !defined __USE_XOPEN2K8) \ \|\| defined __USE_MISC /* Put the absolute pathname of the current working directory in BUF. If successful, return BUF. If not, put an error message in BUF and return NULL. BUF should be at least PATH_MAX bytes long. / extern char getwd (char __buf) __THROW __nonnull ((1)) __attribute_deprecated__ __wur __attr_access ((__write_only__, 1)); #endif / Duplicate FD, returning a new file descriptor on the same file. / extern int dup (int __fd) __THROW __wur; / Duplicate FD to FD2, closing FD2 and making it open on the same file. / extern int dup2 (int __fd, int __fd2) __THROW; #ifdef __USE_GNU / Duplicate FD to FD2, closing FD2 and making it open on the same file while setting flags according to FLAGS. / extern int dup3 (int __fd, int __fd2, int __flags) __THROW; #endif / NULL-terminated array of "NAME=VALUE" environment variables. / extern char __environ; #ifdef __USE_GNU extern char environ; #endif / Replace the current process, executing PATH with arguments ARGV and environment ENVP. ARGV and ENVP are terminated by NULL pointers. / extern int execve (const char __path, char const __argv[], char const __envp[]) __THROW __nonnull ((1, 2)); #ifdef __USE_XOPEN2K8 /* Execute the file FD refers to, overlaying the running program image. ARGV and ENVP are passed to the new program, as for `execve'. / extern int fexecve (int __fd, char const __argv[], char const __envp[]) __THROW __nonnull ((2)); #endif / Execute PATH with arguments ARGV and environment from `environ'. / extern int execv (const char __path, char const __argv[]) __THROW __nonnull ((1, 2)); / Execute PATH with all arguments after PATH until a NULL pointer, and the argument after that for environment. / extern int execle (const char __path, const char __arg, ...) __THROW __nonnull ((1, 2)); / Execute PATH with all arguments after PATH until a NULL pointer and environment from `environ'. / extern int execl (const char __path, const char __arg, ...) __THROW __nonnull ((1, 2)); / Execute FILE, searching in the `PATH' environment variable if it contains no slashes, with arguments ARGV and environment from `environ'. / extern int execvp (const char __file, char const __argv[]) __THROW __nonnull ((1, 2)); / Execute FILE, searching in the `PATH' environment variable if it contains no slashes, with all arguments after FILE until a NULL pointer and environment from `environ'. / extern int execlp (const char __file, const char __arg, ...) __THROW __nonnull ((1, 2)); #ifdef __USE_GNU / Execute FILE, searching in the `PATH' environment variable if it contains no slashes, with arguments ARGV and environment from `environ'. / extern int execvpe (const char __file, char const __argv[], char const __envp[]) __THROW __nonnull ((1, 2)); #endif #if defined __USE_MISC \|\| defined __USE_XOPEN /* Add INC to priority of the current process. / extern int nice (int __inc) __THROW __wur; #endif / Terminate program execution with the low-order 8 bits of STATUS. / extern void _exit (int __status) __attribute__ ((__noreturn__)); / Get the `_PC_' symbols for the NAME argument to `pathconf' and `fpathconf'; the `_SC_' symbols for the NAME argument to `sysconf'; and the `_CS_' symbols for the NAME argument to `confstr'. / #include <bits/confname.h> /* Get file-specific configuration information about PATH. / extern long int pathconf (const char __path, int __name) __THROW __nonnull ((1)); /* Get file-specific configuration about descriptor FD. / extern long int fpathconf (int __fd, int __name) __THROW; / Get the value of the system variable NAME. / extern long int sysconf (int __name) __THROW; #ifdef __USE_POSIX2 / Get the value of the string-valued system variable NAME. / extern size_t confstr (int __name, char __buf, size_t __len) __THROW __fortified_attr_access (__write_only__, 2, 3); #endif /* Get the process ID of the calling process. / extern __pid_t getpid (void) __THROW; / Get the process ID of the calling process's parent. / extern __pid_t getppid (void) __THROW; / Get the process group ID of the calling process. / extern __pid_t getpgrp (void) __THROW; / Get the process group ID of process PID. / extern __pid_t __getpgid (__pid_t __pid) __THROW; #if defined __USE_XOPEN_EXTENDED \|\| defined __USE_XOPEN2K8 extern __pid_t getpgid (__pid_t __pid) __THROW; #endif / Set the process group ID of the process matching PID to PGID. If PID is zero, the current process's process group ID is set. If PGID is zero, the process ID of the process is used. / extern int setpgid (__pid_t __pid, __pid_t __pgid) __THROW; #if defined __USE_MISC \|\| defined __USE_XOPEN_EXTENDED / Both System V and BSD have `setpgrp' functions, but with different calling conventions. The BSD function is the same as POSIX.1 `setpgid' (above). The System V function takes no arguments and puts the calling process in its on group like `setpgid (0, 0)'. New programs should always use `setpgid' instead. GNU provides the POSIX.1 function. / / Set the process group ID of the calling process to its own PID. This is exactly the same as `setpgid (0, 0)'. / extern int setpgrp (void) __THROW; #endif / Use misc or X/Open. / / Create a new session with the calling process as its leader. The process group IDs of the session and the calling process are set to the process ID of the calling process, which is returned. / extern __pid_t setsid (void) __THROW; #if defined __USE_XOPEN_EXTENDED \|\| defined __USE_XOPEN2K8 / Return the session ID of the given process. / extern __pid_t getsid (__pid_t __pid) __THROW; #endif / Get the real user ID of the calling process. / extern __uid_t getuid (void) __THROW; / Get the effective user ID of the calling process. / extern __uid_t geteuid (void) __THROW; / Get the real group ID of the calling process. / extern __gid_t getgid (void) __THROW; / Get the effective group ID of the calling process. / extern __gid_t getegid (void) __THROW; / If SIZE is zero, return the number of supplementary groups the calling process is in. Otherwise, fill in the group IDs of its supplementary groups in LIST and return the number written. / extern int getgroups (int __size, __gid_t __list[]) __THROW __wur __fortified_attr_access (__write_only__, 2, 1); #ifdef __USE_GNU / Return nonzero iff the calling process is in group GID. / extern int group_member (__gid_t __gid) __THROW; #endif / Set the user ID of the calling process to UID. If the calling process is the super-user, set the real and effective user IDs, and the saved set-user-ID to UID; if not, the effective user ID is set to UID. / extern int setuid (__uid_t __uid) __THROW __wur; #if defined __USE_MISC \|\| defined __USE_XOPEN_EXTENDED / Set the real user ID of the calling process to RUID, and the effective user ID of the calling process to EUID. / extern int setreuid (__uid_t __ruid, __uid_t __euid) __THROW __wur; #endif #ifdef __USE_XOPEN2K / Set the effective user ID of the calling process to UID. / extern int seteuid (__uid_t __uid) __THROW __wur; #endif / Use POSIX.1-2001. / / Set the group ID of the calling process to GID. If the calling process is the super-user, set the real and effective group IDs, and the saved set-group-ID to GID; if not, the effective group ID is set to GID. / extern int setgid (__gid_t __gid) __THROW __wur; #if defined __USE_MISC \|\| defined __USE_XOPEN_EXTENDED / Set the real group ID of the calling process to RGID, and the effective group ID of the calling process to EGID. / extern int setregid (__gid_t __rgid, __gid_t __egid) __THROW __wur; #endif #ifdef __USE_XOPEN2K / Set the effective group ID of the calling process to GID. / extern int setegid (__gid_t __gid) __THROW __wur; #endif / Use POSIX.1-2001. / #ifdef __USE_GNU / Fetch the real user ID, effective user ID, and saved-set user ID, of the calling process. / extern int getresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid) __THROW; /* Fetch the real group ID, effective group ID, and saved-set group ID, of the calling process. / extern int getresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid) __THROW; /* Set the real user ID, effective user ID, and saved-set user ID, of the calling process to RUID, EUID, and SUID, respectively. / extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid) __THROW __wur; / Set the real group ID, effective group ID, and saved-set group ID, of the calling process to RGID, EGID, and SGID, respectively. / extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid) __THROW __wur; #endif / Clone the calling process, creating an exact copy. Return -1 for errors, 0 to the new process, and the process ID of the new process to the old process. / extern __pid_t fork (void) __THROWNL; #if (defined __USE_XOPEN_EXTENDED && !defined __USE_XOPEN2K8) \ \|\| defined __USE_MISC / Clone the calling process, but without copying the whole address space. The calling process is suspended until the new process exits or is replaced by a call to `execve'. Return -1 for errors, 0 to the new process, and the process ID of the new process to the old process. / extern __pid_t vfork (void) __THROW; #endif / Use misc or XPG < 7. / #ifdef __USE_GNU / This is similar to fork, however it does not run the atfork handlers neither reinitialize any internal locks in multithread case. Different than fork, _Fork is async-signal-safe. / extern __pid_t _Fork (void) __THROW; #endif / Return the pathname of the terminal FD is open on, or NULL on errors. The returned storage is good only until the next call to this function. / extern char ttyname (int __fd) __THROW; /* Store at most BUFLEN characters of the pathname of the terminal FD is open on in BUF. Return 0 on success, otherwise an error number. / extern int ttyname_r (int __fd, char __buf, size_t __buflen) __THROW __nonnull ((2)) __wur __fortified_attr_access (__write_only__, 2, 3); /* Return 1 if FD is a valid descriptor associated with a terminal, zero if not. / extern int isatty (int __fd) __THROW; #ifdef __USE_MISC / Return the index into the active-logins file (utmp) for the controlling terminal. / extern int ttyslot (void) __THROW; #endif / Make a link to FROM named TO. / extern int link (const char __from, const char __to) __THROW __nonnull ((1, 2)) __wur; #ifdef __USE_ATFILE / Like link but relative paths in TO and FROM are interpreted relative to FROMFD and TOFD respectively. / extern int linkat (int __fromfd, const char __from, int __tofd, const char __to, int __flags) __THROW __nonnull ((2, 4)) __wur; #endif #if defined __USE_XOPEN_EXTENDED \|\| defined __USE_XOPEN2K / Make a symbolic link to FROM named TO. / extern int symlink (const char __from, const char __to) __THROW __nonnull ((1, 2)) __wur; / Read the contents of the symbolic link PATH into no more than LEN bytes of BUF. The contents are not null-terminated. Returns the number of characters read, or -1 for errors. / extern ssize_t readlink (const char __restrict __path, char __restrict __buf, size_t __len) __THROW __nonnull ((1, 2)) __wur __fortified_attr_access (__write_only__, 2, 3); #endif / Use POSIX.1-2001. / #ifdef __USE_ATFILE / Like symlink but a relative path in TO is interpreted relative to TOFD. / extern int symlinkat (const char __from, int __tofd, const char __to) __THROW __nonnull ((1, 3)) __wur; / Like readlink but a relative PATH is interpreted relative to FD. / extern ssize_t readlinkat (int __fd, const char __restrict __path, char __restrict __buf, size_t __len) __THROW __nonnull ((2, 3)) __wur __fortified_attr_access (__write_only__, 3, 4); #endif / Remove the link NAME. / extern int unlink (const char __name) __THROW __nonnull ((1)); #ifdef __USE_ATFILE /* Remove the link NAME relative to FD. / extern int unlinkat (int __fd, const char __name, int __flag) __THROW __nonnull ((2)); #endif /* Remove the directory PATH. / extern int rmdir (const char __path) __THROW __nonnull ((1)); /* Return the foreground process group ID of FD. / extern __pid_t tcgetpgrp (int __fd) __THROW; / Set the foreground process group ID of FD set PGRP_ID. / extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) __THROW; / Return the login name of the user. This function is a possible cancellation point and therefore not marked with __THROW. / extern char getlogin (void); #ifdef __USE_POSIX199506 /* Return at most NAME_LEN characters of the login name of the user in NAME. If it cannot be determined or some other error occurred, return the error code. Otherwise return 0. This function is a possible cancellation point and therefore not marked with __THROW. / extern int getlogin_r (char __name, size_t __name_len) __nonnull ((1)) __fortified_attr_access (__write_only__, 1, 2); #endif #ifdef __USE_MISC /* Set the login name returned by `getlogin'. / extern int setlogin (const char __name) __THROW __nonnull ((1)); #endif #ifdef __USE_POSIX2 /* Get definitions and prototypes for functions to process the arguments in ARGV (ARGC of them, minus the program name) for options given in OPTS. / # include <bits/getopt_posix.h> #endif #if defined __USE_XOPEN_EXTENDED \|\| defined __USE_XOPEN2K / Put the name of the current host in no more than LEN bytes of NAME. The result is null-terminated if LEN is large enough for the full name and the terminator. / extern int gethostname (char __name, size_t __len) __THROW __nonnull ((1)) __fortified_attr_access (__write_only__, 1, 2); #endif #if defined __USE_MISC /* Set the name of the current host to NAME, which is LEN bytes long. This call is restricted to the super-user. / extern int sethostname (const char __name, size_t __len) __THROW __nonnull ((1)) __wur __attr_access ((__read_only__, 1, 2)); /* Set the current machine's Internet number to ID. This call is restricted to the super-user. / extern int sethostid (long int __id) __THROW __wur; / Get and set the NIS (aka YP) domain name, if any. Called just like `gethostname' and `sethostname'. The NIS domain name is usually the empty string when not using NIS. / extern int getdomainname (char __name, size_t __len) __THROW __nonnull ((1)) __wur __fortified_attr_access (__write_only__, 1, 2); extern int setdomainname (const char __name, size_t __len) __THROW __nonnull ((1)) __wur __attr_access ((__read_only__, 1, 2)); / Revoke access permissions to all processes currently communicating with the control terminal, and then send a SIGHUP signal to the process group of the control terminal. / extern int vhangup (void) __THROW; / Revoke the access of all descriptors currently open on FILE. / extern int revoke (const char __file) __THROW __nonnull ((1)) __wur; /* Enable statistical profiling, writing samples of the PC into at most SIZE bytes of SAMPLE_BUFFER; every processor clock tick while profiling is enabled, the system examines the user PC and increments SAMPLE_BUFFER[((PC - OFFSET) / 2) * SCALE / 65536]. If SCALE is zero, disable profiling. Returns zero on success, -1 on error. / extern int profil (unsigned short int __sample_buffer, size_t __size, size_t __offset, unsigned int __scale) __THROW __nonnull ((1)); /* Turn accounting on if NAME is an existing file. The system will then write a record for each process as it terminates, to this file. If NAME is NULL, turn accounting off. This call is restricted to the super-user. / extern int acct (const char __name) __THROW; /* Successive calls return the shells listed in `/etc/shells'. / extern char getusershell (void) __THROW; extern void endusershell (void) __THROW; /* Discard cached info. / extern void setusershell (void) __THROW; / Rewind and re-read the file. / / Put the program in the background, and dissociate from the controlling terminal. If NOCHDIR is zero, do `chdir ("/")'. If NOCLOSE is zero, redirects stdin, stdout, and stderr to /dev/null. / extern int daemon (int __nochdir, int __noclose) __THROW __wur; #endif / Use misc. / #if defined __USE_MISC \|\| (defined __USE_XOPEN && !defined __USE_XOPEN2K) / Make PATH be the root directory (the starting point for absolute paths). This call is restricted to the super-user. / extern int chroot (const char __path) __THROW __nonnull ((1)) __wur; /* Prompt with PROMPT and read a string from the terminal without echoing. Uses /dev/tty if possible; otherwise stderr and stdin. / extern char getpass (const char __prompt) __nonnull ((1)); #endif / Use misc \|\| X/Open. / / Make all changes done to FD actually appear on disk. This function is a cancellation point and therefore not marked with __THROW. / extern int fsync (int __fd); #ifdef __USE_GNU / Make all changes done to all files on the file system associated with FD actually appear on disk. / extern int syncfs (int __fd) __THROW; #endif #if defined __USE_MISC \|\| defined __USE_XOPEN_EXTENDED / Return identifier for the current host. / extern long int gethostid (void); / Make all changes done to all files actually appear on disk. / extern void sync (void) __THROW; # if defined __USE_MISC \|\| !defined __USE_XOPEN2K / Return the number of bytes in a page. This is the system's page size, which is not necessarily the same as the hardware page size. / extern int getpagesize (void) __THROW __attribute__ ((__const__)); / Return the maximum number of file descriptors the current process could possibly have. / extern int getdtablesize (void) __THROW; # endif #endif / Use misc \|\| X/Open Unix. / #if defined __USE_XOPEN_EXTENDED \|\| defined __USE_XOPEN2K8 / Truncate FILE to LENGTH bytes. / # ifndef __USE_FILE_OFFSET64 extern int truncate (const char __file, __off_t __length) __THROW __nonnull ((1)) __wur; # else # ifdef __REDIRECT_NTH extern int __REDIRECT_NTH (truncate, (const char __file, __off64_t __length), truncate64) __nonnull ((1)) __wur; # else # define truncate truncate64 # endif # endif # ifdef __USE_LARGEFILE64 extern int truncate64 (const char __file, __off64_t __length) __THROW __nonnull ((1)) __wur; # endif #endif /* Use X/Open Unix \|\| POSIX 2008. / #if defined __USE_POSIX199309 \ \|\| defined __USE_XOPEN_EXTENDED \|\| defined __USE_XOPEN2K / Truncate the file FD is open on to LENGTH bytes. / # ifndef __USE_FILE_OFFSET64 extern int ftruncate (int __fd, __off_t __length) __THROW __wur; # else # ifdef __REDIRECT_NTH extern int __REDIRECT_NTH (ftruncate, (int __fd, __off64_t __length), ftruncate64) __wur; # else # define ftruncate ftruncate64 # endif # endif # ifdef __USE_LARGEFILE64 extern int ftruncate64 (int __fd, __off64_t __length) __THROW __wur; # endif #endif / Use POSIX.1b \|\| X/Open Unix \|\| XPG6. / #if (defined __USE_XOPEN_EXTENDED && !defined __USE_XOPEN2K) \ \|\| defined __USE_MISC / Set the end of accessible data space (aka "the break") to ADDR. Returns zero on success and -1 for errors (with errno set). / extern int brk (void __addr) __THROW __wur; /* Increase or decrease the end of accessible data space by DELTA bytes. If successful, returns the address the previous end of data space (i.e. the beginning of the new space, if DELTA > 0); returns (void ) -1 for errors (with errno set). / extern void sbrk (intptr_t __delta) __THROW; #endif #ifdef __USE_MISC / Invoke `system call' number SYSNO, passing it the remaining arguments. This is completely system-dependent, and not often useful. In Unix, `syscall' sets `errno' for all errors and most calls return -1 for errors; in many systems you cannot pass arguments or get return values for all system calls (`pipe', `fork', and `getppid' typically among them). In Mach, all system calls take normal arguments and always return an error code (zero for success). / extern long int syscall (long int __sysno, ...) __THROW; #endif / Use misc. / #if (defined __USE_MISC \|\| defined __USE_XOPEN_EXTENDED) && !defined F_LOCK / NOTE: These declarations also appear in <fcntl.h>; be sure to keep both files consistent. Some systems have them there and some here, and some software depends on the macros being defined without including both. / / `lockf' is a simpler interface to the locking facilities of `fcntl'. LEN is always relative to the current file position. The CMD argument is one of the following. This function is a cancellation point and therefore not marked with __THROW. / # define F_ULOCK 0 / Unlock a previously locked region. / # define F_LOCK 1 / Lock a region for exclusive use. / # define F_TLOCK 2 / Test and lock a region for exclusive use. / # define F_TEST 3 / Test a region for other processes locks. / # ifndef __USE_FILE_OFFSET64 extern int lockf (int __fd, int __cmd, __off_t __len) __wur; # else # ifdef __REDIRECT extern int __REDIRECT (lockf, (int __fd, int __cmd, __off64_t __len), lockf64) __wur; # else # define lockf lockf64 # endif # endif # ifdef __USE_LARGEFILE64 extern int lockf64 (int __fd, int __cmd, __off64_t __len) __wur; # endif #endif / Use misc and F_LOCK not already defined. / #ifdef __USE_GNU / Evaluate EXPRESSION, and repeat as long as it returns -1 with `errno' set to EINTR. / # define TEMP_FAILURE_RETRY(expression) \ (__extension__ \ ({ long int __result; \ do __result = (long int) (expression); \ while (__result == -1L && errno == EINTR); \ __result; })) / Copy LENGTH bytes from INFD to OUTFD. / ssize_t copy_file_range (int __infd, __off64_t __pinoff, int __outfd, __off64_t __poutoff, size_t __length, unsigned int __flags); #endif / __USE_GNU / #if defined __USE_POSIX199309 \|\| defined __USE_UNIX98 / Synchronize at least the data part of a file with the underlying media. / extern int fdatasync (int __fildes); #endif / Use POSIX199309 / #ifdef __USE_MISC / One-way hash PHRASE, returning a string suitable for storage in the user database. SALT selects the one-way function to use, and ensures that no two users' hashes are the same, even if they use the same passphrase. The return value points to static storage which will be overwritten by the next call to crypt. / extern char crypt (const char __key, const char __salt) __THROW __nonnull ((1, 2)); #endif #ifdef __USE_XOPEN /* Swab pairs bytes in the first N bytes of the area pointed to by FROM and copy the result to TO. The value of TO must not be in the range [FROM - N + 1, FROM - 1]. If N is odd the first byte in FROM is without partner. / extern void swab (const void __restrict __from, void __restrict __to, ssize_t __n) __THROW __nonnull ((1, 2)) __attr_access ((__read_only__, 1, 3)) __attr_access ((__write_only__, 2, 3)); #endif / Prior to Issue 6, the Single Unix Specification required these prototypes to appear in this header. They are also found in <stdio.h>. / #if defined __USE_XOPEN && !defined __USE_XOPEN2K / Return the name of the controlling terminal. / extern char ctermid (char __s) __THROW; / Return the name of the current user. / extern char cuserid (char __s); #endif / Unix98 requires this function to be declared here. In other standards it is in <pthread.h>. / #if defined __USE_UNIX98 && !defined __USE_XOPEN2K extern int pthread_atfork (void (__prepare) (void), void (__parent) (void), void (__child) (void)) __THROW; #endif #ifdef __USE_MISC /* Write LENGTH bytes of randomness starting at BUFFER. Return 0 on success or -1 on error. / int getentropy (void __buffer, size_t __length) __wur __attr_access ((__write_only__, 1, 2)); #endif /* Define some macros helping to catch buffer overflows. / #if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function # include <bits/unistd.h> #endif / System-specific extensions. / #include <bits/unistd_ext.h> __END_DECLS #endif / unistd.h */	43.45 KB	2026-02-17 11:01
📄 utime.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * POSIX Standard: 5.6.6 Set File Access and Modification Times <utime.h> / #ifndef _UTIME_H #define _UTIME_H 1 #include <features.h> __BEGIN_DECLS #include <bits/types.h> #if defined __USE_XOPEN \|\| defined __USE_XOPEN2K # include <bits/types/time_t.h> #endif / Structure describing file times. / struct utimbuf { #ifdef __USE_TIME_BITS64 __time64_t actime; / Access time. / __time64_t modtime; / Modification time. / #else __time_t actime; / Access time. / __time_t modtime; / Modification time. / #endif }; / Set the access and modification times of FILE to those given in FILE_TIMES. If FILE_TIMES is NULL, set them to the current time. / #ifndef __USE_TIME_BITS64 extern int utime (const char __file, const struct utimbuf __file_times) __THROW __nonnull ((1)); #else # ifdef __REDIRECT_NTH extern int __REDIRECT_NTH (utime, (const char __file, const struct utimbuf __file_times), __utime64); # else # define utime __utime64 # endif #endif __END_DECLS #endif /* utime.h */	1.86 KB	2026-02-17 11:01
📄 utmp.h /* Copyright (C) 1993-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _UTMP_H #define _UTMP_H 1 #include <features.h> #include <sys/types.h> __BEGIN_DECLS / Get system dependent values and data structures. / #include <bits/utmp.h> / Compatibility names for the strings of the canonical file names. / #define UTMP_FILE _PATH_UTMP #define UTMP_FILENAME _PATH_UTMP #define WTMP_FILE _PATH_WTMP #define WTMP_FILENAME _PATH_WTMP / Make FD be the controlling terminal, stdin, stdout, and stderr; then close FD. Returns 0 on success, nonzero on error. / extern int login_tty (int __fd) __THROW; / Write the given entry into utmp and wtmp. / extern void login (const struct utmp __entry) __THROW; /* Write the utmp entry to say the user on UT_LINE has logged out. / extern int logout (const char __ut_line) __THROW; /* Append to wtmp an entry for the current time and the given info. / extern void logwtmp (const char __ut_line, const char __ut_name, const char __ut_host) __THROW; /* Append entry UTMP to the wtmp-like file WTMP_FILE. / extern void updwtmp (const char __wtmp_file, const struct utmp __utmp) __THROW; / Change name of the utmp file to be examined. / extern int utmpname (const char __file) __THROW; /* Read next entry from a utmp-like file. / extern struct utmp getutent (void) __THROW; /* Reset the input stream to the beginning of the file. / extern void setutent (void) __THROW; / Close the current open file. / extern void endutent (void) __THROW; / Search forward from the current point in the utmp file until the next entry with a ut_type matching ID->ut_type. / extern struct utmp getutid (const struct utmp __id) __THROW; / Search forward from the current point in the utmp file until the next entry with a ut_line matching LINE->ut_line. / extern struct utmp getutline (const struct utmp __line) __THROW; / Write out entry pointed to by UTMP_PTR into the utmp file. / extern struct utmp pututline (const struct utmp __utmp_ptr) __THROW; #ifdef __USE_MISC / Reentrant versions of the file for handling utmp files. / extern int getutent_r (struct utmp __buffer, struct utmp *__result) __THROW; extern int getutid_r (const struct utmp __id, struct utmp __buffer, struct utmp __result) __THROW; extern int getutline_r (const struct utmp __line, struct utmp __buffer, struct utmp __result) __THROW; #endif / Use misc. / __END_DECLS #endif / utmp.h */	3.15 KB	2026-02-17 11:02
📄 utmpx.h /* Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _UTMPX_H #define _UTMPX_H 1 #include <features.h> #include <sys/time.h> / Required according to Unix98. / #ifndef __pid_t_defined typedef __pid_t pid_t; # define __pid_t_defined #endif / Get system dependent values and data structures. / #include <bits/utmpx.h> #ifdef __USE_GNU / Compatibility names for the strings of the canonical file names. / # define UTMPX_FILE _PATH_UTMPX # define UTMPX_FILENAME _PATH_UTMPX # define WTMPX_FILE _PATH_WTMPX # define WTMPX_FILENAME _PATH_WTMPX #endif / For the getutmp{,x} functions we need the `struct utmp'. / #ifdef __USE_GNU struct utmp; #endif __BEGIN_DECLS / Open user accounting database. This function is a possible cancellation point and therefore not marked with __THROW. / extern void setutxent (void); / Close user accounting database. This function is a possible cancellation point and therefore not marked with __THROW. / extern void endutxent (void); / Get the next entry from the user accounting database. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct utmpx getutxent (void); /* Get the user accounting database entry corresponding to ID. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct utmpx getutxid (const struct utmpx __id); / Get the user accounting database entry corresponding to LINE. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct utmpx getutxline (const struct utmpx __line); / Write the entry UTMPX into the user accounting database. This function is a possible cancellation point and therefore not marked with __THROW. / extern struct utmpx pututxline (const struct utmpx __utmpx); #ifdef __USE_GNU / Change name of the utmpx file to be examined. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int utmpxname (const char __file); /* Append entry UTMP to the wtmpx-like file WTMPX_FILE. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern void updwtmpx (const char __wtmpx_file, const struct utmpx __utmpx); / Copy the information in UTMPX to UTMP. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern void getutmp (const struct utmpx __utmpx, struct utmp __utmp); / Copy the information in UTMP to UTMPX. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern void getutmpx (const struct utmp __utmp, struct utmpx __utmpx); #endif __END_DECLS #endif / utmpx.h */	4 KB	2026-02-17 11:02
📄 values.h /* Old compatibility names for <limits.h> and <float.h> constants. Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / This interface is obsolete. New programs should use <limits.h> and/or <float.h> instead of <values.h>. / #ifndef _VALUES_H #define _VALUES_H 1 #include <features.h> #include <limits.h> #define _TYPEBITS(type) (sizeof (type) CHAR_BIT) #define CHARBITS _TYPEBITS (char) #define SHORTBITS _TYPEBITS (short int) #define INTBITS _TYPEBITS (int) #define LONGBITS _TYPEBITS (long int) #define PTRBITS _TYPEBITS (char ) #define DOUBLEBITS _TYPEBITS (double) #define FLOATBITS _TYPEBITS (float) #define MINSHORT SHRT_MIN #define MININT INT_MIN #define MINLONG LONG_MIN #define MAXSHORT SHRT_MAX #define MAXINT INT_MAX #define MAXLONG LONG_MAX #define HIBITS MINSHORT #define HIBITL MINLONG #include <float.h> #define MAXDOUBLE DBL_MAX #define MAXFLOAT FLT_MAX #define MINDOUBLE DBL_MIN #define MINFLOAT FLT_MIN #define DMINEXP DBL_MIN_EXP #define FMINEXP FLT_MIN_EXP #define DMAXEXP DBL_MAX_EXP #define FMAXEXP FLT_MAX_EXP #ifdef __USE_MISC / Some systems define this name instead of CHAR_BIT or CHARBITS. / # define BITSPERBYTE CHAR_BIT #endif #endif / values.h */	1.91 KB	2026-02-17 11:01
📄 verto-module.h /* * Copyright 2011 Red Hat, Inc. * * 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. / / THE FOLLOWING ARE FOR IMPLEMENTATION MODULES ONLY / #ifndef VERTO_MODULE_H_ #define VERTO_MODULE_H_ #include <verto.h> #ifndef VERTO_MODULE_TYPES #define VERTO_MODULE_TYPES typedef void verto_mod_ctx; typedef void verto_mod_ev; #endif #define VERTO_MODULE_VERSION 3 #define VERTO_MODULE_TABLE(name) verto_module_table_ ## name #define VERTO_MODULE(name, symb, types) \ static verto_ctx_funcs name ## _funcs = { \ name ## _ctx_new, \ name ## _ctx_default, \ name ## _ctx_free, \ name ## _ctx_run, \ name ## _ctx_run_once, \ name ## _ctx_break, \ name ## _ctx_reinitialize, \ name ## _ctx_set_flags, \ name ## _ctx_add, \ name ## _ctx_del \ }; \ verto_module VERTO_MODULE_TABLE(name) = { \ VERTO_MODULE_VERSION, \ # name, \ # symb, \ types, \ &name ## _funcs, \ }; \ verto_ctx \ verto_new_ ## name() \ { \ return verto_convert(name, 0, NULL); \ } \ verto_ctx * \ verto_default_ ## name() \ { \ return verto_convert(name, 1, NULL); \ } typedef struct { /* Required / verto_mod_ctx (ctx_new)(); / Optional / verto_mod_ctx (ctx_default)(); / Required / void (ctx_free)(verto_mod_ctx ctx); / Optional / void (ctx_run)(verto_mod_ctx ctx); / Required / void (ctx_run_once)(verto_mod_ctx ctx); / Optional / void (ctx_break)(verto_mod_ctx ctx); / Optional / void (ctx_reinitialize)(verto_mod_ctx ctx); / Optional / void (ctx_set_flags)(verto_mod_ctx ctx, const verto_ev ev, verto_mod_ev modev); / Required / verto_mod_ev (ctx_add)(verto_mod_ctx ctx, const verto_ev ev, verto_ev_flag flags); /* Required / void (ctx_del)(verto_mod_ctx ctx, const verto_ev ev, verto_mod_ev modev); } verto_ctx_funcs; typedef struct { unsigned int vers; const char name; const char symb; verto_ev_type types; verto_ctx_funcs funcs; } verto_module; /** * Converts an existing implementation specific loop to a verto_ctx. * * This function also sets the internal default implementation so that future * calls to verto_new(NULL) or verto_default(NULL) will use this specific * implementation if it was not already set. * * @param name The name of the module (unquoted) * @param deflt Whether the ctx is the default context or not * @param ctx The context to store * @return A new verto_ctx, or NULL on error. Call verto_free() when done. / #define verto_convert(name, deflt, ctx) \ verto_convert_module(&VERTO_MODULE_TABLE(name), deflt, ctx) /* * Converts an existing implementation specific loop to a verto_ctx. * * If you are a module implementation, you probably want the macro above. This * function is generally used directly only when an application is attempting * to expose a home-grown event loop to verto. * * If deflt is non-zero and a default ctx was already defined for this module * and ctx is not NULL, than ctx will be free'd and the previously defined * default will be returned. * * If ctx is non-NULL, than the pre-existing verto_mod_ctx will be converted to * to a verto_ctx; if deflt is non-zero than this verto_mod_ctx will also be * marked as the default loop for this process. If ctx is NULL, than the * appropriate constructor will be called: either module->ctx_new() or * module->ctx_default() depending on the boolean value of deflt. If * module->ctx_default is NULL and deflt is non-zero, than module->ctx_new() * will be called and the resulting verto_mod_ctx will be utilized as the * default. * * This function also sets the internal default implementation so that future * calls to verto_new(NULL) or verto_default(NULL) will use this specific * implementation if it was not already set. * * @param name The name of the module (unquoted) * @param ctx The context private to store * @return A new verto_ctx, or NULL on error. Call verto_free() when done. / verto_ctx verto_convert_module(const verto_module module, int deflt, verto_mod_ctx ctx); /** * Calls the callback of the verto_ev and then frees it via verto_del(). * * The verto_ev is not freed (verto_del() is not called) if it is a signal event. * * @see verto_add_read() * @see verto_add_write() * @see verto_add_timeout() * @see verto_add_idle() * @see verto_add_signal() * @see verto_add_child() * @see verto_del() * @param ev The verto_ev / void verto_fire(verto_ev ev); /** * Sets the status of the pid/handle which caused this event to fire. * * This function does nothing if the verto_ev is not a child type. * * @see verto_add_child() * @param ev The verto_ev to set the status in. * @param status The pid/handle status. / void verto_set_proc_status(verto_ev ev, verto_proc_status status); /** * Sets the state of the fd which caused this event to fire. * * This function does nothing if the verto_ev is not a io type. * * Only the flags VERTO_EV_FLAG_IO_(READ\|WRITE\|ERROR) are supported. All other * flags are unset. * * @see verto_add_io() * @param ev The verto_ev to set the state in. * @param state The fd state. / void verto_set_fd_state(verto_ev ev, verto_ev_flag state); #endif /* VERTO_MODULE_H_ */	6.48 KB	2022-02-10 04:33
📄 verto.h /* * Copyright 2011 Red Hat, Inc. * * 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. / #ifndef VERTO_H_ #define VERTO_H_ #include <time.h> / For time_t / #include <unistd.h> / For pid_t / #ifdef WIN32 #include <windows.h> typedef HANDLE verto_proc; typedef DWORD verto_proc_status; #else #include <sys/types.h> typedef pid_t verto_proc; typedef int verto_proc_status; #endif #define VERTO_SIG_IGN ((verto_callback ) 1) #ifdef __cplusplus extern "C" { #endif /* __cplusplus / typedef struct verto_ctx verto_ctx; typedef struct verto_ev verto_ev; typedef enum { VERTO_EV_TYPE_NONE = 0, VERTO_EV_TYPE_IO = 1, VERTO_EV_TYPE_TIMEOUT = 1 << 1, VERTO_EV_TYPE_IDLE = 1 << 2, VERTO_EV_TYPE_SIGNAL = 1 << 3, VERTO_EV_TYPE_CHILD = 1 << 4 } verto_ev_type; typedef enum { VERTO_EV_FLAG_NONE = 0, VERTO_EV_FLAG_PERSIST = 1, VERTO_EV_FLAG_PRIORITY_LOW = 1 << 1, VERTO_EV_FLAG_PRIORITY_MEDIUM = 1 << 2, VERTO_EV_FLAG_PRIORITY_HIGH = 1 << 3, VERTO_EV_FLAG_IO_READ = 1 << 4, VERTO_EV_FLAG_IO_WRITE = 1 << 5, VERTO_EV_FLAG_IO_ERROR = 1 << 7, VERTO_EV_FLAG_IO_CLOSE_FD = 1 << 8, VERTO_EV_FLAG_REINITIABLE = 1 << 6, _VERTO_EV_FLAG_MUTABLE_MASK = VERTO_EV_FLAG_PRIORITY_LOW \| VERTO_EV_FLAG_PRIORITY_MEDIUM \| VERTO_EV_FLAG_PRIORITY_HIGH \| VERTO_EV_FLAG_IO_READ \| VERTO_EV_FLAG_IO_WRITE, _VERTO_EV_FLAG_MAX = VERTO_EV_FLAG_IO_CLOSE_FD } verto_ev_flag; typedef void (verto_callback)(verto_ctx ctx, verto_ev ev); /* * Creates a new event context using an optionally specified implementation * and/or optionally specified required features. * * If you are an application that has already decided on using a particular * event loop implementation, you should not call this function, but instead * import the verto-NAME.h header and link against the verto-NAME.so, where * NAME is the implementation you wish to use. * * If you are a library, you should generally avoid creating event contexts * on your own but allow applications to pass in a verto_ctx you can use. * * There are two cases where you should use this function. The first is * where you have a need to choose an implementation at run time, usually * for testing purposes. The second and more common is when you simply * wish to remain implementation agnostic. In this later case, you should * always call like this: verto_new(NULL, ...). This lets verto choose the best * implementation to use. * * If impl is not NULL, a new context is returned which is backed by the * implementation specified. If the implementation specified is not * available or if the required types (reqtypes) are not provided by the * named implementation, NULL is returned. The parameter 'impl' can specify: * * The full path to an implementation library * * The name of the implementation library (i.e. - "glib" or "libev") * * If impl is NULL, verto will attempt to automatically determine the * best implementation to use. * * First, verto will attempt to use an existing, previously loaded * implementation. This is handled automatically by internal caching of either * the first implementation loaded or the one specified by verto_set_default(). * * Second, verto will attempt to discern if you are already linked to any * of the supported implementations (to avoid wasting memory by loading * extra unnecessary libraries). If you are linked to one supported * implementation, that implementation will be chosen. If you are linked * to more than one supported implementation one of the ones linked to * will be chosen, but the order of the particular choice is undefined. * * Third, verto will attempt to load the compile-time default, if defined at * build time and available at runtime. * * Last, verto will attempt to load any implementation installed. The specific * order of this step is undefined. * * In all cases above, if the implementation does not support all the specified * features (reqtypes), it will be skipped and processing will continue from * where it left off. This means that if verto_new() returns non-NULL it is * guaranteed to support the features you specified. * * @see verto_set_default() * @param impl The implementation to use, or NULL. * @param reqtypes A bitwise or'd list of required event type features. * @return A new verto_ctx, or NULL on error. Call verto_free() when done. / verto_ctx verto_new(const char impl, verto_ev_type reqtypes); /* * Gets the default event context using an optionally specified implementation. * * This function is essentially a singleton version of verto_new(). However, * since this function must return the same loop as the _default() call of the underlying implementation (if such a function exists), it is NOT a * global singleton, but a per-implementation singleton. For this reason, you * must call verto_free() when you are done with this loop. Even after calling * verto_free() on the default verto_ctx, you can safely call verto_default() * again and receive a new reference to the same (internally default) loop. * * In all other respects, verto_default() acts exactly like verto_new(). * * @see verto_new() * @see verto_free() * @param impl The implementation to use, or NULL. * @param reqtypes A bitwise or'd list of required event type features. * @return The default verto_ctx, or NULL on error. Call verto_free() when done. / verto_ctx verto_default(const char impl, verto_ev_type reqtypes); /* * Sets the default implementation to use by its name. * * This function returns 1 on success and 0 on failure. It can fail for the * following reasons: * 1. The default implementation was already set via verto_set_default(). * 2. The implementation specified could not be found. * 3. The implementation specified didn't support the features specified. * 4. The impl argument was NULL. * 5. verto_new() was already called. * 6. verto_default() was already called. * 7. verto_new_NAME() was already called. * 8. verto_default_NAME() was already called. * 9. verto_convert_NAME() was already called. * * @see verto_new() * @see verto_default() * @param impl The implementation to use. * @param reqtypes A bitwise or'd list of required event type features. * @return The default verto_ctx, or NULL on error. Call verto_free() when done. / int verto_set_default(const char impl, verto_ev_type reqtypes); /** * Sets the allocator to use for verto_ctx and verto_ev objects. * * If you plan to set the allocator, you MUST call this function before any * other verto_() calls. * @see verto_new() * @see verto_default() * @see verto_add_io() * @see verto_add_timeout() * @see verto_add_idle() * @see verto_add_signal() * @see verto_add_child() * @param resize The allocator to use (behaves like realloc(); * resize(ptr, 0) must free memory at ptr.) * @param hierarchical Zero if the allocator is not hierarchical / int verto_set_allocator(void (resize)(void mem, size_t size), int hierarchical); /** * Frees a verto_ctx. * * When called on a default verto_ctx, the reference will be freed but the * internal default loop will still be available via another call to * verto_default(). * * @see verto_new() * @see verto_default() * @param ctx The verto_ctx to free. / void verto_free(verto_ctx ctx); /** * Frees global state. * * Remove and free all allocated global state. Call only when no further * contexts exist and all threads have exited. * * @see verto_new() * @see verto_free() * @see verto_default() / void verto_cleanup(void); /* * Run the verto_ctx forever, or at least until verto_break() is called. * * @see verto_break() * @param ctx The verto_ctx to run. / void verto_run(verto_ctx ctx); /** * Run the verto_ctx once. May block. * * @param ctx The verto_ctx to run once. / void verto_run_once(verto_ctx ctx); /** * Exits the currently running verto_ctx. * * @see verto_run() * @param ctx The verto_ctx to exit. / void verto_break(verto_ctx ctx); /** * Re-initializes the verto_ctx. * * This function deletes all events, except those which have set the * VERTO_EV_FLAG_REINITIABLE flag. If you fork(), you MUST call this in the * child process after the fork! * * If this function fails it indicates that at least one * VERTO_EV_FLAG_REINITIABLE event was not rearmed or that ctx was NULL. * * @see verto_new() * @see verto_default() * @param ctx The verto_ctx to re-initialize. * @return Non-zero on success, 0 on error. / int verto_reinitialize(verto_ctx ctx); /** * Adds a callback executed when a file descriptor is ready to be read/written. * * All verto_ev events are automatically freed when their parent verto_ctx is * freed. You do not need to free them manually. If VERTO_EV_FLAG_PERSIST is * provided, the event will repeat until verto_del() is called. If * VERTO_EV_FLAG_PERSIST is not provided, the event will be freed automatically * after its execution. In either case, you may call verto_del() at any time * to prevent the event from executing. * If VERTO_EV_FLAG_IO_CLOSE_FD is provided the passed in fd is automatically * closed when the event is freed with verto_del() * * NOTE: On Windows, the underlying select() only works with sockets. As such, * any attempt to add a non-socket io event on Windows will produce undefined * results and may even crash. * * @see verto_del() * @param ctx The verto_ctx which will fire the callback. * @param flags The flags to set (at least one VERTO_EV_FLAG_IO* required). * @param callback The callback to fire. * @param fd The file descriptor to watch for reads. * @return The verto_ev registered with the event context or NULL on error. / verto_ev verto_add_io(verto_ctx ctx, verto_ev_flag flags, verto_callback callback, int fd); /** * Adds a callback executed after a period of time. * * All verto_ev events are automatically freed when their parent verto_ctx is * freed. You do not need to free them manually. If VERTO_EV_FLAG_PERSIST is * provided, the event will repeat until verto_del() is called. If * VERTO_EV_FLAG_PERSIST is not provided, the event will be freed automatically * after its execution. In either case, you may call verto_del() at any time * to prevent the event from executing. * * @see verto_del() * @param ctx The verto_ctx which will fire the callback. * @param flags The flags to set. * @param callback The callback to fire. * @param interval Time period to wait before firing (in milliseconds). * @return The verto_ev registered with the event context. / verto_ev verto_add_timeout(verto_ctx ctx, verto_ev_flag flags, verto_callback callback, time_t interval); /** * Adds a callback executed when there is nothing else to do. * * All verto_ev events are automatically freed when their parent verto_ctx is * freed. You do not need to free them manually. If VERTO_EV_FLAG_PERSIST is * provided, the event will repeat until verto_del() is called. If * VERTO_EV_FLAG_PERSIST is not provided, the event will be freed automatically * after its execution. In either case, you may call verto_del() at any time * to prevent the event from executing. * * @see verto_del() * @param ctx The verto_ctx which will fire the callback. * @param flags The flags to set. * @param callback The callback to fire. * @return The verto_ev registered with the event context. / verto_ev verto_add_idle(verto_ctx ctx, verto_ev_flag flags, verto_callback callback); /** * Adds a callback executed when a signal is received. * * All verto_ev events are automatically freed when their parent verto_ctx is * freed. You do not need to free them manually. If VERTO_EV_FLAG_PERSIST is * provided, the event will repeat until verto_del() is called. If * VERTO_EV_FLAG_PERSIST is not provided, the event will be freed automatically * after its execution. In either case, you may call verto_del() at any time * to prevent the event from executing. * * NOTE: If you attempt to ignore a signal without the VERTO_EV_FLAG_PERSIST * flag, this function fails. * * NOTE: SIGCHLD is expressly not supported. If you want this notification, * please use verto_add_child(). * * WARNNIG: Signal events can only be reliably received in the default verto_ctx * in some implementations. Attempting to receive signal events in non-default * loops may result in assert() failures. * * WARNING: While verto does its best to protect you from crashes, there is * essentially no way to do signal events if you mix multiple implementations in * a single process. Attempting to do so will result in undefined behavior, * and potentially even a crash. You have been warned. * * @see verto_add_child() * @see verto_repeat() * @see verto_del() * @param ctx The verto_ctx which will fire the callback. * @param flags The flags to set. * @param callback The callback to fire. * @param signal The signal to watch for. * @return The verto_ev registered with the event context. / verto_ev verto_add_signal(verto_ctx ctx, verto_ev_flag flags, verto_callback callback, int signal); /** * Adds a callback executed when a child process exits. * * This event will be freed automatically after its execution. Due to the * nature of a process' life-cycle, child events cannot persist (processes only * exit once). This function returns NULL if you attempt to use * VERTO_EV_FLAG_PERSIST. You may, of course, call verto_del() at any time to * prevent the callback from firing. * * @see verto_del() * @param ctx The verto_ctx which will fire the callback. * @param flags The flags to set. * @param callback The callback to fire. * @param child The pid (POSIX) or handle (Win32) of the child to watch for. * @return The verto_ev registered with the event context. / verto_ev verto_add_child(verto_ctx ctx, verto_ev_flag flags, verto_callback callback, verto_proc proc); /** * Sets the private pointer of the verto_ev. * * The free callback will be called in two cases: * 1. When the event is deleted (manually or automatically) * 2. When verto_set_private() is called again, unless * free is NULL. * * @see verto_get_private() * @param ev The verto_ev * @param priv The private value to store * @param free The callback used to free the data or NULL / void verto_set_private(verto_ev ev, void priv, verto_callback free); /** * Gets the private pointer of the verto_ev. * * @see verto_set_private() * @param ev The verto_ev * @return The verto_ev private pointer / void verto_get_private(const verto_ev ev); /* * Gets the type of the verto_ev. * * @see verto_add_io() * @see verto_add_timeout() * @see verto_add_idle() * @see verto_add_signal() * @see verto_add_child() * @param ev The verto_ev * @return The verto_ev type / verto_ev_type verto_get_type(const verto_ev ev); /** * Gets the flags associated with the given verto_ev. * * @see verto_add_io() * @see verto_add_timeout() * @see verto_add_idle() * @see verto_add_signal() * @see verto_add_child() * @see verto_set_flags() * @param ev The verto_ev * @return The verto_ev type / verto_ev_flag verto_get_flags(const verto_ev ev); /** * Sets the flags associated with the given verto_ev. * * See _VERTO_EV_FLAG_MUTABLE_MASK for the flags that can be changed * with this function. All others will be ignored. If the flags specified * are the same as the flags the event already has, this function is a no-op. * * @see verto_add_io() * @see verto_add_timeout() * @see verto_add_idle() * @see verto_add_signal() * @see verto_add_child() * @see verto_get_flags() * @param ev The verto_ev * @param flags The flags for the event / void verto_set_flags(verto_ev ev, verto_ev_flag flags); /** * Gets the file descriptor associated with a read/write verto_ev. * * @see verto_add_io() * @param ev The verto_ev to retrieve the file descriptor from. * @return The file descriptor, or -1 if not a read/write event. / int verto_get_fd(const verto_ev ev); /** * Gets the file descriptor state from when the event fires. * * @see verto_add_io() * @param ev The verto_ev to retrieve the fd state from. * @return The fd state. / verto_ev_flag verto_get_fd_state(const verto_ev ev); /** * Gets the interval associated with a timeout verto_ev. * * @see verto_add_timeout() * @param ev The verto_ev to retrieve the interval from. * @return The interval, or 0 if not a timeout event. / time_t verto_get_interval(const verto_ev ev); /** * Gets the signal associated with a signal verto_ev. * * @see verto_add_signal() * @param ev The verto_ev to retrieve the signal from. * @return The signal, or -1 if not a signal event. / int verto_get_signal(const verto_ev ev); /** * Gets the process associated with a child verto_ev. * * @see verto_add_child() * @param ev The verto_ev to retrieve the process from. * @return The pid/handle, or 0/NULL if not a child event (POSIX/Win32). / verto_proc verto_get_proc(const verto_ev ev); /** * Gets the status of the process which caused this event to fire. * * @see verto_add_child() * @param ev The verto_ev to retrieve the status from. * @return The pid/handle status. / verto_proc_status verto_get_proc_status(const verto_ev ev); /** * Gets the verto_ctx associated with a verto_ev. * * This is a borrowed reference, don't attempt to free it! * * @param ev The verto_ev to retrieve the verto_ctx from. * @return The verto_ctx. / verto_ctx verto_get_ctx(const verto_ev ev); /* * Removes an event from from the event context and frees it. * * The event and its contents cannot be used after this call. * * @see verto_add_io() * @see verto_add_timeout() * @see verto_add_idle() * @see verto_add_signal() * @see verto_add_child() * @param ev The event to delete. / void verto_del(verto_ev ev); /** * Returns the event types supported by this implementation. * * @param ctx The verto_ctx to query. * @return The event types supported. / verto_ev_type verto_get_supported_types(verto_ctx ctx); #ifdef __cplusplus } /* extern "C" / #endif / __cplusplus / #endif / VERTO_H_ */	18.98 KB	2022-02-10 04:33
📁 video	-	2026-03-27 02:43
📄 wait.h #include <sys/wait.h>	22 B	2026-02-17 11:01
📄 wchar.h /* Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99 Standard: 7.24 * Extended multibyte and wide character utilities <wchar.h> / #ifndef _WCHAR_H #define _WCHAR_H 1 #define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION #include <bits/libc-header-start.h> / Gather machine dependent type support. / #include <bits/floatn.h> #define __need_size_t #define __need_wchar_t #define __need_NULL #include <stddef.h> #define __need___va_list #include <stdarg.h> #include <bits/wchar.h> #include <bits/types/wint_t.h> #include <bits/types/mbstate_t.h> #include <bits/types/__FILE.h> #if defined __USE_UNIX98 \|\| defined __USE_XOPEN2K # include <bits/types/FILE.h> #endif #ifdef __USE_XOPEN2K8 # include <bits/types/locale_t.h> #endif / Tell the caller that we provide correct C++ prototypes. / #if defined __cplusplus && __GNUC_PREREQ (4, 4) # define __CORRECT_ISO_CPP_WCHAR_H_PROTO #endif #ifndef WCHAR_MIN / These constants might also be defined in <inttypes.h>. / # define WCHAR_MIN __WCHAR_MIN # define WCHAR_MAX __WCHAR_MAX #endif #ifndef WEOF # define WEOF (0xffffffffu) #endif / All versions of XPG prior to the publication of ISO C99 required the bulk of <wctype.h>'s declarations to appear in this header (because <wctype.h> did not exist prior to C99). In POSIX.1-2001 those declarations were marked as XSI extensions; in -2008 they were additionally marked as obsolescent. _GNU_SOURCE mode anticipates the removal of these declarations in the next revision of POSIX. / #if (defined __USE_XOPEN && !defined __USE_GNU \ && !(defined __USE_XOPEN2K && !defined __USE_XOPEN2KXSI)) # include <bits/wctype-wchar.h> #endif __BEGIN_DECLS / This incomplete type is defined in <time.h> but needed here because of `wcsftime'. / struct tm; / Copy SRC to DEST. / extern wchar_t wcscpy (wchar_t __restrict __dest, const wchar_t __restrict __src) __THROW __nonnull ((1, 2)); /* Copy no more than N wide-characters of SRC to DEST. / extern wchar_t wcsncpy (wchar_t __restrict __dest, const wchar_t __restrict __src, size_t __n) __THROW __nonnull ((1, 2)); /* Append SRC onto DEST. / extern wchar_t wcscat (wchar_t __restrict __dest, const wchar_t __restrict __src) __THROW __nonnull ((1, 2)); /* Append no more than N wide-characters of SRC onto DEST. / extern wchar_t wcsncat (wchar_t __restrict __dest, const wchar_t __restrict __src, size_t __n) __THROW __nonnull ((1, 2)); /* Compare S1 and S2. / extern int wcscmp (const wchar_t __s1, const wchar_t __s2) __THROW __attribute_pure__ __nonnull ((1, 2)); / Compare N wide-characters of S1 and S2. / extern int wcsncmp (const wchar_t __s1, const wchar_t __s2, size_t __n) __THROW __attribute_pure__ __nonnull ((1, 2)); #ifdef __USE_XOPEN2K8 / Compare S1 and S2, ignoring case. / extern int wcscasecmp (const wchar_t __s1, const wchar_t __s2) __THROW; / Compare no more than N chars of S1 and S2, ignoring case. / extern int wcsncasecmp (const wchar_t __s1, const wchar_t __s2, size_t __n) __THROW; / Similar to the two functions above but take the information from the provided locale and not the global locale. / extern int wcscasecmp_l (const wchar_t __s1, const wchar_t __s2, locale_t __loc) __THROW; extern int wcsncasecmp_l (const wchar_t __s1, const wchar_t __s2, size_t __n, locale_t __loc) __THROW; #endif / Compare S1 and S2, both interpreted as appropriate to the LC_COLLATE category of the current locale. / extern int wcscoll (const wchar_t __s1, const wchar_t __s2) __THROW; / Transform S2 into array pointed to by S1 such that if wcscmp is applied to two transformed strings the result is the as applying `wcscoll' to the original strings. / extern size_t wcsxfrm (wchar_t __restrict __s1, const wchar_t __restrict __s2, size_t __n) __THROW; #ifdef __USE_XOPEN2K8 / Similar to the two functions above but take the information from the provided locale and not the global locale. / / Compare S1 and S2, both interpreted as appropriate to the LC_COLLATE category of the given locale. / extern int wcscoll_l (const wchar_t __s1, const wchar_t __s2, locale_t __loc) __THROW; / Transform S2 into array pointed to by S1 such that if wcscmp is applied to two transformed strings the result is the as applying `wcscoll' to the original strings. / extern size_t wcsxfrm_l (wchar_t __s1, const wchar_t __s2, size_t __n, locale_t __loc) __THROW; / Duplicate S, returning an identical malloc'd string. / extern wchar_t wcsdup (const wchar_t __s) __THROW __attribute_malloc__ __attr_dealloc_free; #endif / Find the first occurrence of WC in WCS. / #ifdef __CORRECT_ISO_CPP_WCHAR_H_PROTO extern "C++" wchar_t wcschr (wchar_t __wcs, wchar_t __wc) __THROW __asm ("wcschr") __attribute_pure__; extern "C++" const wchar_t wcschr (const wchar_t __wcs, wchar_t __wc) __THROW __asm ("wcschr") __attribute_pure__; #else extern wchar_t wcschr (const wchar_t __wcs, wchar_t __wc) __THROW __attribute_pure__; #endif / Find the last occurrence of WC in WCS. / #ifdef __CORRECT_ISO_CPP_WCHAR_H_PROTO extern "C++" wchar_t wcsrchr (wchar_t __wcs, wchar_t __wc) __THROW __asm ("wcsrchr") __attribute_pure__; extern "C++" const wchar_t wcsrchr (const wchar_t __wcs, wchar_t __wc) __THROW __asm ("wcsrchr") __attribute_pure__; #else extern wchar_t wcsrchr (const wchar_t __wcs, wchar_t __wc) __THROW __attribute_pure__; #endif #ifdef __USE_GNU / This function is similar to `wcschr'. But it returns a pointer to the closing NUL wide character in case C is not found in S. / extern wchar_t wcschrnul (const wchar_t __s, wchar_t __wc) __THROW __attribute_pure__; #endif / Return the length of the initial segmet of WCS which consists entirely of wide characters not in REJECT. / extern size_t wcscspn (const wchar_t __wcs, const wchar_t __reject) __THROW __attribute_pure__; / Return the length of the initial segmet of WCS which consists entirely of wide characters in ACCEPT. / extern size_t wcsspn (const wchar_t __wcs, const wchar_t __accept) __THROW __attribute_pure__; / Find the first occurrence in WCS of any character in ACCEPT. / #ifdef __CORRECT_ISO_CPP_WCHAR_H_PROTO extern "C++" wchar_t wcspbrk (wchar_t __wcs, const wchar_t __accept) __THROW __asm ("wcspbrk") __attribute_pure__; extern "C++" const wchar_t wcspbrk (const wchar_t __wcs, const wchar_t __accept) __THROW __asm ("wcspbrk") __attribute_pure__; #else extern wchar_t wcspbrk (const wchar_t __wcs, const wchar_t __accept) __THROW __attribute_pure__; #endif /* Find the first occurrence of NEEDLE in HAYSTACK. / #ifdef __CORRECT_ISO_CPP_WCHAR_H_PROTO extern "C++" wchar_t wcsstr (wchar_t __haystack, const wchar_t __needle) __THROW __asm ("wcsstr") __attribute_pure__; extern "C++" const wchar_t wcsstr (const wchar_t __haystack, const wchar_t __needle) __THROW __asm ("wcsstr") __attribute_pure__; #else extern wchar_t wcsstr (const wchar_t __haystack, const wchar_t __needle) __THROW __attribute_pure__; #endif /* Divide WCS into tokens separated by characters in DELIM. / extern wchar_t wcstok (wchar_t __restrict __s, const wchar_t __restrict __delim, wchar_t *__restrict __ptr) __THROW; / Return the number of wide characters in S. / extern size_t wcslen (const wchar_t __s) __THROW __attribute_pure__; #ifdef __USE_XOPEN /* Another name for `wcsstr' from XPG4. / # ifdef __CORRECT_ISO_CPP_WCHAR_H_PROTO extern "C++" wchar_t wcswcs (wchar_t __haystack, const wchar_t __needle) __THROW __asm ("wcswcs") __attribute_pure__; extern "C++" const wchar_t wcswcs (const wchar_t __haystack, const wchar_t __needle) __THROW __asm ("wcswcs") __attribute_pure__; # else extern wchar_t wcswcs (const wchar_t __haystack, const wchar_t __needle) __THROW __attribute_pure__; # endif #endif #ifdef __USE_XOPEN2K8 /* Return the number of wide characters in S, but at most MAXLEN. / extern size_t wcsnlen (const wchar_t __s, size_t __maxlen) __THROW __attribute_pure__; #endif /* Search N wide characters of S for C. / #ifdef __CORRECT_ISO_CPP_WCHAR_H_PROTO extern "C++" wchar_t wmemchr (wchar_t __s, wchar_t __c, size_t __n) __THROW __asm ("wmemchr") __attribute_pure__; extern "C++" const wchar_t wmemchr (const wchar_t __s, wchar_t __c, size_t __n) __THROW __asm ("wmemchr") __attribute_pure__; #else extern wchar_t wmemchr (const wchar_t __s, wchar_t __c, size_t __n) __THROW __attribute_pure__; #endif / Compare N wide characters of S1 and S2. / extern int wmemcmp (const wchar_t __s1, const wchar_t __s2, size_t __n) __THROW __attribute_pure__; / Copy N wide characters of SRC to DEST. / extern wchar_t wmemcpy (wchar_t __restrict __s1, const wchar_t __restrict __s2, size_t __n) __THROW; /* Copy N wide characters of SRC to DEST, guaranteeing correct behavior for overlapping strings. / extern wchar_t wmemmove (wchar_t __s1, const wchar_t __s2, size_t __n) __THROW; /* Set N wide characters of S to C. / extern wchar_t wmemset (wchar_t __s, wchar_t __c, size_t __n) __THROW; #ifdef __USE_GNU / Copy N wide characters of SRC to DEST and return pointer to following wide character. / extern wchar_t wmempcpy (wchar_t __restrict __s1, const wchar_t __restrict __s2, size_t __n) __THROW; #endif /* Determine whether C constitutes a valid (one-byte) multibyte character. / extern wint_t btowc (int __c) __THROW; / Determine whether C corresponds to a member of the extended character set whose multibyte representation is a single byte. / extern int wctob (wint_t __c) __THROW; / Determine whether PS points to an object representing the initial state. / extern int mbsinit (const mbstate_t __ps) __THROW __attribute_pure__; /* Write wide character representation of multibyte character pointed to by S to PWC. / extern size_t mbrtowc (wchar_t __restrict __pwc, const char __restrict __s, size_t __n, mbstate_t __restrict __p) __THROW; /* Write multibyte representation of wide character WC to S. / extern size_t wcrtomb (char __restrict __s, wchar_t __wc, mbstate_t __restrict __ps) __THROW; / Return number of bytes in multibyte character pointed to by S. / extern size_t __mbrlen (const char __restrict __s, size_t __n, mbstate_t __restrict __ps) __THROW; extern size_t mbrlen (const char __restrict __s, size_t __n, mbstate_t __restrict __ps) __THROW; #ifdef __USE_EXTERN_INLINES / Define inline function as optimization. / / We can use the BTOWC and WCTOB optimizations since we know that all locales must use ASCII encoding for the values in the ASCII range and because the wchar_t encoding is always ISO 10646. / extern wint_t __btowc_alias (int __c) __asm ("btowc"); __extern_inline wint_t __NTH (btowc (int __c)) { return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f' ? (wint_t) __c : __btowc_alias (__c)); } extern int __wctob_alias (wint_t __c) __asm ("wctob"); __extern_inline int __NTH (wctob (wint_t __wc)) { return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f' ? (int) __wc : __wctob_alias (__wc)); } __extern_inline size_t __NTH (mbrlen (const char __restrict __s, size_t __n, mbstate_t __restrict __ps)) { return (__ps != NULL ? mbrtowc (NULL, __s, __n, __ps) : __mbrlen (__s, __n, NULL)); } #endif / Write wide character representation of multibyte character string SRC to DST. / extern size_t mbsrtowcs (wchar_t __restrict __dst, const char *__restrict __src, size_t __len, mbstate_t __restrict __ps) __THROW; /* Write multibyte character representation of wide character string SRC to DST. / extern size_t wcsrtombs (char __restrict __dst, const wchar_t *__restrict __src, size_t __len, mbstate_t __restrict __ps) __THROW; #ifdef __USE_XOPEN2K8 /* Write wide character representation of at most NMC bytes of the multibyte character string SRC to DST. / extern size_t mbsnrtowcs (wchar_t __restrict __dst, const char *__restrict __src, size_t __nmc, size_t __len, mbstate_t __restrict __ps) __THROW; /* Write multibyte character representation of at most NWC characters from the wide character string SRC to DST. / extern size_t wcsnrtombs (char __restrict __dst, const wchar_t *__restrict __src, size_t __nwc, size_t __len, mbstate_t __restrict __ps) __THROW; #endif /* use POSIX 2008 / / The following functions are extensions found in X/Open CAE. / #ifdef __USE_XOPEN / Determine number of column positions required for C. / extern int wcwidth (wchar_t __c) __THROW; / Determine number of column positions required for first N wide characters (or fewer if S ends before this) in S. / extern int wcswidth (const wchar_t __s, size_t __n) __THROW; #endif /* Use X/Open. / / Convert initial portion of the wide string NPTR to `double' representation. / extern double wcstod (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr) __THROW; #ifdef __USE_ISOC99 / Likewise for `float' and `long double' sizes of floating-point numbers. / extern float wcstof (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr) __THROW; extern long double wcstold (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr) __THROW; #endif / C99 / / Likewise for `_FloatN' and `_FloatNx' when support is enabled. / #if __HAVE_FLOAT16 && defined __USE_GNU extern _Float16 wcstof16 (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr) __THROW; #endif #if __HAVE_FLOAT32 && defined __USE_GNU extern _Float32 wcstof32 (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr) __THROW; #endif #if __HAVE_FLOAT64 && defined __USE_GNU extern _Float64 wcstof64 (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr) __THROW; #endif #if __HAVE_FLOAT128 && defined __USE_GNU extern _Float128 wcstof128 (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr) __THROW; #endif #if __HAVE_FLOAT32X && defined __USE_GNU extern _Float32x wcstof32x (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr) __THROW; #endif #if __HAVE_FLOAT64X && defined __USE_GNU extern _Float64x wcstof64x (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr) __THROW; #endif #if __HAVE_FLOAT128X && defined __USE_GNU extern _Float128x wcstof128x (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr) __THROW; #endif / Convert initial portion of wide string NPTR to `long int' representation. / extern long int wcstol (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, int __base) __THROW; / Convert initial portion of wide string NPTR to `unsigned long int' representation. / extern unsigned long int wcstoul (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, int __base) __THROW; #ifdef __USE_ISOC99 / Convert initial portion of wide string NPTR to `long long int' representation. / __extension__ extern long long int wcstoll (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, int __base) __THROW; / Convert initial portion of wide string NPTR to `unsigned long long int' representation. / __extension__ extern unsigned long long int wcstoull (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, int __base) __THROW; #endif / ISO C99. / #ifdef __USE_GNU / Convert initial portion of wide string NPTR to `long long int' representation. / __extension__ extern long long int wcstoq (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, int __base) __THROW; / Convert initial portion of wide string NPTR to `unsigned long long int' representation. / __extension__ extern unsigned long long int wcstouq (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, int __base) __THROW; #endif / Use GNU. / #ifdef __USE_GNU / Parallel versions of the functions above which take the locale to use as an additional parameter. These are GNU extensions inspired by the POSIX.1-2008 extended locale API. / extern long int wcstol_l (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, int __base, locale_t __loc) __THROW; extern unsigned long int wcstoul_l (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, int __base, locale_t __loc) __THROW; __extension__ extern long long int wcstoll_l (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, int __base, locale_t __loc) __THROW; __extension__ extern unsigned long long int wcstoull_l (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, int __base, locale_t __loc) __THROW; extern double wcstod_l (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, locale_t __loc) __THROW; extern float wcstof_l (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, locale_t __loc) __THROW; extern long double wcstold_l (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, locale_t __loc) __THROW; # if __HAVE_FLOAT16 extern _Float16 wcstof16_l (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, locale_t __loc) __THROW; # endif # if __HAVE_FLOAT32 extern _Float32 wcstof32_l (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, locale_t __loc) __THROW; # endif # if __HAVE_FLOAT64 extern _Float64 wcstof64_l (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, locale_t __loc) __THROW; # endif # if __HAVE_FLOAT128 extern _Float128 wcstof128_l (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, locale_t __loc) __THROW; # endif # if __HAVE_FLOAT32X extern _Float32x wcstof32x_l (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, locale_t __loc) __THROW; # endif # if __HAVE_FLOAT64X extern _Float64x wcstof64x_l (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, locale_t __loc) __THROW; # endif # if __HAVE_FLOAT128X extern _Float128x wcstof128x_l (const wchar_t __restrict __nptr, wchar_t *__restrict __endptr, locale_t __loc) __THROW; # endif #endif / use GNU / #ifdef __USE_XOPEN2K8 / Copy SRC to DEST, returning the address of the terminating L'\0' in DEST. / extern wchar_t wcpcpy (wchar_t __restrict __dest, const wchar_t __restrict __src) __THROW; /* Copy no more than N characters of SRC to DEST, returning the address of the last character written into DEST. / extern wchar_t wcpncpy (wchar_t __restrict __dest, const wchar_t __restrict __src, size_t __n) __THROW; #endif /* Wide character I/O functions. / #if defined __USE_XOPEN2K8 \|\| __GLIBC_USE (LIB_EXT2) # ifndef __attr_dealloc_fclose # if defined __has_builtin # if __has_builtin (__builtin_fclose) / If the attribute macro hasn't been defined yet (by <stdio.h>) and fclose is a built-in, use it. / # define __attr_dealloc_fclose __attr_dealloc (__builtin_fclose, 1) # endif # endif # endif # ifndef __attr_dealloc_fclose # define __attr_dealloc_fclose / empty / # endif / Like OPEN_MEMSTREAM, but the stream is wide oriented and produces a wide character string. / extern __FILE open_wmemstream (wchar_t *__bufloc, size_t __sizeloc) __THROW __attribute_malloc__ __attr_dealloc_fclose; #endif #if defined __USE_ISOC95 \|\| defined __USE_UNIX98 /* Select orientation for stream. / extern int fwide (__FILE __fp, int __mode) __THROW; /* Write formatted output to STREAM. This function is a possible cancellation point and therefore not marked with __THROW. / extern int fwprintf (__FILE __restrict __stream, const wchar_t __restrict __format, ...) / __attribute__ ((__format__ (__wprintf__, 2, 3))) /; / Write formatted output to stdout. This function is a possible cancellation point and therefore not marked with __THROW. / extern int wprintf (const wchar_t __restrict __format, ...) /* __attribute__ ((__format__ (__wprintf__, 1, 2))) /; / Write formatted output of at most N characters to S. / extern int swprintf (wchar_t __restrict __s, size_t __n, const wchar_t __restrict __format, ...) __THROW / __attribute__ ((__format__ (__wprintf__, 3, 4))) /; / Write formatted output to S from argument list ARG. This function is a possible cancellation point and therefore not marked with __THROW. / extern int vfwprintf (__FILE __restrict __s, const wchar_t __restrict __format, __gnuc_va_list __arg) / __attribute__ ((__format__ (__wprintf__, 2, 0))) /; / Write formatted output to stdout from argument list ARG. This function is a possible cancellation point and therefore not marked with __THROW. / extern int vwprintf (const wchar_t __restrict __format, __gnuc_va_list __arg) /* __attribute__ ((__format__ (__wprintf__, 1, 0))) /; / Write formatted output of at most N character to S from argument list ARG. / extern int vswprintf (wchar_t __restrict __s, size_t __n, const wchar_t __restrict __format, __gnuc_va_list __arg) __THROW / __attribute__ ((__format__ (__wprintf__, 3, 0))) /; / Read formatted input from STREAM. This function is a possible cancellation point and therefore not marked with __THROW. / extern int fwscanf (__FILE __restrict __stream, const wchar_t __restrict __format, ...) / __attribute__ ((__format__ (__wscanf__, 2, 3))) /; / Read formatted input from stdin. This function is a possible cancellation point and therefore not marked with __THROW. / extern int wscanf (const wchar_t __restrict __format, ...) /* __attribute__ ((__format__ (__wscanf__, 1, 2))) /; / Read formatted input from S. / extern int swscanf (const wchar_t __restrict __s, const wchar_t __restrict __format, ...) __THROW / __attribute__ ((__format__ (__wscanf__, 2, 3))) /; / For historical reasons, the C99-compliant versions of the scanf functions are at alternative names. When __LDBL_COMPAT or __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI are in effect, this is handled in bits/wchar-ldbl.h. / #if !__GLIBC_USE (DEPRECATED_SCANF) && !defined __LDBL_COMPAT \ && __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 0 # ifdef __REDIRECT extern int __REDIRECT (fwscanf, (__FILE __restrict __stream, const wchar_t __restrict __format, ...), __isoc99_fwscanf) / __attribute__ ((__format__ (__wscanf__, 2, 3))) /; extern int __REDIRECT (wscanf, (const wchar_t __restrict __format, ...), __isoc99_wscanf) /* __attribute__ ((__format__ (__wscanf__, 1, 2))) /; extern int __REDIRECT_NTH (swscanf, (const wchar_t __restrict __s, const wchar_t __restrict __format, ...), __isoc99_swscanf) / __attribute__ ((__format__ (__wscanf__, 2, 3))) /; # else extern int __isoc99_fwscanf (__FILE __restrict __stream, const wchar_t __restrict __format, ...); extern int __isoc99_wscanf (const wchar_t __restrict __format, ...); extern int __isoc99_swscanf (const wchar_t __restrict __s, const wchar_t __restrict __format, ...) __THROW; # define fwscanf __isoc99_fwscanf # define wscanf __isoc99_wscanf # define swscanf __isoc99_swscanf # endif # endif #endif /* Use ISO C95, C99 and Unix98. / #ifdef __USE_ISOC99 / Read formatted input from S into argument list ARG. This function is a possible cancellation point and therefore not marked with __THROW. / extern int vfwscanf (__FILE __restrict __s, const wchar_t __restrict __format, __gnuc_va_list __arg) / __attribute__ ((__format__ (__wscanf__, 2, 0))) /; / Read formatted input from stdin into argument list ARG. This function is a possible cancellation point and therefore not marked with __THROW. / extern int vwscanf (const wchar_t __restrict __format, __gnuc_va_list __arg) /* __attribute__ ((__format__ (__wscanf__, 1, 0))) /; / Read formatted input from S into argument list ARG. / extern int vswscanf (const wchar_t __restrict __s, const wchar_t __restrict __format, __gnuc_va_list __arg) __THROW / __attribute__ ((__format__ (__wscanf__, 2, 0))) /; / Same redirection as above for the vwscanf family. / # if !__GLIBC_USE (DEPRECATED_SCANF) \ && (!defined __LDBL_COMPAT \|\| !defined __REDIRECT) \ && (defined __STRICT_ANSI__ \|\| defined __USE_XOPEN2K) \ && __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 0 # ifdef __REDIRECT extern int __REDIRECT (vfwscanf, (__FILE __restrict __s, const wchar_t __restrict __format, __gnuc_va_list __arg), __isoc99_vfwscanf) /* __attribute__ ((__format__ (__wscanf__, 2, 0))) /; extern int __REDIRECT (vwscanf, (const wchar_t __restrict __format, __gnuc_va_list __arg), __isoc99_vwscanf) /* __attribute__ ((__format__ (__wscanf__, 1, 0))) /; extern int __REDIRECT_NTH (vswscanf, (const wchar_t __restrict __s, const wchar_t __restrict __format, __gnuc_va_list __arg), __isoc99_vswscanf) / __attribute__ ((__format__ (__wscanf__, 2, 0))) /; # else extern int __isoc99_vfwscanf (__FILE __restrict __s, const wchar_t __restrict __format, __gnuc_va_list __arg); extern int __isoc99_vwscanf (const wchar_t __restrict __format, __gnuc_va_list __arg); extern int __isoc99_vswscanf (const wchar_t __restrict __s, const wchar_t __restrict __format, __gnuc_va_list __arg) __THROW; # define vfwscanf __isoc99_vfwscanf # define vwscanf __isoc99_vwscanf # define vswscanf __isoc99_vswscanf # endif # endif #endif /* Use ISO C99. / / Read a character from STREAM. These functions are possible cancellation points and therefore not marked with __THROW. / extern wint_t fgetwc (__FILE __stream); extern wint_t getwc (__FILE __stream); / Read a character from stdin. This function is a possible cancellation point and therefore not marked with __THROW. / extern wint_t getwchar (void); / Write a character to STREAM. These functions are possible cancellation points and therefore not marked with __THROW. / extern wint_t fputwc (wchar_t __wc, __FILE __stream); extern wint_t putwc (wchar_t __wc, __FILE __stream); / Write a character to stdout. This function is a possible cancellation point and therefore not marked with __THROW. / extern wint_t putwchar (wchar_t __wc); / Get a newline-terminated wide character string of finite length from STREAM. This function is a possible cancellation point and therefore not marked with __THROW. / extern wchar_t fgetws (wchar_t __restrict __ws, int __n, __FILE __restrict __stream); /* Write a string to STREAM. This function is a possible cancellation point and therefore not marked with __THROW. / extern int fputws (const wchar_t __restrict __ws, __FILE __restrict __stream); / Push a character back onto the input buffer of STREAM. This function is a possible cancellation point and therefore not marked with __THROW. / extern wint_t ungetwc (wint_t __wc, __FILE __stream); #ifdef __USE_GNU /* These are defined to be equivalent to the `char' functions defined in POSIX.1:1996. These functions are not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation they are cancellation points and therefore not marked with __THROW. / extern wint_t getwc_unlocked (__FILE __stream); extern wint_t getwchar_unlocked (void); /* This is the wide character version of a GNU extension. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern wint_t fgetwc_unlocked (__FILE __stream); /* Faster version when locking is not necessary. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern wint_t fputwc_unlocked (wchar_t __wc, __FILE __stream); /* These are defined to be equivalent to the `char' functions defined in POSIX.1:1996. These functions are not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation they are cancellation points and therefore not marked with __THROW. / extern wint_t putwc_unlocked (wchar_t __wc, __FILE __stream); extern wint_t putwchar_unlocked (wchar_t __wc); /* This function does the same as `fgetws' but does not lock the stream. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern wchar_t fgetws_unlocked (wchar_t __restrict __ws, int __n, __FILE __restrict __stream); /* This function does the same as `fputws' but does not lock the stream. This function is not part of POSIX and therefore no official cancellation point. But due to similarity with an POSIX interface or due to the implementation it is a cancellation point and therefore not marked with __THROW. / extern int fputws_unlocked (const wchar_t __restrict __ws, __FILE __restrict __stream); #endif / Format TP into S according to FORMAT. Write no more than MAXSIZE wide characters and return the number of wide characters written, or 0 if it would exceed MAXSIZE. / extern size_t wcsftime (wchar_t __restrict __s, size_t __maxsize, const wchar_t __restrict __format, const struct tm __restrict __tp) __THROW; # ifdef __USE_GNU /* Similar to `wcsftime' but takes the information from the provided locale and not the global locale. / extern size_t wcsftime_l (wchar_t __restrict __s, size_t __maxsize, const wchar_t __restrict __format, const struct tm __restrict __tp, locale_t __loc) __THROW; # endif /* Define some macros helping to catch buffer overflows. / #if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function / Declare all functions from bits/wchar2-decl.h first. / # include <bits/wchar2-decl.h> #endif / The following headers provide asm redirections. These redirections must appear before the first usage of these functions, e.g. in bits/wchar.h. / #if defined __LDBL_COMPAT \|\| __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 # include <bits/wchar-ldbl.h> #endif #if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function / Now include the function definitions and redirects too. / # include <bits/wchar2.h> #endif __END_DECLS #endif / wchar.h */	31.39 KB	2026-02-17 11:01
📄 wctype.h /* Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / / * ISO C99 Standard: 7.25 * Wide character classification and mapping utilities <wctype.h> / #ifndef _WCTYPE_H #define _WCTYPE_H 1 #include <features.h> #include <bits/types.h> #include <bits/types/wint_t.h> / Constant expression of type `wint_t' whose value does not correspond to any member of the extended character set. / #ifndef WEOF # define WEOF (0xffffffffu) #endif / Some definitions from this header also appear in <wchar.h> in Unix98 mode. / #include <bits/wctype-wchar.h> / * Extensible wide-character mapping functions: 7.15.3.2. / __BEGIN_DECLS / Scalar type that can hold values which represent locale-specific character mappings. / typedef const __int32_t wctrans_t; /* Construct value that describes a mapping between wide characters identified by the string argument PROPERTY. / extern wctrans_t wctrans (const char __property) __THROW; /* Map the wide character WC using the mapping described by DESC. / extern wint_t towctrans (wint_t __wc, wctrans_t __desc) __THROW; # ifdef __USE_XOPEN2K8 / POSIX.1-2008 extended locale interface (see locale.h). / # include <bits/types/locale_t.h> / Test for any wide character for which `iswalpha' or `iswdigit' is true. / extern int iswalnum_l (wint_t __wc, locale_t __locale) __THROW; / Test for any wide character for which `iswupper' or 'iswlower' is true, or any wide character that is one of a locale-specific set of wide-characters for which none of `iswcntrl', `iswdigit', `iswpunct', or `iswspace' is true. / extern int iswalpha_l (wint_t __wc, locale_t __locale) __THROW; / Test for any control wide character. / extern int iswcntrl_l (wint_t __wc, locale_t __locale) __THROW; / Test for any wide character that corresponds to a decimal-digit character. / extern int iswdigit_l (wint_t __wc, locale_t __locale) __THROW; / Test for any wide character for which `iswprint' is true and `iswspace' is false. / extern int iswgraph_l (wint_t __wc, locale_t __locale) __THROW; / Test for any wide character that corresponds to a lowercase letter or is one of a locale-specific set of wide characters for which none of `iswcntrl', `iswdigit', `iswpunct', or `iswspace' is true. / extern int iswlower_l (wint_t __wc, locale_t __locale) __THROW; / Test for any printing wide character. / extern int iswprint_l (wint_t __wc, locale_t __locale) __THROW; / Test for any printing wide character that is one of a locale-specific et of wide characters for which neither `iswspace' nor `iswalnum' is true. / extern int iswpunct_l (wint_t __wc, locale_t __locale) __THROW; / Test for any wide character that corresponds to a locale-specific set of wide characters for which none of `iswalnum', `iswgraph', or `iswpunct' is true. / extern int iswspace_l (wint_t __wc, locale_t __locale) __THROW; / Test for any wide character that corresponds to an uppercase letter or is one of a locale-specific set of wide character for which none of `iswcntrl', `iswdigit', `iswpunct', or `iswspace' is true. / extern int iswupper_l (wint_t __wc, locale_t __locale) __THROW; / Test for any wide character that corresponds to a hexadecimal-digit character equivalent to that performed be the functions described in the previous subclause. / extern int iswxdigit_l (wint_t __wc, locale_t __locale) __THROW; / Test for any wide character that corresponds to a standard blank wide character or a locale-specific set of wide characters for which `iswalnum' is false. / extern int iswblank_l (wint_t __wc, locale_t __locale) __THROW; / Construct value that describes a class of wide characters identified by the string argument PROPERTY. / extern wctype_t wctype_l (const char __property, locale_t __locale) __THROW; /* Determine whether the wide-character WC has the property described by DESC. / extern int iswctype_l (wint_t __wc, wctype_t __desc, locale_t __locale) __THROW; / * Wide-character case-mapping functions. / / Converts an uppercase letter to the corresponding lowercase letter. / extern wint_t towlower_l (wint_t __wc, locale_t __locale) __THROW; / Converts an lowercase letter to the corresponding uppercase letter. / extern wint_t towupper_l (wint_t __wc, locale_t __locale) __THROW; / Construct value that describes a mapping between wide characters identified by the string argument PROPERTY. / extern wctrans_t wctrans_l (const char __property, locale_t __locale) __THROW; /* Map the wide character WC using the mapping described by DESC. / extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc, locale_t __locale) __THROW; # endif / Use POSIX 2008. / __END_DECLS #endif / wctype.h */	5.42 KB	2026-02-17 11:01
📄 wordexp.h /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. / #ifndef _WORDEXP_H #define _WORDEXP_H 1 #include <features.h> #define __need_size_t #include <stddef.h> __BEGIN_DECLS / Bits set in the FLAGS argument to `wordexp'. / enum { WRDE_DOOFFS = (1 << 0), / Insert PWORDEXP->we_offs NULLs. / WRDE_APPEND = (1 << 1), / Append to results of a previous call. / WRDE_NOCMD = (1 << 2), / Don't do command substitution. / WRDE_REUSE = (1 << 3), / Reuse storage in PWORDEXP. / WRDE_SHOWERR = (1 << 4), / Don't redirect stderr to /dev/null. / WRDE_UNDEF = (1 << 5), / Error for expanding undefined variables. / __WRDE_FLAGS = (WRDE_DOOFFS \| WRDE_APPEND \| WRDE_NOCMD \| WRDE_REUSE \| WRDE_SHOWERR \| WRDE_UNDEF) }; / Structure describing a word-expansion run. / typedef struct { size_t we_wordc; / Count of words matched. / char we_wordv; / List of expanded words. / size_t we_offs; / Slots to reserve in `we_wordv'. / } wordexp_t; / Possible nonzero return values from `wordexp'. / enum { #ifdef __USE_XOPEN WRDE_NOSYS = -1, / Never used since we support `wordexp'. / #endif WRDE_NOSPACE = 1, / Ran out of memory. / WRDE_BADCHAR, / A metachar appears in the wrong place. / WRDE_BADVAL, / Undefined var reference with WRDE_UNDEF. / WRDE_CMDSUB, / Command substitution with WRDE_NOCMD. / WRDE_SYNTAX / Shell syntax error. / }; / Do word expansion of WORDS into PWORDEXP. / extern int wordexp (const char __restrict __words, wordexp_t __restrict __pwordexp, int __flags); / Free the storage allocated by a `wordexp' call. / extern void wordfree (wordexp_t __wordexp) __THROW; __END_DECLS #endif /* wordexp.h */	2.44 KB	2026-02-17 11:01
📁 xen	-	2026-03-27 02:43
📄 zconf.h /* zconf.h -- configuration of the zlib compression library * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler * For conditions of distribution and use, see copyright notice in zlib.h / / @(#) $Id$ / #ifndef ZCONF_H #define ZCONF_H / * If you really need a unique prefix for all types and library functions, * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. * Even better than compiling with -DZ_PREFIX would be to use configure to set * this permanently in zconf.h using "./configure --zprefix". / #ifdef Z_PREFIX / may be set to #if 1 by ./configure / # define Z_PREFIX_SET / all linked symbols and init macros / # define _dist_code z__dist_code # define _length_code z__length_code # define _tr_align z__tr_align # define _tr_flush_bits z__tr_flush_bits # define _tr_flush_block z__tr_flush_block # define _tr_init z__tr_init # define _tr_stored_block z__tr_stored_block # define _tr_tally z__tr_tally # define adler32 z_adler32 # define adler32_combine z_adler32_combine # define adler32_combine64 z_adler32_combine64 # define adler32_z z_adler32_z # ifndef Z_SOLO # define compress z_compress # define compress2 z_compress2 # define compressBound z_compressBound # endif # define crc32 z_crc32 # define crc32_combine z_crc32_combine # define crc32_combine64 z_crc32_combine64 # define crc32_z z_crc32_z # define deflate z_deflate # define deflateBound z_deflateBound # define deflateCopy z_deflateCopy # define deflateEnd z_deflateEnd # define deflateGetDictionary z_deflateGetDictionary # define deflateInit z_deflateInit # define deflateInit2 z_deflateInit2 # define deflateInit2_ z_deflateInit2_ # define deflateInit_ z_deflateInit_ # define deflateParams z_deflateParams # define deflatePending z_deflatePending # define deflatePrime z_deflatePrime # define deflateReset z_deflateReset # define deflateResetKeep z_deflateResetKeep # define deflateSetDictionary z_deflateSetDictionary # define deflateSetHeader z_deflateSetHeader # define deflateTune z_deflateTune # define deflate_copyright z_deflate_copyright # define get_crc_table z_get_crc_table # ifndef Z_SOLO # define gz_error z_gz_error # define gz_intmax z_gz_intmax # define gz_strwinerror z_gz_strwinerror # define gzbuffer z_gzbuffer # define gzclearerr z_gzclearerr # define gzclose z_gzclose # define gzclose_r z_gzclose_r # define gzclose_w z_gzclose_w # define gzdirect z_gzdirect # define gzdopen z_gzdopen # define gzeof z_gzeof # define gzerror z_gzerror # define gzflush z_gzflush # define gzfread z_gzfread # define gzfwrite z_gzfwrite # define gzgetc z_gzgetc # define gzgetc_ z_gzgetc_ # define gzgets z_gzgets # define gzoffset z_gzoffset # define gzoffset64 z_gzoffset64 # define gzopen z_gzopen # define gzopen64 z_gzopen64 # ifdef _WIN32 # define gzopen_w z_gzopen_w # endif # define gzprintf z_gzprintf # define gzputc z_gzputc # define gzputs z_gzputs # define gzread z_gzread # define gzrewind z_gzrewind # define gzseek z_gzseek # define gzseek64 z_gzseek64 # define gzsetparams z_gzsetparams # define gztell z_gztell # define gztell64 z_gztell64 # define gzungetc z_gzungetc # define gzvprintf z_gzvprintf # define gzwrite z_gzwrite # endif # define inflate z_inflate # define inflateBack z_inflateBack # define inflateBackEnd z_inflateBackEnd # define inflateBackInit z_inflateBackInit # define inflateBackInit_ z_inflateBackInit_ # define inflateCodesUsed z_inflateCodesUsed # define inflateCopy z_inflateCopy # define inflateEnd z_inflateEnd # define inflateGetDictionary z_inflateGetDictionary # define inflateGetHeader z_inflateGetHeader # define inflateInit z_inflateInit # define inflateInit2 z_inflateInit2 # define inflateInit2_ z_inflateInit2_ # define inflateInit_ z_inflateInit_ # define inflateMark z_inflateMark # define inflatePrime z_inflatePrime # define inflateReset z_inflateReset # define inflateReset2 z_inflateReset2 # define inflateResetKeep z_inflateResetKeep # define inflateSetDictionary z_inflateSetDictionary # define inflateSync z_inflateSync # define inflateSyncPoint z_inflateSyncPoint # define inflateUndermine z_inflateUndermine # define inflateValidate z_inflateValidate # define inflate_copyright z_inflate_copyright # define inflate_fast z_inflate_fast # define inflate_table z_inflate_table # ifndef Z_SOLO # define uncompress z_uncompress # define uncompress2 z_uncompress2 # endif # define zError z_zError # ifndef Z_SOLO # define zcalloc z_zcalloc # define zcfree z_zcfree # endif # define zlibCompileFlags z_zlibCompileFlags # define zlibVersion z_zlibVersion / all zlib typedefs in zlib.h and zconf.h / # define Byte z_Byte # define Bytef z_Bytef # define alloc_func z_alloc_func # define charf z_charf # define free_func z_free_func # ifndef Z_SOLO # define gzFile z_gzFile # endif # define gz_header z_gz_header # define gz_headerp z_gz_headerp # define in_func z_in_func # define intf z_intf # define out_func z_out_func # define uInt z_uInt # define uIntf z_uIntf # define uLong z_uLong # define uLongf z_uLongf # define voidp z_voidp # define voidpc z_voidpc # define voidpf z_voidpf / all zlib structs in zlib.h and zconf.h / # define gz_header_s z_gz_header_s # define internal_state z_internal_state #endif #if defined(__MSDOS__) && !defined(MSDOS) # define MSDOS #endif #if (defined(OS_2) \|\| defined(__OS2__)) && !defined(OS2) # define OS2 #endif #if defined(_WINDOWS) && !defined(WINDOWS) # define WINDOWS #endif #if defined(_WIN32) \|\| defined(_WIN32_WCE) \|\| defined(__WIN32__) # ifndef WIN32 # define WIN32 # endif #endif #if (defined(MSDOS) \|\| defined(OS2) \|\| defined(WINDOWS)) && !defined(WIN32) # if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) # ifndef SYS16BIT # define SYS16BIT # endif # endif #endif / * Compile with -DMAXSEG_64K if the alloc function cannot allocate more * than 64k bytes at a time (needed on systems with 16-bit int). / #ifdef SYS16BIT # define MAXSEG_64K #endif #ifdef MSDOS # define UNALIGNED_OK #endif #ifdef __STDC_VERSION__ # ifndef STDC # define STDC # endif # if __STDC_VERSION__ >= 199901L # ifndef STDC99 # define STDC99 # endif # endif #endif #if !defined(STDC) && (defined(__STDC__) \|\| defined(__cplusplus)) # define STDC #endif #if !defined(STDC) && (defined(__GNUC__) \|\| defined(__BORLANDC__)) # define STDC #endif #if !defined(STDC) && (defined(MSDOS) \|\| defined(WINDOWS) \|\| defined(WIN32)) # define STDC #endif #if !defined(STDC) && (defined(OS2) \|\| defined(__HOS_AIX__)) # define STDC #endif #if defined(__OS400__) && !defined(STDC) / iSeries (formerly AS/400). / # define STDC #endif #ifndef STDC # ifndef const / cannot use !defined(STDC) && !defined(const) on Mac / # define const / note: need a more gentle solution here / # endif #endif #if defined(ZLIB_CONST) && !defined(z_const) # define z_const const #else # define z_const #endif #ifdef Z_SOLO typedef unsigned long z_size_t; #else # define z_longlong long long # if defined(NO_SIZE_T) typedef unsigned NO_SIZE_T z_size_t; # elif defined(STDC) # include <stddef.h> typedef size_t z_size_t; # else typedef unsigned long z_size_t; # endif # undef z_longlong #endif / Maximum value for memLevel in deflateInit2 / #ifndef MAX_MEM_LEVEL # ifdef MAXSEG_64K # define MAX_MEM_LEVEL 8 # else # define MAX_MEM_LEVEL 9 # endif #endif / Maximum value for windowBits in deflateInit2 and inflateInit2. * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files * created by gzip. (Files created by minigzip can still be extracted by * gzip.) / #ifndef MAX_WBITS # define MAX_WBITS 15 / 32K LZ77 window / #endif / The memory requirements for deflate are (in bytes): (1 << (windowBits+2)) + (1 << (memLevel+9)) that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) plus a few kilobytes for small objects. For example, if you want to reduce the default memory requirements from 256K to 128K, compile with make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" Of course this will generally degrade compression (there's no free lunch). The memory requirements for inflate are (in bytes) 1 << windowBits that is, 32K for windowBits=15 (default value) plus about 7 kilobytes for small objects. / / Type declarations / #ifndef OF / function prototypes / # ifdef STDC # define OF(args) args # else # define OF(args) () # endif #endif #ifndef Z_ARG / function prototypes for stdarg / # if defined(STDC) \|\| defined(Z_HAVE_STDARG_H) # define Z_ARG(args) args # else # define Z_ARG(args) () # endif #endif / The following definitions for FAR are needed only for MSDOS mixed * model programming (small or medium model with some far allocations). * This was tested only with MSC; for other MSDOS compilers you may have * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, * just define FAR to be empty. / #ifdef SYS16BIT # if defined(M_I86SM) \|\| defined(M_I86MM) / MSC small or medium model / # define SMALL_MEDIUM # ifdef _MSC_VER # define FAR _far # else # define FAR far # endif # endif # if (defined(__SMALL__) \|\| defined(__MEDIUM__)) / Turbo C small or medium model / # define SMALL_MEDIUM # ifdef __BORLANDC__ # define FAR _far # else # define FAR far # endif # endif #endif #if defined(WINDOWS) \|\| defined(WIN32) / If building or using zlib as a DLL, define ZLIB_DLL. * This is not mandatory, but it offers a little performance increase. / # ifdef ZLIB_DLL # if defined(WIN32) && (!defined(__BORLANDC__) \|\| (__BORLANDC__ >= 0x500)) # ifdef ZLIB_INTERNAL # define ZEXTERN extern __declspec(dllexport) # else # define ZEXTERN extern __declspec(dllimport) # endif # endif # endif / ZLIB_DLL / / If building or using zlib with the WINAPI/WINAPIV calling convention, * define ZLIB_WINAPI. * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. / # ifdef ZLIB_WINAPI # ifdef FAR # undef FAR # endif # include <windows.h> / No need for _export, use ZLIB.DEF instead. / / For complete Windows compatibility, use WINAPI, not __stdcall. / # define ZEXPORT WINAPI # ifdef WIN32 # define ZEXPORTVA WINAPIV # else # define ZEXPORTVA FAR CDECL # endif # endif #endif #if defined (__BEOS__) # ifdef ZLIB_DLL # ifdef ZLIB_INTERNAL # define ZEXPORT __declspec(dllexport) # define ZEXPORTVA __declspec(dllexport) # else # define ZEXPORT __declspec(dllimport) # define ZEXPORTVA __declspec(dllimport) # endif # endif #endif #ifndef ZEXTERN # define ZEXTERN extern #endif #ifndef ZEXPORT # define ZEXPORT #endif #ifndef ZEXPORTVA # define ZEXPORTVA #endif #ifndef FAR # define FAR #endif #if !defined(__MACTYPES__) typedef unsigned char Byte; / 8 bits / #endif typedef unsigned int uInt; / 16 bits or more / typedef unsigned long uLong; / 32 bits or more / #ifdef SMALL_MEDIUM / Borland C/C++ and some old MSC versions ignore FAR inside typedef / # define Bytef Byte FAR #else typedef Byte FAR Bytef; #endif typedef char FAR charf; typedef int FAR intf; typedef uInt FAR uIntf; typedef uLong FAR uLongf; #ifdef STDC typedef void const voidpc; typedef void FAR voidpf; typedef void voidp; #else typedef Byte const voidpc; typedef Byte FAR voidpf; typedef Byte voidp; #endif #if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC) # include <limits.h> # if (UINT_MAX == 0xffffffffUL) # define Z_U4 unsigned # elif (ULONG_MAX == 0xffffffffUL) # define Z_U4 unsigned long # elif (USHRT_MAX == 0xffffffffUL) # define Z_U4 unsigned short # endif #endif #ifdef Z_U4 typedef Z_U4 z_crc_t; #else typedef unsigned long z_crc_t; #endif #if 1 / was set to #if 1 by ./configure / # define Z_HAVE_UNISTD_H #endif #if 1 / was set to #if 1 by ./configure / # define Z_HAVE_STDARG_H #endif #ifdef STDC # ifndef Z_SOLO # include <sys/types.h> / for off_t / # endif #endif #if defined(STDC) \|\| defined(Z_HAVE_STDARG_H) # ifndef Z_SOLO # include <stdarg.h> / for va_list / # endif #endif #ifdef _WIN32 # ifndef Z_SOLO # include <stddef.h> / for wchar_t / # endif #endif / a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even * though the former does not conform to the LFS document), but considering * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as * equivalently requesting no 64-bit operations / #if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1 # undef _LARGEFILE64_SOURCE #endif #if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H) # define Z_HAVE_UNISTD_H #endif #ifndef Z_SOLO # if defined(Z_HAVE_UNISTD_H) \|\| defined(_LARGEFILE64_SOURCE) # include <unistd.h> / for SEEK_, off_t, and _LFS64_LARGEFILE / # ifdef VMS # include <unixio.h> /* for off_t / # endif # ifndef z_off_t # define z_off_t off_t # endif # endif #endif #if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0 # define Z_LFS64 #endif #if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64) # define Z_LARGE64 #endif #if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64) # define Z_WANT64 #endif #if !defined(SEEK_SET) && !defined(Z_SOLO) # define SEEK_SET 0 / Seek from beginning of file. / # define SEEK_CUR 1 / Seek from current position. / # define SEEK_END 2 / Set file pointer to EOF plus "offset" / #endif #ifndef z_off_t # define z_off_t long #endif #if !defined(_WIN32) && defined(Z_LARGE64) # define z_off64_t off64_t #else # if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO) # define z_off64_t __int64 # else # define z_off64_t z_off_t # endif #endif / MVS linker does not support external names larger than 8 bytes / #if defined(__MVS__) #pragma map(deflateInit_,"DEIN") #pragma map(deflateInit2_,"DEIN2") #pragma map(deflateEnd,"DEEND") #pragma map(deflateBound,"DEBND") #pragma map(inflateInit_,"ININ") #pragma map(inflateInit2_,"ININ2") #pragma map(inflateEnd,"INEND") #pragma map(inflateSync,"INSY") #pragma map(inflateSetDictionary,"INSEDI") #pragma map(compressBound,"CMBND") #pragma map(inflate_table,"INTABL") #pragma map(inflate_fast,"INFA") #pragma map(inflate_copyright,"INCOPY") #endif #endif / ZCONF_H */	15.88 KB	2023-09-26 09:22
📄 zdict.h /* * Copyright (c) Meta Platforms, Inc. and affiliates. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. / #if defined (__cplusplus) extern "C" { #endif #ifndef ZSTD_ZDICT_H #define ZSTD_ZDICT_H /====== Dependencies ======/ #include <stddef.h> / size_t / / ===== ZDICTLIB_API : control library symbols visibility ===== / #ifndef ZDICTLIB_VISIBLE / Backwards compatibility with old macro name / # ifdef ZDICTLIB_VISIBILITY # define ZDICTLIB_VISIBLE ZDICTLIB_VISIBILITY # elif defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__) # define ZDICTLIB_VISIBLE __attribute__ ((visibility ("default"))) # else # define ZDICTLIB_VISIBLE # endif #endif #ifndef ZDICTLIB_HIDDEN # if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__) # define ZDICTLIB_HIDDEN __attribute__ ((visibility ("hidden"))) # else # define ZDICTLIB_HIDDEN # endif #endif #if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1) # define ZDICTLIB_API __declspec(dllexport) ZDICTLIB_VISIBLE #elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1) # define ZDICTLIB_API __declspec(dllimport) ZDICTLIB_VISIBLE / It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump./ #else # define ZDICTLIB_API ZDICTLIB_VISIBLE #endif /****************************************************************************** * Zstd dictionary builder * * FAQ * === * Why should I use a dictionary? * ------------------------------ * * Zstd can use dictionaries to improve compression ratio of small data. * Traditionally small files don't compress well because there is very little * repetition in a single sample, since it is small. But, if you are compressing * many similar files, like a bunch of JSON records that share the same * structure, you can train a dictionary on ahead of time on some samples of * these files. Then, zstd can use the dictionary to find repetitions that are * present across samples. This can vastly improve compression ratio. * * When is a dictionary useful? * ---------------------------- * * Dictionaries are useful when compressing many small files that are similar. * The larger a file is, the less benefit a dictionary will have. Generally, * we don't expect dictionary compression to be effective past 100KB. And the * smaller a file is, the more we would expect the dictionary to help. * * How do I use a dictionary? * -------------------------- * * Simply pass the dictionary to the zstd compressor with * `ZSTD_CCtx_loadDictionary()`. The same dictionary must then be passed to * the decompressor, using `ZSTD_DCtx_loadDictionary()`. There are other * more advanced functions that allow selecting some options, see zstd.h for * complete documentation. * * What is a zstd dictionary? * -------------------------- * * A zstd dictionary has two pieces: Its header, and its content. The header * contains a magic number, the dictionary ID, and entropy tables. These * entropy tables allow zstd to save on header costs in the compressed file, * which really matters for small data. The content is just bytes, which are * repeated content that is common across many samples. * * What is a raw content dictionary? * --------------------------------- * * A raw content dictionary is just bytes. It doesn't have a zstd dictionary * header, a dictionary ID, or entropy tables. Any buffer is a valid raw * content dictionary. * * How do I train a dictionary? * ---------------------------- * * Gather samples from your use case. These samples should be similar to each * other. If you have several use cases, you could try to train one dictionary * per use case. * * Pass those samples to `ZDICT_trainFromBuffer()` and that will train your * dictionary. There are a few advanced versions of this function, but this * is a great starting point. If you want to further tune your dictionary * you could try `ZDICT_optimizeTrainFromBuffer_cover()`. If that is too slow * you can try `ZDICT_optimizeTrainFromBuffer_fastCover()`. * * If the dictionary training function fails, that is likely because you * either passed too few samples, or a dictionary would not be effective * for your data. Look at the messages that the dictionary trainer printed, * if it doesn't say too few samples, then a dictionary would not be effective. * * How large should my dictionary be? * ---------------------------------- * * A reasonable dictionary size, the `dictBufferCapacity`, is about 100KB. * The zstd CLI defaults to a 110KB dictionary. You likely don't need a * dictionary larger than that. But, most use cases can get away with a * smaller dictionary. The advanced dictionary builders can automatically * shrink the dictionary for you, and select the smallest size that doesn't * hurt compression ratio too much. See the `shrinkDict` parameter. * A smaller dictionary can save memory, and potentially speed up * compression. * * How many samples should I provide to the dictionary builder? * ------------------------------------------------------------ * * We generally recommend passing ~100x the size of the dictionary * in samples. A few thousand should suffice. Having too few samples * can hurt the dictionaries effectiveness. Having more samples will * only improve the dictionaries effectiveness. But having too many * samples can slow down the dictionary builder. * * How do I determine if a dictionary will be effective? * ----------------------------------------------------- * * Simply train a dictionary and try it out. You can use zstd's built in * benchmarking tool to test the dictionary effectiveness. * * # Benchmark levels 1-3 without a dictionary * zstd -b1e3 -r /path/to/my/files * # Benchmark levels 1-3 with a dictionary * zstd -b1e3 -r /path/to/my/files -D /path/to/my/dictionary * * When should I retrain a dictionary? * ----------------------------------- * * You should retrain a dictionary when its effectiveness drops. Dictionary * effectiveness drops as the data you are compressing changes. Generally, we do * expect dictionaries to "decay" over time, as your data changes, but the rate * at which they decay depends on your use case. Internally, we regularly * retrain dictionaries, and if the new dictionary performs significantly * better than the old dictionary, we will ship the new dictionary. * * I have a raw content dictionary, how do I turn it into a zstd dictionary? * ------------------------------------------------------------------------- * * If you have a raw content dictionary, e.g. by manually constructing it, or * using a third-party dictionary builder, you can turn it into a zstd * dictionary by using `ZDICT_finalizeDictionary()`. You'll also have to * provide some samples of the data. It will add the zstd header to the * raw content, which contains a dictionary ID and entropy tables, which * will improve compression ratio, and allow zstd to write the dictionary ID * into the frame, if you so choose. * * Do I have to use zstd's dictionary builder? * ------------------------------------------- * * No! You can construct dictionary content however you please, it is just * bytes. It will always be valid as a raw content dictionary. If you want * a zstd dictionary, which can improve compression ratio, use * `ZDICT_finalizeDictionary()`. * * What is the attack surface of a zstd dictionary? * ------------------------------------------------ * * Zstd is heavily fuzz tested, including loading fuzzed dictionaries, so * zstd should never crash, or access out-of-bounds memory no matter what * the dictionary is. However, if an attacker can control the dictionary * during decompression, they can cause zstd to generate arbitrary bytes, * just like if they controlled the compressed data. * *****************************************************************************/ /! ZDICT_trainFromBuffer(): * Train a dictionary from an array of samples. * Redirect towards ZDICT_optimizeTrainFromBuffer_fastCover() single-threaded, with d=8, steps=4, * f=20, and accel=1. * Samples must be stored concatenated in a single flat buffer `samplesBuffer`, * supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order. * The resulting dictionary will be saved into `dictBuffer`. * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`) * or an error code, which can be tested with ZDICT_isError(). * Note: Dictionary training will fail if there are not enough samples to construct a * dictionary, or if most of the samples are too small (< 8 bytes being the lower limit). * If dictionary training fails, you should use zstd without a dictionary, as the dictionary * would've been ineffective anyways. If you believe your samples would benefit from a dictionary * please open an issue with details, and we can look into it. * Note: ZDICT_trainFromBuffer()'s memory usage is about 6 MB. * Tips: In general, a reasonable dictionary has a size of ~ 100 KB. * It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`. * In general, it's recommended to provide a few thousands samples, though this can vary a lot. * It's recommended that total size of all samples be about ~x100 times the target size of dictionary. / ZDICTLIB_API size_t ZDICT_trainFromBuffer(void dictBuffer, size_t dictBufferCapacity, const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples); typedef struct { int compressionLevel; /*< optimize for a specific zstd compression level; 0 means default / unsigned notificationLevel; /*< Write log to stderr; 0 = none (default); 1 = errors; 2 = progression; 3 = details; 4 = debug; / unsigned dictID; /*< force dictID value; 0 means auto mode (32-bits random value) NOTE: The zstd format reserves some dictionary IDs for future use. * You may use them in private settings, but be warned that they * may be used by zstd in a public dictionary registry in the future. * These dictionary IDs are: * - low range : <= 32767 * - high range : >= (2^31) / } ZDICT_params_t; /! ZDICT_finalizeDictionary(): * Given a custom content as a basis for dictionary, and a set of samples, * finalize dictionary by adding headers and statistics according to the zstd * dictionary format. * * Samples must be stored concatenated in a flat buffer `samplesBuffer`, * supplied with an array of sizes `samplesSizes`, providing the size of each * sample in order. The samples are used to construct the statistics, so they * should be representative of what you will compress with this dictionary. * * The compression level can be set in `parameters`. You should pass the * compression level you expect to use in production. The statistics for each * compression level differ, so tuning the dictionary for the compression level * can help quite a bit. * * You can set an explicit dictionary ID in `parameters`, or allow us to pick * a random dictionary ID for you, but we can't guarantee no collisions. * * The dstDictBuffer and the dictContent may overlap, and the content will be * appended to the end of the header. If the header + the content doesn't fit in * maxDictSize the beginning of the content is truncated to make room, since it * is presumed that the most profitable content is at the end of the dictionary, * since that is the cheapest to reference. * * `maxDictSize` must be >= max(dictContentSize, ZSTD_DICTSIZE_MIN). * * @return: size of dictionary stored into `dstDictBuffer` (<= `maxDictSize`), * or an error code, which can be tested by ZDICT_isError(). * Note: ZDICT_finalizeDictionary() will push notifications into stderr if * instructed to, using notificationLevel>0. * NOTE: This function currently may fail in several edge cases including: * * Not enough samples * * Samples are uncompressible * * Samples are all exactly the same / ZDICTLIB_API size_t ZDICT_finalizeDictionary(void dstDictBuffer, size_t maxDictSize, const void* dictContent, size_t dictContentSize, const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples, ZDICT_params_t parameters); /====== Helper functions ======/ ZDICTLIB_API unsigned ZDICT_getDictID(const void* dictBuffer, size_t dictSize); /*< extracts dictID; @return zero if error (not a valid dictionary) / ZDICTLIB_API size_t ZDICT_getDictHeaderSize(const void* dictBuffer, size_t dictSize); /* returns dict header size; returns a ZSTD error code on failure / ZDICTLIB_API unsigned ZDICT_isError(size_t errorCode); ZDICTLIB_API const char ZDICT_getErrorName(size_t errorCode); #endif /* ZSTD_ZDICT_H / #if defined(ZDICT_STATIC_LINKING_ONLY) && !defined(ZSTD_ZDICT_H_STATIC) #define ZSTD_ZDICT_H_STATIC / This can be overridden externally to hide static symbols. / #ifndef ZDICTLIB_STATIC_API # if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1) # define ZDICTLIB_STATIC_API __declspec(dllexport) ZDICTLIB_VISIBLE # elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1) # define ZDICTLIB_STATIC_API __declspec(dllimport) ZDICTLIB_VISIBLE # else # define ZDICTLIB_STATIC_API ZDICTLIB_VISIBLE # endif #endif / ==================================================================================== * The definitions in this section are considered experimental. * They should never be used with a dynamic library, as they may change in the future. * They are provided for advanced usages. * Use them only in association with static linking. * ==================================================================================== / #define ZDICT_DICTSIZE_MIN 256 / Deprecated: Remove in v1.6.0 / #define ZDICT_CONTENTSIZE_MIN 128 /! ZDICT_cover_params_t: * k and d are the only required parameters. * For others, value 0 means default. / typedef struct { unsigned k; / Segment size : constraint: 0 < k : Reasonable range [16, 2048+] / unsigned d; / dmer size : constraint: 0 < d <= k : Reasonable range [6, 16] / unsigned steps; / Number of steps : Only used for optimization : 0 means default (40) : Higher means more parameters checked / unsigned nbThreads; / Number of threads : constraint: 0 < nbThreads : 1 means single-threaded : Only used for optimization : Ignored if ZSTD_MULTITHREAD is not defined / double splitPoint; / Percentage of samples used for training: Only used for optimization : the first nbSamples * splitPoint samples will be used to training, the last nbSamples * (1 - splitPoint) samples will be used for testing, 0 means default (1.0), 1.0 when all samples are used for both training and testing / unsigned shrinkDict; / Train dictionaries to shrink in size starting from the minimum size and selects the smallest dictionary that is shrinkDictMaxRegression% worse than the largest dictionary. 0 means no shrinking and 1 means shrinking / unsigned shrinkDictMaxRegression; / Sets shrinkDictMaxRegression so that a smaller dictionary can be at worse shrinkDictMaxRegression% worse than the max dict size dictionary. / ZDICT_params_t zParams; } ZDICT_cover_params_t; typedef struct { unsigned k; / Segment size : constraint: 0 < k : Reasonable range [16, 2048+] / unsigned d; / dmer size : constraint: 0 < d <= k : Reasonable range [6, 16] / unsigned f; / log of size of frequency array : constraint: 0 < f <= 31 : 1 means default(20)/ unsigned steps; / Number of steps : Only used for optimization : 0 means default (40) : Higher means more parameters checked / unsigned nbThreads; / Number of threads : constraint: 0 < nbThreads : 1 means single-threaded : Only used for optimization : Ignored if ZSTD_MULTITHREAD is not defined / double splitPoint; / Percentage of samples used for training: Only used for optimization : the first nbSamples * splitPoint samples will be used to training, the last nbSamples * (1 - splitPoint) samples will be used for testing, 0 means default (0.75), 1.0 when all samples are used for both training and testing / unsigned accel; / Acceleration level: constraint: 0 < accel <= 10, higher means faster and less accurate, 0 means default(1) / unsigned shrinkDict; / Train dictionaries to shrink in size starting from the minimum size and selects the smallest dictionary that is shrinkDictMaxRegression% worse than the largest dictionary. 0 means no shrinking and 1 means shrinking / unsigned shrinkDictMaxRegression; / Sets shrinkDictMaxRegression so that a smaller dictionary can be at worse shrinkDictMaxRegression% worse than the max dict size dictionary. / ZDICT_params_t zParams; } ZDICT_fastCover_params_t; /! ZDICT_trainFromBuffer_cover(): * Train a dictionary from an array of samples using the COVER algorithm. * Samples must be stored concatenated in a single flat buffer `samplesBuffer`, * supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order. * The resulting dictionary will be saved into `dictBuffer`. * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`) * or an error code, which can be tested with ZDICT_isError(). * See ZDICT_trainFromBuffer() for details on failure modes. * Note: ZDICT_trainFromBuffer_cover() requires about 9 bytes of memory for each input byte. * Tips: In general, a reasonable dictionary has a size of ~ 100 KB. * It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`. * In general, it's recommended to provide a few thousands samples, though this can vary a lot. * It's recommended that total size of all samples be about ~x100 times the target size of dictionary. / ZDICTLIB_STATIC_API size_t ZDICT_trainFromBuffer_cover( void dictBuffer, size_t dictBufferCapacity, const void samplesBuffer, const size_t samplesSizes, unsigned nbSamples, ZDICT_cover_params_t parameters); /! ZDICT_optimizeTrainFromBuffer_cover(): The same requirements as above hold for all the parameters except `parameters`. * This function tries many parameter combinations and picks the best parameters. * `parameters` is filled with the best parameters found, dictionary constructed with those parameters is stored in `dictBuffer`. * * All of the parameters d, k, steps are optional. * If d is non-zero then we don't check multiple values of d, otherwise we check d = {6, 8}. * if steps is zero it defaults to its default value. * If k is non-zero then we don't check multiple values of k, otherwise we check steps values in [50, 2000]. * * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`) * or an error code, which can be tested with ZDICT_isError(). * On success `parameters` contains the parameters selected. See ZDICT_trainFromBuffer() for details on failure modes. * Note: ZDICT_optimizeTrainFromBuffer_cover() requires about 8 bytes of memory for each input byte and additionally another 5 bytes of memory for each byte of memory for each thread. / ZDICTLIB_STATIC_API size_t ZDICT_optimizeTrainFromBuffer_cover( void dictBuffer, size_t dictBufferCapacity, const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples, ZDICT_cover_params_t* parameters); /! ZDICT_trainFromBuffer_fastCover(): Train a dictionary from an array of samples using a modified version of COVER algorithm. * Samples must be stored concatenated in a single flat buffer `samplesBuffer`, * supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order. * d and k are required. * All other parameters are optional, will use default values if not provided * The resulting dictionary will be saved into `dictBuffer`. * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`) * or an error code, which can be tested with ZDICT_isError(). * See ZDICT_trainFromBuffer() for details on failure modes. * Note: ZDICT_trainFromBuffer_fastCover() requires 6 * 2^f bytes of memory. * Tips: In general, a reasonable dictionary has a size of ~ 100 KB. * It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`. * In general, it's recommended to provide a few thousands samples, though this can vary a lot. * It's recommended that total size of all samples be about ~x100 times the target size of dictionary. / ZDICTLIB_STATIC_API size_t ZDICT_trainFromBuffer_fastCover(void dictBuffer, size_t dictBufferCapacity, const void samplesBuffer, const size_t samplesSizes, unsigned nbSamples, ZDICT_fastCover_params_t parameters); /! ZDICT_optimizeTrainFromBuffer_fastCover(): The same requirements as above hold for all the parameters except `parameters`. * This function tries many parameter combinations (specifically, k and d combinations) * and picks the best parameters. `parameters` is filled with the best parameters found, dictionary constructed with those parameters is stored in `dictBuffer`. * All of the parameters d, k, steps, f, and accel are optional. * If d is non-zero then we don't check multiple values of d, otherwise we check d = {6, 8}. * if steps is zero it defaults to its default value. * If k is non-zero then we don't check multiple values of k, otherwise we check steps values in [50, 2000]. * If f is zero, default value of 20 is used. * If accel is zero, default value of 1 is used. * * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`) * or an error code, which can be tested with ZDICT_isError(). * On success `parameters` contains the parameters selected. See ZDICT_trainFromBuffer() for details on failure modes. * Note: ZDICT_optimizeTrainFromBuffer_fastCover() requires about 6 * 2^f bytes of memory for each thread. / ZDICTLIB_STATIC_API size_t ZDICT_optimizeTrainFromBuffer_fastCover(void dictBuffer, size_t dictBufferCapacity, const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples, ZDICT_fastCover_params_t* parameters); typedef struct { unsigned selectivityLevel; /* 0 means default; larger => select more => larger dictionary / ZDICT_params_t zParams; } ZDICT_legacy_params_t; /! ZDICT_trainFromBuffer_legacy(): * Train a dictionary from an array of samples. * Samples must be stored concatenated in a single flat buffer `samplesBuffer`, * supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order. * The resulting dictionary will be saved into `dictBuffer`. * `parameters` is optional and can be provided with values set to 0 to mean "default". * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`) * or an error code, which can be tested with ZDICT_isError(). * See ZDICT_trainFromBuffer() for details on failure modes. * Tips: In general, a reasonable dictionary has a size of ~ 100 KB. * It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`. * In general, it's recommended to provide a few thousands samples, though this can vary a lot. * It's recommended that total size of all samples be about ~x100 times the target size of dictionary. * Note: ZDICT_trainFromBuffer_legacy() will send notifications into stderr if instructed to, using notificationLevel>0. / ZDICTLIB_STATIC_API size_t ZDICT_trainFromBuffer_legacy( void dictBuffer, size_t dictBufferCapacity, const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples, ZDICT_legacy_params_t parameters); /* Deprecation warnings / / It is generally possible to disable deprecation warnings from compiler, for example with -Wno-deprecated-declarations for gcc or _CRT_SECURE_NO_WARNINGS in Visual. Otherwise, it's also possible to manually define ZDICT_DISABLE_DEPRECATE_WARNINGS / #ifdef ZDICT_DISABLE_DEPRECATE_WARNINGS # define ZDICT_DEPRECATED(message) / disable deprecation warnings / #else # define ZDICT_GCC_VERSION (__GNUC__ 100 + __GNUC_MINOR__) # if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater / # define ZDICT_DEPRECATED(message) [[deprecated(message)]] # elif defined(__clang__) \|\| (ZDICT_GCC_VERSION >= 405) # define ZDICT_DEPRECATED(message) __attribute__((deprecated(message))) # elif (ZDICT_GCC_VERSION >= 301) # define ZDICT_DEPRECATED(message) __attribute__((deprecated)) # elif defined(_MSC_VER) # define ZDICT_DEPRECATED(message) __declspec(deprecated(message)) # else # pragma message("WARNING: You need to implement ZDICT_DEPRECATED for this compiler") # define ZDICT_DEPRECATED(message) # endif #endif / ZDICT_DISABLE_DEPRECATE_WARNINGS / ZDICT_DEPRECATED("use ZDICT_finalizeDictionary() instead") ZDICTLIB_STATIC_API size_t ZDICT_addEntropyTablesFromBuffer(void dictBuffer, size_t dictContentSize, size_t dictBufferCapacity, const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples); #endif /* ZSTD_ZDICT_H_STATIC */ #if defined (__cplusplus) } #endif	25.81 KB	2023-04-04 20:13
📄 zlib.h /* zlib.h -- interface of the 'zlib' general purpose compression library version 1.2.11, January 15th, 2017 Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly Mark Adler jloup@gzip.org madler@alumni.caltech.edu The data format used by the zlib library is described by RFCs (Request for Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). / #ifndef ZLIB_H #define ZLIB_H #include "zconf.h" #ifdef __cplusplus extern "C" { #endif #define ZLIB_VERSION "1.2.11" #define ZLIB_VERNUM 0x12b0 #define ZLIB_VER_MAJOR 1 #define ZLIB_VER_MINOR 2 #define ZLIB_VER_REVISION 11 #define ZLIB_VER_SUBREVISION 0 / The 'zlib' compression library provides in-memory compression and decompression functions, including integrity checks of the uncompressed data. This version of the library supports only one compression method (deflation) but other algorithms will be added later and will have the same stream interface. Compression can be done in a single step if the buffers are large enough, or can be done by repeated calls of the compression function. In the latter case, the application must provide more input and/or consume the output (providing more output space) before each call. The compressed data format used by default by the in-memory functions is the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped around a deflate stream, which is itself documented in RFC 1951. The library also supports reading and writing files in gzip (.gz) format with an interface similar to that of stdio using the functions that start with "gz". The gzip format is different from the zlib format. gzip is a gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. This library can optionally read and write gzip and raw deflate streams in memory as well. The zlib format was designed to be compact and fast for use in memory and on communications channels. The gzip format was designed for single- file compression on file systems, has a larger header than zlib to maintain directory information, and uses a different, slower check method than zlib. The library does not install any signal handler. The decoder checks the consistency of the compressed data, so the library should never crash even in the case of corrupted input. / typedef voidpf (alloc_func) OF((voidpf opaque, uInt items, uInt size)); typedef void (free_func) OF((voidpf opaque, voidpf address)); struct internal_state; typedef struct z_stream_s { z_const Bytef next_in; /* next input byte / uInt avail_in; / number of bytes available at next_in / uLong total_in; / total number of input bytes read so far / Bytef next_out; /* next output byte will go here / uInt avail_out; / remaining free space at next_out / uLong total_out; / total number of bytes output so far / z_const char msg; /* last error message, NULL if no error / struct internal_state FAR state; /* not visible by applications / alloc_func zalloc; / used to allocate the internal state / free_func zfree; / used to free the internal state / voidpf opaque; / private data object passed to zalloc and zfree / int data_type; / best guess about the data type: binary or text for deflate, or the decoding state for inflate / uLong adler; / Adler-32 or CRC-32 value of the uncompressed data / uLong reserved; / reserved for future use / } z_stream; typedef z_stream FAR z_streamp; /* gzip header information passed to and from zlib routines. See RFC 1952 for more details on the meanings of these fields. / typedef struct gz_header_s { int text; / true if compressed data believed to be text / uLong time; / modification time / int xflags; / extra flags (not used when writing a gzip file) / int os; / operating system / Bytef extra; /* pointer to extra field or Z_NULL if none / uInt extra_len; / extra field length (valid if extra != Z_NULL) / uInt extra_max; / space at extra (only when reading header) / Bytef name; /* pointer to zero-terminated file name or Z_NULL / uInt name_max; / space at name (only when reading header) / Bytef comment; /* pointer to zero-terminated comment or Z_NULL / uInt comm_max; / space at comment (only when reading header) / int hcrc; / true if there was or will be a header crc / int done; / true when done reading gzip header (not used when writing a gzip file) / } gz_header; typedef gz_header FAR gz_headerp; /* The application must update next_in and avail_in when avail_in has dropped to zero. It must update next_out and avail_out when avail_out has dropped to zero. The application must initialize zalloc, zfree and opaque before calling the init function. All other fields are set by the compression library and must not be updated by the application. The opaque value provided by the application will be passed as the first parameter for calls of zalloc and zfree. This can be useful for custom memory management. The compression library attaches no meaning to the opaque value. zalloc must return Z_NULL if there is not enough memory for the object. If zlib is used in a multi-threaded application, zalloc and zfree must be thread safe. In that case, zlib is thread-safe. When zalloc and zfree are Z_NULL on entry to the initialization function, they are set to internal routines that use the standard library functions malloc() and free(). On 16-bit systems, the functions zalloc and zfree must be able to allocate exactly 65536 bytes, but will not be required to allocate more than this if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, pointers returned by zalloc for objects of exactly 65536 bytes must have their offset normalized to zero. The default allocation function provided by this library ensures this (see zutil.c). To reduce memory requirements and avoid any allocation of 64K objects, at the expense of compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). The fields total_in and total_out can be used for statistics or progress reports. After compression, total_in holds the total size of the uncompressed data and may be saved for use by the decompressor (particularly if the decompressor wants to decompress everything in a single step). / / constants / #define Z_NO_FLUSH 0 #define Z_PARTIAL_FLUSH 1 #define Z_SYNC_FLUSH 2 #define Z_FULL_FLUSH 3 #define Z_FINISH 4 #define Z_BLOCK 5 #define Z_TREES 6 / Allowed flush values; see deflate() and inflate() below for details / #define Z_OK 0 #define Z_STREAM_END 1 #define Z_NEED_DICT 2 #define Z_ERRNO (-1) #define Z_STREAM_ERROR (-2) #define Z_DATA_ERROR (-3) #define Z_MEM_ERROR (-4) #define Z_BUF_ERROR (-5) #define Z_VERSION_ERROR (-6) / Return codes for the compression/decompression functions. Negative values * are errors, positive values are used for special but normal events. / #define Z_NO_COMPRESSION 0 #define Z_BEST_SPEED 1 #define Z_BEST_COMPRESSION 9 #define Z_DEFAULT_COMPRESSION (-1) / compression levels / #define Z_FILTERED 1 #define Z_HUFFMAN_ONLY 2 #define Z_RLE 3 #define Z_FIXED 4 #define Z_DEFAULT_STRATEGY 0 / compression strategy; see deflateInit2() below for details / #define Z_BINARY 0 #define Z_TEXT 1 #define Z_ASCII Z_TEXT / for compatibility with 1.2.2 and earlier / #define Z_UNKNOWN 2 / Possible values of the data_type field for deflate() / #define Z_DEFLATED 8 / The deflate compression method (the only one supported in this version) / #define Z_NULL 0 / for initializing zalloc, zfree, opaque / #define zlib_version zlibVersion() / for compatibility with versions < 1.0.2 / / basic functions / ZEXTERN const char ZEXPORT zlibVersion OF((void)); /* The application can compare zlibVersion and ZLIB_VERSION for consistency. If the first character differs, the library code actually used is not compatible with the zlib.h header file used by the application. This check is automatically made by deflateInit and inflateInit. / / ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); Initializes the internal stream state for compression. The fields zalloc, zfree and opaque must be initialized before by the caller. If zalloc and zfree are set to Z_NULL, deflateInit updates them to use default allocation functions. The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: 1 gives best speed, 9 gives best compression, 0 gives no compression at all (the input data is simply copied a block at a time). Z_DEFAULT_COMPRESSION requests a default compromise between speed and compression (currently equivalent to level 6). deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_STREAM_ERROR if level is not a valid compression level, or Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible with the version assumed by the caller (ZLIB_VERSION). msg is set to null if there is no error message. deflateInit does not perform any compression: this will be done by deflate(). / ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); / deflate compresses as much data as possible, and stops when the input buffer becomes empty or the output buffer becomes full. It may introduce some output latency (reading input without producing any output) except when forced to flush. The detailed semantics are as follows. deflate performs one or both of the following actions: - Compress more input starting at next_in and update next_in and avail_in accordingly. If not all input can be processed (because there is not enough room in the output buffer), next_in and avail_in are updated and processing will resume at this point for the next call of deflate(). - Generate more output starting at next_out and update next_out and avail_out accordingly. This action is forced if the parameter flush is non zero. Forcing flush frequently degrades the compression ratio, so this parameter should be set only when necessary. Some output may be provided even if flush is zero. Before the call of deflate(), the application should ensure that at least one of the actions is possible, by providing more input and/or consuming more output, and updating avail_in or avail_out accordingly; avail_out should never be zero before the call. The application can consume the compressed output when it wants, for example when the output buffer is full (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK and with zero avail_out, it must be called again after making room in the output buffer because there might be more output pending. See deflatePending(), which can be used if desired to determine whether or not there is more ouput in that case. Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to decide how much data to accumulate before producing output, in order to maximize compression. If the parameter flush is set to Z_SYNC_FLUSH, all pending output is flushed to the output buffer and the output is aligned on a byte boundary, so that the decompressor can get all input data available so far. (In particular avail_in is zero after the call if enough output space has been provided before the call.) Flushing may degrade compression for some compression algorithms and so it should be used only when necessary. This completes the current deflate block and follows it with an empty stored block that is three bits plus filler bits to the next byte, followed by four bytes (00 00 ff ff). If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the output buffer, but the output is not aligned to a byte boundary. All of the input data so far will be available to the decompressor, as for Z_SYNC_FLUSH. This completes the current deflate block and follows it with an empty fixed codes block that is 10 bits long. This assures that enough bytes are output in order for the decompressor to finish the block before the empty fixed codes block. If flush is set to Z_BLOCK, a deflate block is completed and emitted, as for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to seven bits of the current block are held to be written as the next byte after the next deflate block is completed. In this case, the decompressor may not be provided enough bits at this point in order to complete decompression of the data provided so far to the compressor. It may need to wait for the next block to be emitted. This is for advanced applications that need to control the emission of deflate blocks. If flush is set to Z_FULL_FLUSH, all output is flushed as with Z_SYNC_FLUSH, and the compression state is reset so that decompression can restart from this point if previous compressed data has been damaged or if random access is desired. Using Z_FULL_FLUSH too often can seriously degrade compression. If deflate returns with avail_out == 0, this function must be called again with the same value of the flush parameter and more output space (updated avail_out), until the flush is complete (deflate returns with non-zero avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that avail_out is greater than six to avoid repeated flush markers due to avail_out == 0 on return. If the parameter flush is set to Z_FINISH, pending input is processed, pending output is flushed and deflate returns with Z_STREAM_END if there was enough output space. If deflate returns with Z_OK or Z_BUF_ERROR, this function must be called again with Z_FINISH and more output space (updated avail_out) but no more input data, until it returns with Z_STREAM_END or an error. After deflate has returned Z_STREAM_END, the only possible operations on the stream are deflateReset or deflateEnd. Z_FINISH can be used in the first deflate call after deflateInit if all the compression is to be done in a single step. In order to complete in one call, avail_out must be at least the value returned by deflateBound (see below). Then deflate is guaranteed to return Z_STREAM_END. If not enough output space is provided, deflate will not return Z_STREAM_END, and it must be called again as described above. deflate() sets strm->adler to the Adler-32 checksum of all input read so far (that is, total_in bytes). If a gzip stream is being generated, then strm->adler will be the CRC-32 checksum of the input read so far. (See deflateInit2 below.) deflate() may update strm->data_type if it can make a good guess about the input data type (Z_BINARY or Z_TEXT). If in doubt, the data is considered binary. This field is only for information purposes and does not affect the compression algorithm in any manner. deflate() returns Z_OK if some progress has been made (more input processed or more output produced), Z_STREAM_END if all input has been consumed and all output has been produced (only when flush is set to Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example if next_in or next_out was Z_NULL or the state was inadvertently written over by the application), or Z_BUF_ERROR if no progress is possible (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not fatal, and deflate() can be called again with more input and more output space to continue compressing. / ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); / All dynamically allocated data structures for this stream are freed. This function discards any unprocessed input and does not flush any pending output. deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state was inconsistent, Z_DATA_ERROR if the stream was freed prematurely (some input or output was discarded). In the error case, msg may be set but then points to a static string (which must not be deallocated). / / ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); Initializes the internal stream state for decompression. The fields next_in, avail_in, zalloc, zfree and opaque must be initialized before by the caller. In the current version of inflate, the provided input is not read or consumed. The allocation of a sliding window will be deferred to the first call of inflate (if the decompression does not complete on the first call). If zalloc and zfree are set to Z_NULL, inflateInit updates them to use default allocation functions. inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_VERSION_ERROR if the zlib library version is incompatible with the version assumed by the caller, or Z_STREAM_ERROR if the parameters are invalid, such as a null pointer to the structure. msg is set to null if there is no error message. inflateInit does not perform any decompression. Actual decompression will be done by inflate(). So next_in, and avail_in, next_out, and avail_out are unused and unchanged. The current implementation of inflateInit() does not process any header information -- that is deferred until inflate() is called. / ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); / inflate decompresses as much data as possible, and stops when the input buffer becomes empty or the output buffer becomes full. It may introduce some output latency (reading input without producing any output) except when forced to flush. The detailed semantics are as follows. inflate performs one or both of the following actions: - Decompress more input starting at next_in and update next_in and avail_in accordingly. If not all input can be processed (because there is not enough room in the output buffer), then next_in and avail_in are updated accordingly, and processing will resume at this point for the next call of inflate(). - Generate more output starting at next_out and update next_out and avail_out accordingly. inflate() provides as much output as possible, until there is no more input data or no more space in the output buffer (see below about the flush parameter). Before the call of inflate(), the application should ensure that at least one of the actions is possible, by providing more input and/or consuming more output, and updating the next_* and avail_* values accordingly. If the caller of inflate() does not provide both available input and available output space, it is possible that there will be no progress made. The application can consume the uncompressed output when it wants, for example when the output buffer is full (avail_out == 0), or after each call of inflate(). If inflate returns Z_OK and with zero avail_out, it must be called again after making room in the output buffer because there might be more output pending. The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH, Z_BLOCK, or Z_TREES. Z_SYNC_FLUSH requests that inflate() flush as much output as possible to the output buffer. Z_BLOCK requests that inflate() stop if and when it gets to the next deflate block boundary. When decoding the zlib or gzip format, this will cause inflate() to return immediately after the header and before the first block. When doing a raw inflate, inflate() will go ahead and process the first block, and will return when it gets to the end of that block, or when it runs out of data. The Z_BLOCK option assists in appending to or combining deflate streams. To assist in this, on return inflate() always sets strm->data_type to the number of unused bits in the last byte taken from strm->next_in, plus 64 if inflate() is currently decoding the last block in the deflate stream, plus 128 if inflate() returned immediately after decoding an end-of-block code or decoding the complete header up to just before the first byte of the deflate stream. The end-of-block will not be indicated until all of the uncompressed data from that block has been written to strm->next_out. The number of unused bits may in general be greater than seven, except when bit 7 of data_type is set, in which case the number of unused bits will be less than eight. data_type is set as noted here every time inflate() returns for all flush options, and so can be used to determine the amount of currently consumed input in bits. The Z_TREES option behaves as Z_BLOCK does, but it also returns when the end of each deflate block header is reached, before any actual data in that block is decoded. This allows the caller to determine the length of the deflate block header for later use in random access within a deflate block. 256 is added to the value of strm->data_type when inflate() returns immediately after reaching the end of the deflate block header. inflate() should normally be called until it returns Z_STREAM_END or an error. However if all decompression is to be performed in a single step (a single call of inflate), the parameter flush should be set to Z_FINISH. In this case all pending input is processed and all pending output is flushed; avail_out must be large enough to hold all of the uncompressed data for the operation to complete. (The size of the uncompressed data may have been saved by the compressor for this purpose.) The use of Z_FINISH is not required to perform an inflation in one step. However it may be used to inform inflate that a faster approach can be used for the single inflate() call. Z_FINISH also informs inflate to not maintain a sliding window if the stream completes, which reduces inflate's memory footprint. If the stream does not complete, either because not all of the stream is provided or not enough output space is provided, then a sliding window will be allocated and inflate() can be called again to continue the operation as if Z_NO_FLUSH had been used. In this implementation, inflate() always flushes as much output as possible to the output buffer, and always uses the faster approach on the first call. So the effects of the flush parameter in this implementation are on the return value of inflate() as noted below, when inflate() returns early when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of memory for a sliding window when Z_FINISH is used. If a preset dictionary is needed after this call (see inflateSetDictionary below), inflate sets strm->adler to the Adler-32 checksum of the dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise it sets strm->adler to the Adler-32 checksum of all output produced so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described below. At the end of the stream, inflate() checks that its computed Adler-32 checksum is equal to that saved by the compressor and returns Z_STREAM_END only if the checksum is correct. inflate() can decompress and check either zlib-wrapped or gzip-wrapped deflate data. The header type is detected automatically, if requested when initializing with inflateInit2(). Any information contained in the gzip header is not retained unless inflateGetHeader() is used. When processing gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output produced so far. The CRC-32 is checked against the gzip trailer, as is the uncompressed length, modulo 2^32. inflate() returns Z_OK if some progress has been made (more input processed or more output produced), Z_STREAM_END if the end of the compressed data has been reached and all uncompressed output has been produced, Z_NEED_DICT if a preset dictionary is needed at this point, Z_DATA_ERROR if the input data was corrupted (input stream not conforming to the zlib format or incorrect check value, in which case strm->msg points to a string with a more specific error), Z_STREAM_ERROR if the stream structure was inconsistent (for example next_in or next_out was Z_NULL, or the state was inadvertently written over by the application), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if no progress was possible or if there was not enough room in the output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and inflate() can be called again with more input and more output space to continue decompressing. If Z_DATA_ERROR is returned, the application may then call inflateSync() to look for a good compression block if a partial recovery of the data is to be attempted. / ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); / All dynamically allocated data structures for this stream are freed. This function discards any unprocessed input and does not flush any pending output. inflateEnd returns Z_OK if success, or Z_STREAM_ERROR if the stream state was inconsistent. / / Advanced functions / / The following functions are needed only in some special applications. / / ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, int level, int method, int windowBits, int memLevel, int strategy)); This is another version of deflateInit with more compression options. The fields next_in, zalloc, zfree and opaque must be initialized before by the caller. The method parameter is the compression method. It must be Z_DEFLATED in this version of the library. The windowBits parameter is the base two logarithm of the window size (the size of the history buffer). It should be in the range 8..15 for this version of the library. Larger values of this parameter result in better compression at the expense of memory usage. The default value is 15 if deflateInit is used instead. For the current implementation of deflate(), a windowBits value of 8 (a window size of 256 bytes) is not supported. As a result, a request for 8 will result in 9 (a 512-byte window). In that case, providing 8 to inflateInit2() will result in an error when the zlib header with 9 is checked against the initialization of inflate(). The remedy is to not use 8 with deflateInit2() with this initialization, or at least in that case use 9 with inflateInit2(). windowBits can also be -8..-15 for raw deflate. In this case, -windowBits determines the window size. deflate() will then generate raw deflate data with no zlib header or trailer, and will not compute a check value. windowBits can also be greater than 15 for optional gzip encoding. Add 16 to windowBits to write a simple gzip header and trailer around the compressed data instead of a zlib wrapper. The gzip header will have no file name, no extra data, no comment, no modification time (set to zero), no header crc, and the operating system will be set to the appropriate value, if the operating system was determined at compile time. If a gzip stream is being written, strm->adler is a CRC-32 instead of an Adler-32. For raw deflate or gzip encoding, a request for a 256-byte window is rejected as invalid, since only the zlib header provides a means of transmitting the window size to the decompressor. The memLevel parameter specifies how much memory should be allocated for the internal compression state. memLevel=1 uses minimum memory but is slow and reduces compression ratio; memLevel=9 uses maximum memory for optimal speed. The default value is 8. See zconf.h for total memory usage as a function of windowBits and memLevel. The strategy parameter is used to tune the compression algorithm. Use the value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no string match), or Z_RLE to limit match distances to one (run-length encoding). Filtered data consists mostly of small values with a somewhat random distribution. In this case, the compression algorithm is tuned to compress them better. The effect of Z_FILTERED is to force more Huffman coding and less string matching; it is somewhat intermediate between Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data. The strategy parameter only affects the compression ratio but not the correctness of the compressed output even if it is not set appropriately. Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler decoder for special applications. deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible with the version assumed by the caller (ZLIB_VERSION). msg is set to null if there is no error message. deflateInit2 does not perform any compression: this will be done by deflate(). / ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, const Bytef dictionary, uInt dictLength)); /* Initializes the compression dictionary from the given byte sequence without producing any compressed output. When using the zlib format, this function must be called immediately after deflateInit, deflateInit2 or deflateReset, and before any call of deflate. When doing raw deflate, this function must be called either before any call of deflate, or immediately after the completion of a deflate block, i.e. after all input has been consumed and all output has been delivered when using any of the flush options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH. The compressor and decompressor must use exactly the same dictionary (see inflateSetDictionary). The dictionary should consist of strings (byte sequences) that are likely to be encountered later in the data to be compressed, with the most commonly used strings preferably put towards the end of the dictionary. Using a dictionary is most useful when the data to be compressed is short and can be predicted with good accuracy; the data can then be compressed better than with the default empty dictionary. Depending on the size of the compression data structures selected by deflateInit or deflateInit2, a part of the dictionary may in effect be discarded, for example if the dictionary is larger than the window size provided in deflateInit or deflateInit2. Thus the strings most likely to be useful should be put at the end of the dictionary, not at the front. In addition, the current implementation of deflate will use at most the window size minus 262 bytes of the provided dictionary. Upon return of this function, strm->adler is set to the Adler-32 value of the dictionary; the decompressor may later use this value to determine which dictionary has been used by the compressor. (The Adler-32 value applies to the whole dictionary even if only a subset of the dictionary is actually used by the compressor.) If a raw deflate was requested, then the Adler-32 value is not computed and strm->adler is not set. deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is inconsistent (for example if deflate has already been called for this stream or if not at a block boundary for raw deflate). deflateSetDictionary does not perform any compression: this will be done by deflate(). / ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm, Bytef dictionary, uInt dictLength)); / Returns the sliding dictionary being maintained by deflate. dictLength is set to the number of bytes in the dictionary, and that many bytes are copied to dictionary. dictionary must have enough space, where 32768 bytes is always enough. If deflateGetDictionary() is called with dictionary equal to Z_NULL, then only the dictionary length is returned, and nothing is copied. Similary, if dictLength is Z_NULL, then it is not set. deflateGetDictionary() may return a length less than the window size, even when more than the window size in input has been provided. It may return up to 258 bytes less in that case, due to how zlib's implementation of deflate manages the sliding window and lookahead for matches, where matches can be up to 258 bytes long. If the application needs the last window-size bytes of input, then that would need to be saved by the application outside of zlib. deflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the stream state is inconsistent. / ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, z_streamp source)); / Sets the destination stream as a complete copy of the source stream. This function can be useful when several compression strategies will be tried, for example when there are several ways of pre-processing the input data with a filter. The streams that will be discarded should then be freed by calling deflateEnd. Note that deflateCopy duplicates the internal compression state which can be quite large, so this strategy is slow and can consume lots of memory. deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_STREAM_ERROR if the source stream state was inconsistent (such as zalloc being Z_NULL). msg is left unchanged in both source and destination. / ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); / This function is equivalent to deflateEnd followed by deflateInit, but does not free and reallocate the internal compression state. The stream will leave the compression level and any other attributes that may have been set unchanged. deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent (such as zalloc or state being Z_NULL). / ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, int level, int strategy)); / Dynamically update the compression level and compression strategy. The interpretation of level and strategy is as in deflateInit2(). This can be used to switch between compression and straight copy of the input data, or to switch to a different kind of input data requiring a different strategy. If the compression approach (which is a function of the level) or the strategy is changed, and if there have been any deflate() calls since the state was initialized or reset, then the input available so far is compressed with the old level and strategy using deflate(strm, Z_BLOCK). There are three approaches for the compression levels 0, 1..3, and 4..9 respectively. The new level and strategy will take effect at the next call of deflate(). If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does not have enough output space to complete, then the parameter change will not take effect. In this case, deflateParams() can be called again with the same parameters and more output space to try again. In order to assure a change in the parameters on the first try, the deflate stream should be flushed using deflate() with Z_BLOCK or other flush request until strm.avail_out is not zero, before calling deflateParams(). Then no more input data should be provided before the deflateParams() call. If this is done, the old level and strategy will be applied to the data compressed before deflateParams(), and the new level and strategy will be applied to the the data compressed after deflateParams(). deflateParams returns Z_OK on success, Z_STREAM_ERROR if the source stream state was inconsistent or if a parameter was invalid, or Z_BUF_ERROR if there was not enough output space to complete the compression of the available input data before a change in the strategy or approach. Note that in the case of a Z_BUF_ERROR, the parameters are not changed. A return value of Z_BUF_ERROR is not fatal, in which case deflateParams() can be retried with more output space. / ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, int good_length, int max_lazy, int nice_length, int max_chain)); / Fine tune deflate's internal compression parameters. This should only be used by someone who understands the algorithm used by zlib's deflate for searching for the best matching string, and even then only by the most fanatic optimizer trying to squeeze out the last compressed bit for their specific input data. Read the deflate.c source code for the meaning of the max_lazy, good_length, nice_length, and max_chain parameters. deflateTune() can be called after deflateInit() or deflateInit2(), and returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. / ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, uLong sourceLen)); / deflateBound() returns an upper bound on the compressed size after deflation of sourceLen bytes. It must be called after deflateInit() or deflateInit2(), and after deflateSetHeader(), if used. This would be used to allocate an output buffer for deflation in a single pass, and so would be called before deflate(). If that first deflate() call is provided the sourceLen input bytes, an output buffer allocated to the size returned by deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed to return Z_STREAM_END. Note that it is possible for the compressed size to be larger than the value returned by deflateBound() if flush options other than Z_FINISH or Z_NO_FLUSH are used. / ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, unsigned pending, int bits)); / deflatePending() returns the number of bytes and bits of output that have been generated, but not yet provided in the available output. The bytes not provided would be due to the available output space having being consumed. The number of bits of output not provided are between 0 and 7, where they await more bits to join them in order to fill out a full byte. If pending or bits are Z_NULL, then those values are not set. deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent. / ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, int bits, int value)); / deflatePrime() inserts bits in the deflate output stream. The intent is that this function is used to start off the deflate output with the bits leftover from a previous deflate stream when appending to it. As such, this function can only be used for raw deflate, and must be used before the first deflate() call after a deflateInit2() or deflateReset(). bits must be less than or equal to 16, and that many of the least significant bits of value will be inserted in the output. deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the source stream state was inconsistent. / ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, gz_headerp head)); / deflateSetHeader() provides gzip header information for when a gzip stream is requested by deflateInit2(). deflateSetHeader() may be called after deflateInit2() or deflateReset() and before the first call of deflate(). The text, time, os, extra field, name, and comment information in the provided gz_header structure are written to the gzip header (xflag is ignored -- the extra flags are set according to the compression level). The caller must assure that, if not Z_NULL, name and comment are terminated with a zero byte, and that if extra is not Z_NULL, that extra_len bytes are available there. If hcrc is true, a gzip header crc is included. Note that the current versions of the command-line version of gzip (up through version 1.3.x) do not support header crc's, and will report that it is a "multi-part gzip file" and give up. If deflateSetHeader is not used, the default gzip header has text false, the time set to zero, and os set to 255, with no extra, name, or comment fields. The gzip header is returned to the default state by deflateReset(). deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent. / / ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, int windowBits)); This is another version of inflateInit with an extra parameter. The fields next_in, avail_in, zalloc, zfree and opaque must be initialized before by the caller. The windowBits parameter is the base two logarithm of the maximum window size (the size of the history buffer). It should be in the range 8..15 for this version of the library. The default value is 15 if inflateInit is used instead. windowBits must be greater than or equal to the windowBits value provided to deflateInit2() while compressing, or it must be equal to 15 if deflateInit2() was not used. If a compressed stream with a larger window size is given as input, inflate() will return with the error code Z_DATA_ERROR instead of trying to allocate a larger window. windowBits can also be zero to request that inflate use the window size in the zlib header of the compressed stream. windowBits can also be -8..-15 for raw inflate. In this case, -windowBits determines the window size. inflate() will then process raw deflate data, not looking for a zlib or gzip header, not generating a check value, and not looking for any check values for comparison at the end of the stream. This is for use with other formats that use the deflate compressed data format such as zip. Those formats provide their own check values. If a custom format is developed using the raw deflate format for compressed data, it is recommended that a check value such as an Adler-32 or a CRC-32 be applied to the uncompressed data as is done in the zlib, gzip, and zip formats. For most applications, the zlib format should be used as is. Note that comments above on the use in deflateInit2() applies to the magnitude of windowBits. windowBits can also be greater than 15 for optional gzip decoding. Add 32 to windowBits to enable zlib and gzip decoding with automatic header detection, or add 16 to decode only the gzip format (the zlib format will return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a CRC-32 instead of an Adler-32. Unlike the gunzip utility and gzread() (see below), inflate() will not automatically decode concatenated gzip streams. inflate() will return Z_STREAM_END at the end of the gzip stream. The state would need to be reset to continue decoding a subsequent gzip stream. inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_VERSION_ERROR if the zlib library version is incompatible with the version assumed by the caller, or Z_STREAM_ERROR if the parameters are invalid, such as a null pointer to the structure. msg is set to null if there is no error message. inflateInit2 does not perform any decompression apart from possibly reading the zlib header if present: actual decompression will be done by inflate(). (So next_in and avail_in may be modified, but next_out and avail_out are unused and unchanged.) The current implementation of inflateInit2() does not process any header information -- that is deferred until inflate() is called. / ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, const Bytef dictionary, uInt dictLength)); /* Initializes the decompression dictionary from the given uncompressed byte sequence. This function must be called immediately after a call of inflate, if that call returned Z_NEED_DICT. The dictionary chosen by the compressor can be determined from the Adler-32 value returned by that call of inflate. The compressor and decompressor must use exactly the same dictionary (see deflateSetDictionary). For raw inflate, this function can be called at any time to set the dictionary. If the provided dictionary is smaller than the window and there is already data in the window, then the provided dictionary will amend what's there. The application must insure that the dictionary that was used for compression is provided. inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the expected one (incorrect Adler-32 value). inflateSetDictionary does not perform any decompression: this will be done by subsequent calls of inflate(). / ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm, Bytef dictionary, uInt dictLength)); / Returns the sliding dictionary being maintained by inflate. dictLength is set to the number of bytes in the dictionary, and that many bytes are copied to dictionary. dictionary must have enough space, where 32768 bytes is always enough. If inflateGetDictionary() is called with dictionary equal to Z_NULL, then only the dictionary length is returned, and nothing is copied. Similary, if dictLength is Z_NULL, then it is not set. inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the stream state is inconsistent. / ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); / Skips invalid compressed data until a possible full flush point (see above for the description of deflate with Z_FULL_FLUSH) can be found, or until all available input is skipped. No output is provided. inflateSync searches for a 00 00 FF FF pattern in the compressed data. All full flush points have this pattern, but not all occurrences of this pattern are full flush points. inflateSync returns Z_OK if a possible full flush point has been found, Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point has been found, or Z_STREAM_ERROR if the stream structure was inconsistent. In the success case, the application may save the current current value of total_in which indicates where valid compressed data was found. In the error case, the application may repeatedly call inflateSync, providing more input each time, until success or end of the input data. / ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, z_streamp source)); / Sets the destination stream as a complete copy of the source stream. This function can be useful when randomly accessing a large stream. The first pass through the stream can periodically record the inflate state, allowing restarting inflate at those points when randomly accessing the stream. inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_STREAM_ERROR if the source stream state was inconsistent (such as zalloc being Z_NULL). msg is left unchanged in both source and destination. / ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); / This function is equivalent to inflateEnd followed by inflateInit, but does not free and reallocate the internal decompression state. The stream will keep attributes that may have been set by inflateInit2. inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent (such as zalloc or state being Z_NULL). / ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, int windowBits)); / This function is the same as inflateReset, but it also permits changing the wrap and window size requests. The windowBits parameter is interpreted the same as it is for inflateInit2. If the window size is changed, then the memory allocated for the window is freed, and the window will be reallocated by inflate() if needed. inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent (such as zalloc or state being Z_NULL), or if the windowBits parameter is invalid. / ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, int bits, int value)); / This function inserts bits in the inflate input stream. The intent is that this function is used to start inflating at a bit position in the middle of a byte. The provided bits will be used before any bytes are used from next_in. This function should only be used with raw inflate, and should be used before the first inflate() call after inflateInit2() or inflateReset(). bits must be less than or equal to 16, and that many of the least significant bits of value will be inserted in the input. If bits is negative, then the input stream bit buffer is emptied. Then inflatePrime() can be called again to put bits in the buffer. This is used to clear out bits leftover after feeding inflate a block description prior to feeding inflate codes. inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent. / ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm)); / This function returns two values, one in the lower 16 bits of the return value, and the other in the remaining upper bits, obtained by shifting the return value down 16 bits. If the upper value is -1 and the lower value is zero, then inflate() is currently decoding information outside of a block. If the upper value is -1 and the lower value is non-zero, then inflate is in the middle of a stored block, with the lower value equaling the number of bytes from the input remaining to copy. If the upper value is not -1, then it is the number of bits back from the current bit position in the input of the code (literal or length/distance pair) currently being processed. In that case the lower value is the number of bytes already emitted for that code. A code is being processed if inflate is waiting for more input to complete decoding of the code, or if it has completed decoding but is waiting for more output space to write the literal or match data. inflateMark() is used to mark locations in the input data for random access, which may be at bit positions, and to note those cases where the output of a code may span boundaries of random access blocks. The current location in the input stream can be determined from avail_in and data_type as noted in the description for the Z_BLOCK flush parameter for inflate. inflateMark returns the value noted above, or -65536 if the provided source stream state was inconsistent. / ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, gz_headerp head)); / inflateGetHeader() requests that gzip header information be stored in the provided gz_header structure. inflateGetHeader() may be called after inflateInit2() or inflateReset(), and before the first call of inflate(). As inflate() processes the gzip stream, head->done is zero until the header is completed, at which time head->done is set to one. If a zlib stream is being decoded, then head->done is set to -1 to indicate that there will be no gzip header information forthcoming. Note that Z_BLOCK or Z_TREES can be used to force inflate() to return immediately after header processing is complete and before any actual data is decompressed. The text, time, xflags, and os fields are filled in with the gzip header contents. hcrc is set to true if there is a header CRC. (The header CRC was valid if done is set to one.) If extra is not Z_NULL, then extra_max contains the maximum number of bytes to write to extra. Once done is true, extra_len contains the actual extra field length, and extra contains the extra field, or that field truncated if extra_max is less than extra_len. If name is not Z_NULL, then up to name_max characters are written there, terminated with a zero unless the length is greater than name_max. If comment is not Z_NULL, then up to comm_max characters are written there, terminated with a zero unless the length is greater than comm_max. When any of extra, name, or comment are not Z_NULL and the respective field is not present in the header, then that field is set to Z_NULL to signal its absence. This allows the use of deflateSetHeader() with the returned structure to duplicate the header. However if those fields are set to allocated memory, then the application will need to save those pointers elsewhere so that they can be eventually freed. If inflateGetHeader is not used, then the header information is simply discarded. The header is always checked for validity, including the header CRC if present. inflateReset() will reset the process to discard the header information. The application would need to call inflateGetHeader() again to retrieve the header from the next gzip stream. inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent. / / ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, unsigned char FAR window)); Initialize the internal stream state for decompression using inflateBack() calls. The fields zalloc, zfree and opaque in strm must be initialized before the call. If zalloc and zfree are Z_NULL, then the default library- derived memory allocation routines are used. windowBits is the base two logarithm of the window size, in the range 8..15. window is a caller supplied buffer of that size. Except for special applications where it is assured that deflate was used with small window sizes, windowBits must be 15 and a 32K byte window must be supplied to be able to decompress general deflate streams. See inflateBack() for the usage of these routines. inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of the parameters are invalid, Z_MEM_ERROR if the internal state could not be allocated, or Z_VERSION_ERROR if the version of the library does not match the version of the header file. / typedef unsigned (in_func) OF((void FAR , z_const unsigned char FAR * FAR )); typedef int (out_func) OF((void FAR , unsigned char FAR , unsigned)); ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, in_func in, void FAR in_desc, out_func out, void FAR out_desc)); /* inflateBack() does a raw inflate with a single call using a call-back interface for input and output. This is potentially more efficient than inflate() for file i/o applications, in that it avoids copying between the output and the sliding window by simply making the window itself the output buffer. inflate() can be faster on modern CPUs when used with large buffers. inflateBack() trusts the application to not change the output buffer passed by the output function, at least until inflateBack() returns. inflateBackInit() must be called first to allocate the internal state and to initialize the state with the user-provided window buffer. inflateBack() may then be used multiple times to inflate a complete, raw deflate stream with each call. inflateBackEnd() is then called to free the allocated state. A raw deflate stream is one with no zlib or gzip header or trailer. This routine would normally be used in a utility that reads zip or gzip files and writes out uncompressed files. The utility would decode the header and process the trailer on its own, hence this routine expects only the raw deflate stream to decompress. This is different from the default behavior of inflate(), which expects a zlib header and trailer around the deflate stream. inflateBack() uses two subroutines supplied by the caller that are then called by inflateBack() for input and output. inflateBack() calls those routines until it reads a complete deflate stream and writes out all of the uncompressed data, or until it encounters an error. The function's parameters and return types are defined above in the in_func and out_func typedefs. inflateBack() will call in(in_desc, &buf) which should return the number of bytes of provided input, and a pointer to that input in buf. If there is no input available, in() must return zero -- buf is ignored in that case -- and inflateBack() will return a buffer error. inflateBack() will call out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out() should return zero on success, or non-zero on failure. If out() returns non-zero, inflateBack() will return with an error. Neither in() nor out() are permitted to change the contents of the window provided to inflateBackInit(), which is also the buffer that out() uses to write from. The length written by out() will be at most the window size. Any non-zero amount of input may be provided by in(). For convenience, inflateBack() can be provided input on the first call by setting strm->next_in and strm->avail_in. If that input is exhausted, then in() will be called. Therefore strm->next_in must be initialized before calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in must also be initialized, and then if strm->avail_in is not zero, input will initially be taken from strm->next_in[0 .. strm->avail_in - 1]. The in_desc and out_desc parameters of inflateBack() is passed as the first parameter of in() and out() respectively when they are called. These descriptors can be optionally used to pass any information that the caller- supplied in() and out() functions need to do their job. On return, inflateBack() will set strm->next_in and strm->avail_in to pass back any unused input that was provided by the last in() call. The return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR if in() or out() returned an error, Z_DATA_ERROR if there was a format error in the deflate stream (in which case strm->msg is set to indicate the nature of the error), or Z_STREAM_ERROR if the stream was not properly initialized. In the case of Z_BUF_ERROR, an input or output error can be distinguished using strm->next_in which will be Z_NULL only if in() returned an error. If strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning non-zero. (in() will always be called before out(), so strm->next_in is assured to be defined if out() returns non-zero.) Note that inflateBack() cannot return Z_OK. / ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); / All memory allocated by inflateBackInit() is freed. inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream state was inconsistent. / ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); / Return flags indicating compile-time options. Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: 1.0: size of uInt 3.2: size of uLong 5.4: size of voidpf (pointer) 7.6: size of z_off_t Compiler, assembler, and debug options: 8: ZLIB_DEBUG 9: ASMV or ASMINF -- use ASM code 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention 11: 0 (reserved) One-time table building (smaller code, but not thread-safe if true): 12: BUILDFIXED -- build static block decoding tables when needed 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed 14,15: 0 (reserved) Library content (indicates missing functionality): 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking deflate code when not needed) 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect and decode gzip streams (to avoid linking crc code) 18-19: 0 (reserved) Operation variations (changes in library functionality): 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate 21: FASTEST -- deflate algorithm with only one, lowest compression level 22,23: 0 (reserved) The sprintf variant used by gzprintf (zero is best): 24: 0 = vs, 1 = s -- 1 means limited to 20 arguments after the format 25: 0 = nprintf, 1 = printf -- 1 means gzprintf() not secure! 26: 0 = returns value, 1 = void -- 1 means inferred string length returned Remainder: 27-31: 0 (reserved) / #ifndef Z_SOLO / utility functions / / The following utility functions are implemented on top of the basic stream-oriented functions. To simplify the interface, some default options are assumed (compression level and memory usage, standard memory allocation functions). The source code of these utility functions can be modified if you need special options. / ZEXTERN int ZEXPORT compress OF((Bytef dest, uLongf destLen, const Bytef source, uLong sourceLen)); /* Compresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total size of the destination buffer, which must be at least the value returned by compressBound(sourceLen). Upon exit, destLen is the actual size of the compressed data. compress() is equivalent to compress2() with a level parameter of Z_DEFAULT_COMPRESSION. compress returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if there was not enough room in the output buffer. / ZEXTERN int ZEXPORT compress2 OF((Bytef dest, uLongf destLen, const Bytef source, uLong sourceLen, int level)); /* Compresses the source buffer into the destination buffer. The level parameter has the same meaning as in deflateInit. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total size of the destination buffer, which must be at least the value returned by compressBound(sourceLen). Upon exit, destLen is the actual size of the compressed data. compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if there was not enough room in the output buffer, Z_STREAM_ERROR if the level parameter is invalid. / ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); / compressBound() returns an upper bound on the compressed size after compress() or compress2() on sourceLen bytes. It would be used before a compress() or compress2() call to allocate the destination buffer. / ZEXTERN int ZEXPORT uncompress OF((Bytef dest, uLongf destLen, const Bytef source, uLong sourceLen)); /* Decompresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total size of the destination buffer, which must be large enough to hold the entire uncompressed data. (The size of the uncompressed data must have been saved previously by the compressor and transmitted to the decompressor by some mechanism outside the scope of this compression library.) Upon exit, destLen is the actual size of the uncompressed data. uncompress returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if there was not enough room in the output buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. In the case where there is not enough room, uncompress() will fill the output buffer with the uncompressed data up to that point. / ZEXTERN int ZEXPORT uncompress2 OF((Bytef dest, uLongf destLen, const Bytef source, uLong sourceLen)); / Same as uncompress, except that sourceLen is a pointer, where the length of the source is sourceLen. On return, sourceLen is the number of source bytes consumed. / / gzip file access functions / / This library supports reading and writing files in gzip (.gz) format with an interface similar to that of stdio, using the functions that start with "gz". The gzip format is different from the zlib format. gzip is a gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. / typedef struct gzFile_s gzFile; /* semi-opaque gzip file descriptor / / ZEXTERN gzFile ZEXPORT gzopen OF((const char path, const char mode)); Opens a gzip (.gz) file for reading or writing. The mode parameter is as in fopen ("rb" or "wb") but can also include a compression level ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F' for fixed code compression as in "wb9F". (See the description of deflateInit2 for more information about the strategy parameter.) 'T' will request transparent writing or appending with no compression and not using the gzip format. "a" can be used instead of "w" to request that the gzip stream that will be written be appended to the file. "+" will result in an error, since reading and writing to the same gzip file is not supported. The addition of "x" when writing will create the file exclusively, which fails if the file already exists. On systems that support it, the addition of "e" when reading or writing will set the flag to close the file on an execve() call. These functions, as well as gzip, will read and decode a sequence of gzip streams in a file. The append function of gzopen() can be used to create such a file. (Also see gzflush() for another way to do this.) When appending, gzopen does not test whether the file begins with a gzip stream, nor does it look for the end of the gzip streams to begin appending. gzopen will simply append a gzip stream to the existing file. gzopen can be used to read a file which is not in gzip format; in this case gzread will directly read from the file without decompression. When reading, this will be detected automatically by looking for the magic two- byte gzip header. gzopen returns NULL if the file could not be opened, if there was insufficient memory to allocate the gzFile state, or if an invalid mode was specified (an 'r', 'w', or 'a' was not provided, or '+' was provided). errno can be checked to determine if the reason gzopen failed was that the file could not be opened. / ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char mode)); /* gzdopen associates a gzFile with the file descriptor fd. File descriptors are obtained from calls like open, dup, creat, pipe or fileno (if the file has been previously opened with fopen). The mode parameter is as in gzopen. The next call of gzclose on the returned gzFile will also close the file descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor fd. If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd, mode);. The duplicated descriptor should be saved to avoid a leak, since gzdopen does not close fd if it fails. If you are using fileno() to get the file descriptor from a FILE , then you will have to use dup() to avoid double-close()ing the file descriptor. Both gzclose() and fclose() will close the associated file descriptor, so they need to have different file descriptors. gzdopen returns NULL if there was insufficient memory to allocate the gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not provided, or '+' was provided), or if fd is -1. The file descriptor is not used until the next gz read, write, seek, or close operation, so gzdopen will not detect if fd is invalid (unless fd is -1). / ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); / Set the internal buffer size used by this library's functions. The default buffer size is 8192 bytes. This function must be called after gzopen() or gzdopen(), and before any other calls that read or write the file. The buffer memory allocation is always deferred to the first read or write. Three times that size in buffer space is allocated. A larger buffer size of, for example, 64K or 128K bytes will noticeably increase the speed of decompression (reading). The new buffer size also affects the maximum length for gzprintf(). gzbuffer() returns 0 on success, or -1 on failure, such as being called too late. / ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); / Dynamically update the compression level or strategy. See the description of deflateInit2 for the meaning of these parameters. Previously provided data is flushed before the parameter change. gzsetparams returns Z_OK if success, Z_STREAM_ERROR if the file was not opened for writing, Z_ERRNO if there is an error writing the flushed data, or Z_MEM_ERROR if there is a memory allocation error. / ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); / Reads the given number of uncompressed bytes from the compressed file. If the input file is not in gzip format, gzread copies the given number of bytes into the buffer directly from the file. After reaching the end of a gzip stream in the input, gzread will continue to read, looking for another gzip stream. Any number of gzip streams may be concatenated in the input file, and will all be decompressed by gzread(). If something other than a gzip stream is encountered after a gzip stream, that remaining trailing garbage is ignored (and no error is returned). gzread can be used to read a gzip file that is being concurrently written. Upon reaching the end of the input, gzread will return with the available data. If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then gzclearerr can be used to clear the end of file indicator in order to permit gzread to be tried again. Z_OK indicates that a gzip stream was completed on the last gzread. Z_BUF_ERROR indicates that the input file ended in the middle of a gzip stream. Note that gzread does not return -1 in the event of an incomplete gzip stream. This error is deferred until gzclose(), which will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip stream. Alternatively, gzerror can be used before gzclose to detect this case. gzread returns the number of uncompressed bytes actually read, less than len for end of file, or -1 for error. If len is too large to fit in an int, then nothing is read, -1 is returned, and the error state is set to Z_STREAM_ERROR. / ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems, gzFile file)); / Read up to nitems items of size size from file to buf, otherwise operating as gzread() does. This duplicates the interface of stdio's fread(), with size_t request and return types. If the library defines size_t, then z_size_t is identical to size_t. If not, then z_size_t is an unsigned integer type that can contain a pointer. gzfread() returns the number of full items read of size size, or zero if the end of the file was reached and a full item could not be read, or if there was an error. gzerror() must be consulted if zero is returned in order to determine if there was an error. If the multiplication of size and nitems overflows, i.e. the product does not fit in a z_size_t, then nothing is read, zero is returned, and the error state is set to Z_STREAM_ERROR. In the event that the end of file is reached and only a partial item is available at the end, i.e. the remaining uncompressed data length is not a multiple of size, then the final partial item is nevetheless read into buf and the end-of-file flag is set. The length of the partial item read is not provided, but could be inferred from the result of gztell(). This behavior is the same as the behavior of fread() implementations in common libraries, but it prevents the direct use of gzfread() to read a concurrently written file, reseting and retrying on end-of-file, when size is not 1. / ZEXTERN int ZEXPORT gzwrite OF((gzFile file, voidpc buf, unsigned len)); / Writes the given number of uncompressed bytes into the compressed file. gzwrite returns the number of uncompressed bytes written or 0 in case of error. / ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size, z_size_t nitems, gzFile file)); / gzfwrite() writes nitems items of size size from buf to file, duplicating the interface of stdio's fwrite(), with size_t request and return types. If the library defines size_t, then z_size_t is identical to size_t. If not, then z_size_t is an unsigned integer type that can contain a pointer. gzfwrite() returns the number of full items written of size size, or zero if there was an error. If the multiplication of size and nitems overflows, i.e. the product does not fit in a z_size_t, then nothing is written, zero is returned, and the error state is set to Z_STREAM_ERROR. / ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char format, ...)); /* Converts, formats, and writes the arguments to the compressed file under control of the format string, as in fprintf. gzprintf returns the number of uncompressed bytes actually written, or a negative zlib error code in case of error. The number of uncompressed bytes written is limited to 8191, or one less than the buffer size given to gzbuffer(). The caller should assure that this limit is not exceeded. If it is exceeded, then gzprintf() will return an error (0) with nothing written. In this case, there may also be a buffer overflow with unpredictable consequences, which is possible only if zlib was compiled with the insecure functions sprintf() or vsprintf() because the secure snprintf() or vsnprintf() functions were not available. This can be determined using zlibCompileFlags(). / ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char s)); /* Writes the given null-terminated string to the compressed file, excluding the terminating null character. gzputs returns the number of characters written, or -1 in case of error. / ZEXTERN char ZEXPORT gzgets OF((gzFile file, char buf, int len)); / Reads bytes from the compressed file until len-1 characters are read, or a newline character is read and transferred to buf, or an end-of-file condition is encountered. If any characters are read or if len == 1, the string is terminated with a null character. If no characters are read due to an end-of-file or len < 1, then the buffer is left untouched. gzgets returns buf which is a null-terminated string, or it returns NULL for end-of-file or in case of error. If there was an error, the contents at buf are indeterminate. / ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); / Writes c, converted to an unsigned char, into the compressed file. gzputc returns the value that was written, or -1 in case of error. / ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); / Reads one byte from the compressed file. gzgetc returns this byte or -1 in case of end of file or error. This is implemented as a macro for speed. As such, it does not do all of the checking the other functions do. I.e. it does not check to see if file is NULL, nor whether the structure file points to has been clobbered or not. / ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); / Push one character back onto the stream to be read as the first character on the next read. At least one character of push-back is allowed. gzungetc() returns the character pushed, or -1 on failure. gzungetc() will fail if c is -1, and may fail if a character has been pushed but not read yet. If gzungetc is used immediately after gzopen or gzdopen, at least the output buffer size of pushed characters is allowed. (See gzbuffer above.) The pushed character will be discarded if the stream is repositioned with gzseek() or gzrewind(). / ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); / Flushes all pending output into the compressed file. The parameter flush is as in the deflate() function. The return value is the zlib error number (see function gzerror below). gzflush is only permitted when writing. If the flush parameter is Z_FINISH, the remaining data is written and the gzip stream is completed in the output. If gzwrite() is called again, a new gzip stream will be started in the output. gzread() is able to read such concatenated gzip streams. gzflush should be called only when strictly necessary because it will degrade compression if called too often. / / ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, z_off_t offset, int whence)); Sets the starting position for the next gzread or gzwrite on the given compressed file. The offset represents a number of bytes in the uncompressed data stream. The whence parameter is defined as in lseek(2); the value SEEK_END is not supported. If the file is opened for reading, this function is emulated but can be extremely slow. If the file is opened for writing, only forward seeks are supported; gzseek then compresses a sequence of zeroes up to the new starting position. gzseek returns the resulting offset location as measured in bytes from the beginning of the uncompressed stream, or -1 in case of error, in particular if the file is opened for writing and the new starting position would be before the current position. / ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); / Rewinds the given file. This function is supported only for reading. gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) / / ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); Returns the starting position for the next gzread or gzwrite on the given compressed file. This position represents a number of bytes in the uncompressed data stream, and is zero when starting, even if appending or reading a gzip stream from the middle of a file using gzdopen(). gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) / / ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file)); Returns the current offset in the file being read or written. This offset includes the count of bytes that precede the gzip stream, for example when appending or when using gzdopen() for reading. When reading, the offset does not include as yet unused buffered input. This information can be used for a progress indicator. On error, gzoffset() returns -1. / ZEXTERN int ZEXPORT gzeof OF((gzFile file)); / Returns true (1) if the end-of-file indicator has been set while reading, false (0) otherwise. Note that the end-of-file indicator is set only if the read tried to go past the end of the input, but came up short. Therefore, just like feof(), gzeof() may return false even if there is no more data to read, in the event that the last read request was for the exact number of bytes remaining in the input file. This will happen if the input file size is an exact multiple of the buffer size. If gzeof() returns true, then the read functions will return no more data, unless the end-of-file indicator is reset by gzclearerr() and the input file has grown since the previous end of file was detected. / ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); / Returns true (1) if file is being copied directly while reading, or false (0) if file is a gzip stream being decompressed. If the input file is empty, gzdirect() will return true, since the input does not contain a gzip stream. If gzdirect() is used immediately after gzopen() or gzdopen() it will cause buffers to be allocated to allow reading the file to determine if it is a gzip file. Therefore if gzbuffer() is used, it should be called before gzdirect(). When writing, gzdirect() returns true (1) if transparent writing was requested ("wT" for the gzopen() mode), or false (0) otherwise. (Note: gzdirect() is not needed when writing. Transparent writing must be explicitly requested, so the application already knows the answer. When linking statically, using gzdirect() will include all of the zlib code for gzip file reading and decompression, which may not be desired.) / ZEXTERN int ZEXPORT gzclose OF((gzFile file)); / Flushes all pending output if necessary, closes the compressed file and deallocates the (de)compression state. Note that once file is closed, you cannot call gzerror with file, since its structures have been deallocated. gzclose must not be called more than once on the same file, just as free must not be called more than once on the same allocation. gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the last read ended in the middle of a gzip stream, or Z_OK on success. / ZEXTERN int ZEXPORT gzclose_r OF((gzFile file)); ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); / Same as gzclose(), but gzclose_r() is only for use when reading, and gzclose_w() is only for use when writing or appending. The advantage to using these instead of gzclose() is that they avoid linking in zlib compression or decompression code that is not used when only reading or only writing respectively. If gzclose() is used, then both compression and decompression code will be included the application when linking to a static zlib library. / ZEXTERN const char ZEXPORT gzerror OF((gzFile file, int errnum)); / Returns the error message for the last error which occurred on the given compressed file. errnum is set to zlib error number. If an error occurred in the file system and not in the compression library, errnum is set to Z_ERRNO and the application may consult errno to get the exact error code. The application must not modify the returned string. Future calls to this function may invalidate the previously returned string. If file is closed, then the string previously returned by gzerror will no longer be available. gzerror() should be used to distinguish errors from end-of-file for those functions above that do not distinguish those cases in their return values. / ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); / Clears the error and end-of-file flags for file. This is analogous to the clearerr() function in stdio. This is useful for continuing to read a gzip file that is being written concurrently. / #endif / !Z_SOLO / / checksum functions / / These functions are not related to compression but are exported anyway because they might be useful in applications using the compression library. / ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef buf, uInt len)); /* Update a running Adler-32 checksum with the bytes buf[0..len-1] and return the updated checksum. If buf is Z_NULL, this function returns the required initial value for the checksum. An Adler-32 checksum is almost as reliable as a CRC-32 but can be computed much faster. Usage example: uLong adler = adler32(0L, Z_NULL, 0); while (read_buffer(buffer, length) != EOF) { adler = adler32(adler, buffer, length); } if (adler != original_adler) error(); / ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef buf, z_size_t len)); /* Same as adler32(), but with a size_t length. / / ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, z_off_t len2)); Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. Note that the z_off_t type (like off_t) is a signed integer. If len2 is negative, the result has no meaning or utility. / ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef buf, uInt len)); /* Update a running CRC-32 with the bytes buf[0..len-1] and return the updated CRC-32. If buf is Z_NULL, this function returns the required initial value for the crc. Pre- and post-conditioning (one's complement) is performed within this function so it shouldn't be done by the application. Usage example: uLong crc = crc32(0L, Z_NULL, 0); while (read_buffer(buffer, length) != EOF) { crc = crc32(crc, buffer, length); } if (crc != original_crc) error(); / ZEXTERN uLong ZEXPORT crc32_z OF((uLong adler, const Bytef buf, z_size_t len)); /* Same as crc32(), but with a size_t length. / / ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); Combine two CRC-32 check values into one. For two sequences of bytes, seq1 and seq2 with lengths len1 and len2, CRC-32 check values were calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32 check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and len2. / / various hacks, don't look :) / / deflateInit and inflateInit are macros to allow checking the zlib version * and the compiler's view of z_stream: / ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, const char version, int stream_size)); ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, const char version, int stream_size)); ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, int windowBits, int memLevel, int strategy, const char version, int stream_size)); ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, const char version, int stream_size)); ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, unsigned char FAR window, const char version, int stream_size)); #ifdef Z_PREFIX_SET # define z_deflateInit(strm, level) \ deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) # define z_inflateInit(strm) \ inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream)) # define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ (strategy), ZLIB_VERSION, (int)sizeof(z_stream)) # define z_inflateInit2(strm, windowBits) \ inflateInit2_((strm), (windowBits), ZLIB_VERSION, \ (int)sizeof(z_stream)) # define z_inflateBackInit(strm, windowBits, window) \ inflateBackInit_((strm), (windowBits), (window), \ ZLIB_VERSION, (int)sizeof(z_stream)) #else # define deflateInit(strm, level) \ deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) # define inflateInit(strm) \ inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream)) # define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ (strategy), ZLIB_VERSION, (int)sizeof(z_stream)) # define inflateInit2(strm, windowBits) \ inflateInit2_((strm), (windowBits), ZLIB_VERSION, \ (int)sizeof(z_stream)) # define inflateBackInit(strm, windowBits, window) \ inflateBackInit_((strm), (windowBits), (window), \ ZLIB_VERSION, (int)sizeof(z_stream)) #endif #ifndef Z_SOLO / gzgetc() macro and its supporting function and exposed data structure. Note * that the real internal state is much larger than the exposed structure. * This abbreviated structure exposes just enough for the gzgetc() macro. The * user should not mess with these exposed elements, since their names or * behavior could change in the future, perhaps even capriciously. They can * only be used by the gzgetc() macro. You have been warned. / struct gzFile_s { unsigned have; unsigned char next; z_off64_t pos; }; ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility / #ifdef Z_PREFIX_SET # undef z_gzgetc # define z_gzgetc(g) \ ((g)->have ? ((g)->have--, (g)->pos++, ((g)->next)++) : (gzgetc)(g)) #else # define gzgetc(g) \ ((g)->have ? ((g)->have--, (g)->pos++, ((g)->next)++) : (gzgetc)(g)) #endif / provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if * both are true, the application gets the 64 functions, and the regular functions are changed to 64 bits) -- in case these are set on systems * without large file support, _LFS64_LARGEFILE must also be true / #ifdef Z_LARGE64 ZEXTERN gzFile ZEXPORT gzopen64 OF((const char , const char )); ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t)); ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t)); #endif #if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) # ifdef Z_PREFIX_SET # define z_gzopen z_gzopen64 # define z_gzseek z_gzseek64 # define z_gztell z_gztell64 # define z_gzoffset z_gzoffset64 # define z_adler32_combine z_adler32_combine64 # define z_crc32_combine z_crc32_combine64 # else # define gzopen gzopen64 # define gzseek gzseek64 # define gztell gztell64 # define gzoffset gzoffset64 # define adler32_combine adler32_combine64 # define crc32_combine crc32_combine64 # endif # ifndef Z_LARGE64 ZEXTERN gzFile ZEXPORT gzopen64 OF((const char , const char )); ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int)); ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile)); ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile)); ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); # endif #else ZEXTERN gzFile ZEXPORT gzopen OF((const char , const char )); ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int)); ZEXTERN z_off_t ZEXPORT gztell OF((gzFile)); ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile)); ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); #endif #else / Z_SOLO / ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); #endif / !Z_SOLO / / undocumented functions / ZEXTERN const char ZEXPORT zError OF((int)); ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp)); ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void)); ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); ZEXTERN int ZEXPORT inflateValidate OF((z_streamp, int)); ZEXTERN unsigned long ZEXPORT inflateCodesUsed OF ((z_streamp)); ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp)); ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp)); #if (defined(_WIN32) \|\| defined(__CYGWIN__)) && !defined(Z_SOLO) ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t path, const char mode)); #endif #if defined(STDC) \|\| defined(Z_HAVE_STDARG_H) # ifndef Z_SOLO ZEXTERN int ZEXPORTVA gzvprintf Z_ARG((gzFile file, const char format, va_list va)); # endif #endif #ifdef __cplusplus } #endif #endif / ZLIB_H */	94 KB	2023-09-26 09:22
📄 zstd.h /* * Copyright (c) Meta Platforms, Inc. and affiliates. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. / #if defined (__cplusplus) extern "C" { #endif #ifndef ZSTD_H_235446 #define ZSTD_H_235446 / ====== Dependencies ======/ #include <limits.h> / INT_MAX / #include <stddef.h> / size_t / / ===== ZSTDLIB_API : control library symbols visibility ===== / #ifndef ZSTDLIB_VISIBLE / Backwards compatibility with old macro name / # ifdef ZSTDLIB_VISIBILITY # define ZSTDLIB_VISIBLE ZSTDLIB_VISIBILITY # elif defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__) # define ZSTDLIB_VISIBLE __attribute__ ((visibility ("default"))) # else # define ZSTDLIB_VISIBLE # endif #endif #ifndef ZSTDLIB_HIDDEN # if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__) # define ZSTDLIB_HIDDEN __attribute__ ((visibility ("hidden"))) # else # define ZSTDLIB_HIDDEN # endif #endif #if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1) # define ZSTDLIB_API __declspec(dllexport) ZSTDLIB_VISIBLE #elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1) # define ZSTDLIB_API __declspec(dllimport) ZSTDLIB_VISIBLE / It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump./ #else # define ZSTDLIB_API ZSTDLIB_VISIBLE #endif / Deprecation warnings : * Should these warnings be a problem, it is generally possible to disable them, * typically with -Wno-deprecated-declarations for gcc or _CRT_SECURE_NO_WARNINGS in Visual. * Otherwise, it's also possible to define ZSTD_DISABLE_DEPRECATE_WARNINGS. / #ifdef ZSTD_DISABLE_DEPRECATE_WARNINGS # define ZSTD_DEPRECATED(message) / disable deprecation warnings / #else # if defined (__cplusplus) && (__cplusplus >= 201402) / C++14 or greater / # define ZSTD_DEPRECATED(message) [[deprecated(message)]] # elif (defined(GNUC) && (GNUC > 4 \|\| (GNUC == 4 && GNUC_MINOR >= 5))) \|\| defined(__clang__) # define ZSTD_DEPRECATED(message) __attribute__((deprecated(message))) # elif defined(__GNUC__) && (__GNUC__ >= 3) # define ZSTD_DEPRECATED(message) __attribute__((deprecated)) # elif defined(_MSC_VER) # define ZSTD_DEPRECATED(message) __declspec(deprecated(message)) # else # pragma message("WARNING: You need to implement ZSTD_DEPRECATED for this compiler") # define ZSTD_DEPRECATED(message) # endif #endif / ZSTD_DISABLE_DEPRECATE_WARNINGS / /**************************************************************************** Introduction zstd, short for Zstandard, is a fast lossless compression algorithm, targeting real-time compression scenarios at zlib-level and better compression ratios. The zstd compression library provides in-memory compression and decompression functions. The library supports regular compression levels from 1 up to ZSTD_maxCLevel(), which is currently 22. Levels >= 20, labeled `--ultra`, should be used with caution, as they require more memory. The library also offers negative compression levels, which extend the range of speed vs. ratio preferences. The lower the level, the faster the speed (at the cost of compression). Compression can be done in: - a single step (described as Simple API) - a single step, reusing a context (described as Explicit context) - unbounded multiple steps (described as Streaming compression) The compression ratio achievable on small data can be highly improved using a dictionary. Dictionary compression can be performed in: - a single step (described as Simple dictionary API) - a single step, reusing a dictionary (described as Bulk-processing dictionary API) Advanced experimental functions can be accessed using `#define ZSTD_STATIC_LINKING_ONLY` before including zstd.h. Advanced experimental APIs should never be used with a dynamically-linked library. They are not "stable"; their definitions or signatures may change in the future. Only static linking is allowed. ****************************************************************************/ /------ Version ------/ #define ZSTD_VERSION_MAJOR 1 #define ZSTD_VERSION_MINOR 5 #define ZSTD_VERSION_RELEASE 5 #define ZSTD_VERSION_NUMBER (ZSTD_VERSION_MAJOR 100100 + ZSTD_VERSION_MINOR 100 + ZSTD_VERSION_RELEASE) /! ZSTD_versionNumber() : Return runtime library version, the value is (MAJOR100100 + MINOR100 + RELEASE). / ZSTDLIB_API unsigned ZSTD_versionNumber(void); #define ZSTD_LIB_VERSION ZSTD_VERSION_MAJOR.ZSTD_VERSION_MINOR.ZSTD_VERSION_RELEASE #define ZSTD_QUOTE(str) #str #define ZSTD_EXPAND_AND_QUOTE(str) ZSTD_QUOTE(str) #define ZSTD_VERSION_STRING ZSTD_EXPAND_AND_QUOTE(ZSTD_LIB_VERSION) /! ZSTD_versionString() : Return runtime library version, like "1.4.5". Requires v1.3.0+. / ZSTDLIB_API const char ZSTD_versionString(void); /* ************************************* * Default constant **************************************/ #ifndef ZSTD_CLEVEL_DEFAULT # define ZSTD_CLEVEL_DEFAULT 3 #endif / ************************************* * Constants **************************************/ / All magic numbers are supposed read/written to/from files/memory using little-endian convention / #define ZSTD_MAGICNUMBER 0xFD2FB528 / valid since v0.8.0 / #define ZSTD_MAGIC_DICTIONARY 0xEC30A437 / valid since v0.7.0 / #define ZSTD_MAGIC_SKIPPABLE_START 0x184D2A50 / all 16 values, from 0x184D2A50 to 0x184D2A5F, signal the beginning of a skippable frame / #define ZSTD_MAGIC_SKIPPABLE_MASK 0xFFFFFFF0 #define ZSTD_BLOCKSIZELOG_MAX 17 #define ZSTD_BLOCKSIZE_MAX (1<<ZSTD_BLOCKSIZELOG_MAX) /************************************** * Simple API **************************************/ /! ZSTD_compress() : * Compresses `src` content as a single zstd compressed frame into already allocated `dst`. * NOTE: Providing `dstCapacity >= ZSTD_compressBound(srcSize)` guarantees that zstd will have * enough space to successfully compress the data. * @return : compressed size written into `dst` (<= `dstCapacity), * or an error code if it fails (which can be tested using ZSTD_isError()). / ZSTDLIB_API size_t ZSTD_compress( void dst, size_t dstCapacity, const void* src, size_t srcSize, int compressionLevel); /! ZSTD_decompress() : `compressedSize` : must be the _exact_ size of some number of compressed and/or skippable frames. * `dstCapacity` is an upper bound of originalSize to regenerate. * If user cannot imply a maximum upper bound, it's better to use streaming mode to decompress data. * @return : the number of bytes decompressed into `dst` (<= `dstCapacity`), * or an errorCode if it fails (which can be tested using ZSTD_isError()). / ZSTDLIB_API size_t ZSTD_decompress( void dst, size_t dstCapacity, const void* src, size_t compressedSize); /! ZSTD_getFrameContentSize() : requires v1.3.0+ `src` should point to the start of a ZSTD encoded frame. * `srcSize` must be at least as large as the frame header. * hint : any size >= `ZSTD_frameHeaderSize_max` is large enough. * @return : - decompressed size of `src` frame content, if known * - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined * - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small) * note 1 : a 0 return value means the frame is valid but "empty". * note 2 : decompressed size is an optional field, it may not be present, typically in streaming mode. * When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size. * In which case, it's necessary to use streaming mode to decompress data. * Optionally, application can rely on some implicit limit, * as ZSTD_decompress() only needs an upper bound of decompressed size. * (For example, data could be necessarily cut into blocks <= 16 KB). * note 3 : decompressed size is always present when compression is completed using single-pass functions, * such as ZSTD_compress(), ZSTD_compressCCtx() ZSTD_compress_usingDict() or ZSTD_compress_usingCDict(). * note 4 : decompressed size can be very large (64-bits value), * potentially larger than what local system can handle as a single memory segment. * In which case, it's necessary to use streaming mode to decompress data. * note 5 : If source is untrusted, decompressed size could be wrong or intentionally modified. * Always ensure return value fits within application's authorized limits. * Each application can set its own limits. * note 6 : This function replaces ZSTD_getDecompressedSize() / #define ZSTD_CONTENTSIZE_UNKNOWN (0ULL - 1) #define ZSTD_CONTENTSIZE_ERROR (0ULL - 2) ZSTDLIB_API unsigned long long ZSTD_getFrameContentSize(const void src, size_t srcSize); /! ZSTD_getDecompressedSize() : NOTE: This function is now obsolete, in favor of ZSTD_getFrameContentSize(). * Both functions work the same way, but ZSTD_getDecompressedSize() blends * "empty", "unknown" and "error" results to the same return value (0), * while ZSTD_getFrameContentSize() gives them separate return values. * @return : decompressed size of `src` frame content _if known and not empty_, 0 otherwise. / ZSTD_DEPRECATED("Replaced by ZSTD_getFrameContentSize") ZSTDLIB_API unsigned long long ZSTD_getDecompressedSize(const void src, size_t srcSize); /! ZSTD_findFrameCompressedSize() : Requires v1.4.0+ `src` should point to the start of a ZSTD frame or skippable frame. * `srcSize` must be >= first frame size * @return : the compressed size of the first frame starting at `src`, * suitable to pass as `srcSize` to `ZSTD_decompress` or similar, * or an error code if input is invalid / ZSTDLIB_API size_t ZSTD_findFrameCompressedSize(const void src, size_t srcSize); /====== Helper functions ======/ /* ZSTD_compressBound() : * maximum compressed size in worst case single-pass scenario. * When invoking `ZSTD_compress()` or any other one-pass compression function, * it's recommended to provide @dstCapacity >= ZSTD_compressBound(srcSize) * as it eliminates one potential failure scenario, * aka not enough room in dst buffer to write the compressed frame. * Note : ZSTD_compressBound() itself can fail, if @srcSize > ZSTD_MAX_INPUT_SIZE . * In which case, ZSTD_compressBound() will return an error code * which can be tested using ZSTD_isError(). * * ZSTD_COMPRESSBOUND() : * same as ZSTD_compressBound(), but as a macro. * It can be used to produce constants, which can be useful for static allocation, * for example to size a static array on stack. * Will produce constant value 0 if srcSize too large. / #define ZSTD_MAX_INPUT_SIZE ((sizeof(size_t)==8) ? 0xFF00FF00FF00FF00LLU : 0xFF00FF00U) #define ZSTD_COMPRESSBOUND(srcSize) (((size_t)(srcSize) >= ZSTD_MAX_INPUT_SIZE) ? 0 : (srcSize) + ((srcSize)>>8) + (((srcSize) < (128<<10)) ? (((128<<10) - (srcSize)) >> 11) / margin, from 64 to 0 / : 0)) / this formula ensures that bound(A) + bound(B) <= bound(A+B) as long as A and B >= 128 KB / ZSTDLIB_API size_t ZSTD_compressBound(size_t srcSize); /!< maximum compressed size in worst case single-pass scenario / / ZSTD_isError() : * Most ZSTD_* functions returning a size_t value can be tested for error, * using ZSTD_isError(). * @return 1 if error, 0 otherwise / ZSTDLIB_API unsigned ZSTD_isError(size_t code); /!< tells if a `size_t` function result is an error code / ZSTDLIB_API const char ZSTD_getErrorName(size_t code); /!< provides readable string from an error code / ZSTDLIB_API int ZSTD_minCLevel(void); /!< minimum negative compression level allowed, requires v1.4.0+ / ZSTDLIB_API int ZSTD_maxCLevel(void); /!< maximum compression level available / ZSTDLIB_API int ZSTD_defaultCLevel(void); /!< default compression level, specified by ZSTD_CLEVEL_DEFAULT, requires v1.5.0+ / /*************************************** * Explicit context **************************************/ /= Compression context * When compressing many times, * it is recommended to allocate a context just once, * and re-use it for each successive compression operation. * This will make workload friendlier for system's memory. * Note : re-using context is just a speed / resource optimization. * It doesn't change the compression ratio, which remains identical. * Note 2 : In multi-threaded environments, * use one different context per thread for parallel execution. / typedef struct ZSTD_CCtx_s ZSTD_CCtx; ZSTDLIB_API ZSTD_CCtx ZSTD_createCCtx(void); ZSTDLIB_API size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx); /* accept NULL pointer / /! ZSTD_compressCCtx() : * Same as ZSTD_compress(), using an explicit ZSTD_CCtx. * Important : in order to behave similarly to `ZSTD_compress()`, * this function compresses at requested compression level, * __ignoring any other parameter__ . * If any advanced parameter was set using the advanced API, * they will all be reset. Only `compressionLevel` remains. / ZSTDLIB_API size_t ZSTD_compressCCtx(ZSTD_CCtx cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, int compressionLevel); /= Decompression context When decompressing many times, * it is recommended to allocate a context only once, * and re-use it for each successive compression operation. * This will make workload friendlier for system's memory. * Use one context per thread for parallel execution. / typedef struct ZSTD_DCtx_s ZSTD_DCtx; ZSTDLIB_API ZSTD_DCtx ZSTD_createDCtx(void); ZSTDLIB_API size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx); /* accept NULL pointer / /! ZSTD_decompressDCtx() : * Same as ZSTD_decompress(), * requires an allocated ZSTD_DCtx. * Compatible with sticky parameters. / ZSTDLIB_API size_t ZSTD_decompressDCtx(ZSTD_DCtx dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); /********************************************* * Advanced compression API (Requires v1.4.0+) *********************************************/ / API design : * Parameters are pushed one by one into an existing context, * using ZSTD_CCtx_set() functions. Pushed parameters are sticky : they are valid for next compressed frame, and any subsequent frame. * "sticky" parameters are applicable to `ZSTD_compress2()` and `ZSTD_compressStream()` ! __They do not apply to "simple" one-shot variants such as ZSTD_compressCCtx()__ . * * It's possible to reset all parameters to "default" using ZSTD_CCtx_reset(). * * This API supersedes all other "advanced" API entry points in the experimental section. * In the future, we expect to remove from experimental API entry points which are redundant with this API. / / Compression strategies, listed from fastest to strongest / typedef enum { ZSTD_fast=1, ZSTD_dfast=2, ZSTD_greedy=3, ZSTD_lazy=4, ZSTD_lazy2=5, ZSTD_btlazy2=6, ZSTD_btopt=7, ZSTD_btultra=8, ZSTD_btultra2=9 / note : new strategies _might_ be added in the future. Only the order (from fast to strong) is guaranteed / } ZSTD_strategy; typedef enum { / compression parameters * Note: When compressing with a ZSTD_CDict these parameters are superseded * by the parameters used to construct the ZSTD_CDict. * See ZSTD_CCtx_refCDict() for more info (superseded-by-cdict). / ZSTD_c_compressionLevel=100, / Set compression parameters according to pre-defined cLevel table. * Note that exact compression parameters are dynamically determined, * depending on both compression level and srcSize (when known). * Default level is ZSTD_CLEVEL_DEFAULT==3. * Special: value 0 means default, which is controlled by ZSTD_CLEVEL_DEFAULT. * Note 1 : it's possible to pass a negative compression level. * Note 2 : setting a level does not automatically set all other compression parameters * to default. Setting this will however eventually dynamically impact the compression * parameters which have not been manually set. The manually set * ones will 'stick'. / / Advanced compression parameters : * It's possible to pin down compression parameters to some specific values. * In which case, these values are no longer dynamically selected by the compressor / ZSTD_c_windowLog=101, / Maximum allowed back-reference distance, expressed as power of 2. * This will set a memory budget for streaming decompression, * with larger values requiring more memory * and typically compressing more. * Must be clamped between ZSTD_WINDOWLOG_MIN and ZSTD_WINDOWLOG_MAX. * Special: value 0 means "use default windowLog". * Note: Using a windowLog greater than ZSTD_WINDOWLOG_LIMIT_DEFAULT * requires explicitly allowing such size at streaming decompression stage. / ZSTD_c_hashLog=102, / Size of the initial probe table, as a power of 2. * Resulting memory usage is (1 << (hashLog+2)). * Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX. * Larger tables improve compression ratio of strategies <= dFast, * and improve speed of strategies > dFast. * Special: value 0 means "use default hashLog". / ZSTD_c_chainLog=103, / Size of the multi-probe search table, as a power of 2. * Resulting memory usage is (1 << (chainLog+2)). * Must be clamped between ZSTD_CHAINLOG_MIN and ZSTD_CHAINLOG_MAX. * Larger tables result in better and slower compression. * This parameter is useless for "fast" strategy. * It's still useful when using "dfast" strategy, * in which case it defines a secondary probe table. * Special: value 0 means "use default chainLog". / ZSTD_c_searchLog=104, / Number of search attempts, as a power of 2. * More attempts result in better and slower compression. * This parameter is useless for "fast" and "dFast" strategies. * Special: value 0 means "use default searchLog". / ZSTD_c_minMatch=105, / Minimum size of searched matches. * Note that Zstandard can still find matches of smaller size, * it just tweaks its search algorithm to look for this size and larger. * Larger values increase compression and decompression speed, but decrease ratio. * Must be clamped between ZSTD_MINMATCH_MIN and ZSTD_MINMATCH_MAX. * Note that currently, for all strategies < btopt, effective minimum is 4. * , for all strategies > fast, effective maximum is 6. * Special: value 0 means "use default minMatchLength". / ZSTD_c_targetLength=106, / Impact of this field depends on strategy. * For strategies btopt, btultra & btultra2: * Length of Match considered "good enough" to stop search. * Larger values make compression stronger, and slower. * For strategy fast: * Distance between match sampling. * Larger values make compression faster, and weaker. * Special: value 0 means "use default targetLength". / ZSTD_c_strategy=107, / See ZSTD_strategy enum definition. * The higher the value of selected strategy, the more complex it is, * resulting in stronger and slower compression. * Special: value 0 means "use default strategy". / / LDM mode parameters / ZSTD_c_enableLongDistanceMatching=160, / Enable long distance matching. * This parameter is designed to improve compression ratio * for large inputs, by finding large matches at long distance. * It increases memory usage and window size. * Note: enabling this parameter increases default ZSTD_c_windowLog to 128 MB * except when expressly set to a different value. * Note: will be enabled by default if ZSTD_c_windowLog >= 128 MB and * compression strategy >= ZSTD_btopt (== compression level 16+) / ZSTD_c_ldmHashLog=161, / Size of the table for long distance matching, as a power of 2. * Larger values increase memory usage and compression ratio, * but decrease compression speed. * Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX * default: windowlog - 7. * Special: value 0 means "automatically determine hashlog". / ZSTD_c_ldmMinMatch=162, / Minimum match size for long distance matcher. * Larger/too small values usually decrease compression ratio. * Must be clamped between ZSTD_LDM_MINMATCH_MIN and ZSTD_LDM_MINMATCH_MAX. * Special: value 0 means "use default value" (default: 64). / ZSTD_c_ldmBucketSizeLog=163, / Log size of each bucket in the LDM hash table for collision resolution. * Larger values improve collision resolution but decrease compression speed. * The maximum value is ZSTD_LDM_BUCKETSIZELOG_MAX. * Special: value 0 means "use default value" (default: 3). / ZSTD_c_ldmHashRateLog=164, / Frequency of inserting/looking up entries into the LDM hash table. * Must be clamped between 0 and (ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN). * Default is MAX(0, (windowLog - ldmHashLog)), optimizing hash table usage. * Larger values improve compression speed. * Deviating far from default value will likely result in a compression ratio decrease. * Special: value 0 means "automatically determine hashRateLog". / / frame parameters / ZSTD_c_contentSizeFlag=200, / Content size will be written into frame header _whenever known_ (default:1) * Content size must be known at the beginning of compression. * This is automatically the case when using ZSTD_compress2(), * For streaming scenarios, content size must be provided with ZSTD_CCtx_setPledgedSrcSize() / ZSTD_c_checksumFlag=201, / A 32-bits checksum of content is written at end of frame (default:0) / ZSTD_c_dictIDFlag=202, / When applicable, dictionary's ID is written into frame header (default:1) / / multi-threading parameters / / These parameters are only active if multi-threading is enabled (compiled with build macro ZSTD_MULTITHREAD). * Otherwise, trying to set any other value than default (0) will be a no-op and return an error. * In a situation where it's unknown if the linked library supports multi-threading or not, * setting ZSTD_c_nbWorkers to any value >= 1 and consulting the return value provides a quick way to check this property. / ZSTD_c_nbWorkers=400, / Select how many threads will be spawned to compress in parallel. * When nbWorkers >= 1, triggers asynchronous mode when invoking ZSTD_compressStream() : ZSTD_compressStream() consumes input and flush output if possible, but immediately gives back control to caller, while compression is performed in parallel, within worker thread(s). * (note : a strong exception to this rule is when first invocation of ZSTD_compressStream2() sets ZSTD_e_end : * in which case, ZSTD_compressStream2() delegates to ZSTD_compress2(), which is always a blocking call). * More workers improve speed, but also increase memory usage. * Default value is `0`, aka "single-threaded mode" : no worker is spawned, * compression is performed inside Caller's thread, and all invocations are blocking / ZSTD_c_jobSize=401, / Size of a compression job. This value is enforced only when nbWorkers >= 1. * Each compression job is completed in parallel, so this value can indirectly impact the nb of active threads. * 0 means default, which is dynamically determined based on compression parameters. * Job size must be a minimum of overlap size, or ZSTDMT_JOBSIZE_MIN (= 512 KB), whichever is largest. * The minimum size is automatically and transparently enforced. / ZSTD_c_overlapLog=402, / Control the overlap size, as a fraction of window size. * The overlap size is an amount of data reloaded from previous job at the beginning of a new job. * It helps preserve compression ratio, while each job is compressed in parallel. * This value is enforced only when nbWorkers >= 1. * Larger values increase compression ratio, but decrease speed. * Possible values range from 0 to 9 : * - 0 means "default" : value will be determined by the library, depending on strategy * - 1 means "no overlap" * - 9 means "full overlap", using a full window size. * Each intermediate rank increases/decreases load size by a factor 2 : * 9: full window; 8: w/2; 7: w/4; 6: w/8; 5:w/16; 4: w/32; 3:w/64; 2:w/128; 1:no overlap; 0:default * default value varies between 6 and 9, depending on strategy / / note : additional experimental parameters are also available * within the experimental section of the API. * At the time of this writing, they include : * ZSTD_c_rsyncable * ZSTD_c_format * ZSTD_c_forceMaxWindow * ZSTD_c_forceAttachDict * ZSTD_c_literalCompressionMode * ZSTD_c_targetCBlockSize * ZSTD_c_srcSizeHint * ZSTD_c_enableDedicatedDictSearch * ZSTD_c_stableInBuffer * ZSTD_c_stableOutBuffer * ZSTD_c_blockDelimiters * ZSTD_c_validateSequences * ZSTD_c_useBlockSplitter * ZSTD_c_useRowMatchFinder * ZSTD_c_prefetchCDictTables * ZSTD_c_enableSeqProducerFallback * ZSTD_c_maxBlockSize * Because they are not stable, it's necessary to define ZSTD_STATIC_LINKING_ONLY to access them. * note : never ever use experimentalParam? names directly; * also, the enums values themselves are unstable and can still change. / ZSTD_c_experimentalParam1=500, ZSTD_c_experimentalParam2=10, ZSTD_c_experimentalParam3=1000, ZSTD_c_experimentalParam4=1001, ZSTD_c_experimentalParam5=1002, ZSTD_c_experimentalParam6=1003, ZSTD_c_experimentalParam7=1004, ZSTD_c_experimentalParam8=1005, ZSTD_c_experimentalParam9=1006, ZSTD_c_experimentalParam10=1007, ZSTD_c_experimentalParam11=1008, ZSTD_c_experimentalParam12=1009, ZSTD_c_experimentalParam13=1010, ZSTD_c_experimentalParam14=1011, ZSTD_c_experimentalParam15=1012, ZSTD_c_experimentalParam16=1013, ZSTD_c_experimentalParam17=1014, ZSTD_c_experimentalParam18=1015, ZSTD_c_experimentalParam19=1016 } ZSTD_cParameter; typedef struct { size_t error; int lowerBound; int upperBound; } ZSTD_bounds; /! ZSTD_cParam_getBounds() : * All parameters must belong to an interval with lower and upper bounds, * otherwise they will either trigger an error or be automatically clamped. * @return : a structure, ZSTD_bounds, which contains * - an error status field, which must be tested using ZSTD_isError() * - lower and upper bounds, both inclusive / ZSTDLIB_API ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter cParam); /! ZSTD_CCtx_setParameter() : * Set one compression parameter, selected by enum ZSTD_cParameter. * All parameters have valid bounds. Bounds can be queried using ZSTD_cParam_getBounds(). * Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter). * Setting a parameter is generally only possible during frame initialization (before starting compression). * Exception : when using multi-threading mode (nbWorkers >= 1), * the following parameters can be updated _during_ compression (within same frame): * => compressionLevel, hashLog, chainLog, searchLog, minMatch, targetLength and strategy. * new parameters will be active for next job only (after a flush()). * @return : an error code (which can be tested using ZSTD_isError()). / ZSTDLIB_API size_t ZSTD_CCtx_setParameter(ZSTD_CCtx cctx, ZSTD_cParameter param, int value); /! ZSTD_CCtx_setPledgedSrcSize() : Total input data size to be compressed as a single frame. * Value will be written in frame header, unless if explicitly forbidden using ZSTD_c_contentSizeFlag. * This value will also be controlled at end of frame, and trigger an error if not respected. * @result : 0, or an error code (which can be tested with ZSTD_isError()). * Note 1 : pledgedSrcSize==0 actually means zero, aka an empty frame. * In order to mean "unknown content size", pass constant ZSTD_CONTENTSIZE_UNKNOWN. * ZSTD_CONTENTSIZE_UNKNOWN is default value for any new frame. * Note 2 : pledgedSrcSize is only valid once, for the next frame. * It's discarded at the end of the frame, and replaced by ZSTD_CONTENTSIZE_UNKNOWN. * Note 3 : Whenever all input data is provided and consumed in a single round, * for example with ZSTD_compress2(), * or invoking immediately ZSTD_compressStream2(,,,ZSTD_e_end), * this value is automatically overridden by srcSize instead. / ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx cctx, unsigned long long pledgedSrcSize); typedef enum { ZSTD_reset_session_only = 1, ZSTD_reset_parameters = 2, ZSTD_reset_session_and_parameters = 3 } ZSTD_ResetDirective; /! ZSTD_CCtx_reset() : There are 2 different things that can be reset, independently or jointly : * - The session : will stop compressing current frame, and make CCtx ready to start a new one. * Useful after an error, or to interrupt any ongoing compression. * Any internal data not yet flushed is cancelled. * Compression parameters and dictionary remain unchanged. * They will be used to compress next frame. * Resetting session never fails. * - The parameters : changes all parameters back to "default". * This also removes any reference to any dictionary or external sequence producer. * Parameters can only be changed between 2 sessions (i.e. no compression is currently ongoing) * otherwise the reset fails, and function returns an error value (which can be tested using ZSTD_isError()) * - Both : similar to resetting the session, followed by resetting parameters. / ZSTDLIB_API size_t ZSTD_CCtx_reset(ZSTD_CCtx cctx, ZSTD_ResetDirective reset); /! ZSTD_compress2() : Behave the same as ZSTD_compressCCtx(), but compression parameters are set using the advanced API. * ZSTD_compress2() always starts a new frame. * Should cctx hold data from a previously unfinished frame, everything about it is forgotten. * - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set() - The function is always blocking, returns when compression is completed. * NOTE: Providing `dstCapacity >= ZSTD_compressBound(srcSize)` guarantees that zstd will have * enough space to successfully compress the data, though it is possible it fails for other reasons. * @return : compressed size written into `dst` (<= `dstCapacity), * or an error code if it fails (which can be tested using ZSTD_isError()). / ZSTDLIB_API size_t ZSTD_compress2( ZSTD_CCtx cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); /*********************************************** * Advanced decompression API (Requires v1.4.0+) ***********************************************/ / The advanced API pushes parameters one by one into an existing DCtx context. * Parameters are sticky, and remain valid for all following frames * using the same DCtx context. * It's possible to reset parameters to default values using ZSTD_DCtx_reset(). * Note : This API is compatible with existing ZSTD_decompressDCtx() and ZSTD_decompressStream(). * Therefore, no new decompression function is necessary. / typedef enum { ZSTD_d_windowLogMax=100, / Select a size limit (in power of 2) beyond which * the streaming API will refuse to allocate memory buffer * in order to protect the host from unreasonable memory requirements. * This parameter is only useful in streaming mode, since no internal buffer is allocated in single-pass mode. * By default, a decompression context accepts window sizes <= (1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT). * Special: value 0 means "use default maximum windowLog". / / note : additional experimental parameters are also available * within the experimental section of the API. * At the time of this writing, they include : * ZSTD_d_format * ZSTD_d_stableOutBuffer * ZSTD_d_forceIgnoreChecksum * ZSTD_d_refMultipleDDicts * ZSTD_d_disableHuffmanAssembly * Because they are not stable, it's necessary to define ZSTD_STATIC_LINKING_ONLY to access them. * note : never ever use experimentalParam? names directly / ZSTD_d_experimentalParam1=1000, ZSTD_d_experimentalParam2=1001, ZSTD_d_experimentalParam3=1002, ZSTD_d_experimentalParam4=1003, ZSTD_d_experimentalParam5=1004 } ZSTD_dParameter; /! ZSTD_dParam_getBounds() : * All parameters must belong to an interval with lower and upper bounds, * otherwise they will either trigger an error or be automatically clamped. * @return : a structure, ZSTD_bounds, which contains * - an error status field, which must be tested using ZSTD_isError() * - both lower and upper bounds, inclusive / ZSTDLIB_API ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam); /! ZSTD_DCtx_setParameter() : * Set one compression parameter, selected by enum ZSTD_dParameter. * All parameters have valid bounds. Bounds can be queried using ZSTD_dParam_getBounds(). * Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter). * Setting a parameter is only possible during frame initialization (before starting decompression). * @return : 0, or an error code (which can be tested using ZSTD_isError()). / ZSTDLIB_API size_t ZSTD_DCtx_setParameter(ZSTD_DCtx dctx, ZSTD_dParameter param, int value); /! ZSTD_DCtx_reset() : Return a DCtx to clean state. * Session and parameters can be reset jointly or separately. * Parameters can only be reset when no active frame is being decompressed. * @return : 0, or an error code, which can be tested with ZSTD_isError() / ZSTDLIB_API size_t ZSTD_DCtx_reset(ZSTD_DCtx dctx, ZSTD_ResetDirective reset); /**************************** * Streaming ***************************/ typedef struct ZSTD_inBuffer_s { const void src; /*< start of input buffer / size_t size; /*< size of input buffer / size_t pos; /*< position where reading stopped. Will be updated. Necessarily 0 <= pos <= size / } ZSTD_inBuffer; typedef struct ZSTD_outBuffer_s { void* dst; /*< start of output buffer / size_t size; /*< size of output buffer / size_t pos; /*< position where writing stopped. Will be updated. Necessarily 0 <= pos <= size / } ZSTD_outBuffer; /-********************************************************************** * Streaming compression - HowTo * * A ZSTD_CStream object is required to track streaming operation. * Use ZSTD_createCStream() and ZSTD_freeCStream() to create/release resources. * ZSTD_CStream objects can be reused multiple times on consecutive compression operations. * It is recommended to re-use ZSTD_CStream since it will play nicer with system's memory, by re-using already allocated memory. * * For parallel execution, use one separate ZSTD_CStream per thread. * * note : since v1.3.0, ZSTD_CStream and ZSTD_CCtx are the same thing. * * Parameters are sticky : when starting a new compression on the same context, * it will re-use the same sticky parameters as previous compression session. * When in doubt, it's recommended to fully initialize the context before usage. * Use ZSTD_CCtx_reset() to reset the context and ZSTD_CCtx_setParameter(), * ZSTD_CCtx_setPledgedSrcSize(), or ZSTD_CCtx_loadDictionary() and friends to * set more specific parameters, the pledged source size, or load a dictionary. * * Use ZSTD_compressStream2() with ZSTD_e_continue as many times as necessary to * consume input stream. The function will automatically update both `pos` * fields within `input` and `output`. * Note that the function may not consume the entire input, for example, because * the output buffer is already full, in which case `input.pos < input.size`. * The caller must check if input has been entirely consumed. * If not, the caller must make some room to receive more compressed data, * and then present again remaining input data. * note: ZSTD_e_continue is guaranteed to make some forward progress when called, * but doesn't guarantee maximal forward progress. This is especially relevant * when compressing with multiple threads. The call won't block if it can * consume some input, but if it can't it will wait for some, but not all, * output to be flushed. * @return : provides a minimum amount of data remaining to be flushed from internal buffers * or an error code, which can be tested using ZSTD_isError(). * * At any moment, it's possible to flush whatever data might remain stuck within internal buffer, * using ZSTD_compressStream2() with ZSTD_e_flush. `output->pos` will be updated. * Note that, if `output->size` is too small, a single invocation with ZSTD_e_flush might not be enough (return code > 0). * In which case, make some room to receive more compressed data, and call again ZSTD_compressStream2() with ZSTD_e_flush. * You must continue calling ZSTD_compressStream2() with ZSTD_e_flush until it returns 0, at which point you can change the * operation. * note: ZSTD_e_flush will flush as much output as possible, meaning when compressing with multiple threads, it will * block until the flush is complete or the output buffer is full. * @return : 0 if internal buffers are entirely flushed, * >0 if some data still present within internal buffer (the value is minimal estimation of remaining size), * or an error code, which can be tested using ZSTD_isError(). * * Calling ZSTD_compressStream2() with ZSTD_e_end instructs to finish a frame. * It will perform a flush and write frame epilogue. * The epilogue is required for decoders to consider a frame completed. * flush operation is the same, and follows same rules as calling ZSTD_compressStream2() with ZSTD_e_flush. * You must continue calling ZSTD_compressStream2() with ZSTD_e_end until it returns 0, at which point you are free to * start a new frame. * note: ZSTD_e_end will flush as much output as possible, meaning when compressing with multiple threads, it will * block until the flush is complete or the output buffer is full. * @return : 0 if frame fully completed and fully flushed, * >0 if some data still present within internal buffer (the value is minimal estimation of remaining size), * or an error code, which can be tested using ZSTD_isError(). * * *****************************************************************/ typedef ZSTD_CCtx ZSTD_CStream; /< CCtx and CStream are now effectively same object (>= v1.3.0) / / Continue to distinguish them for compatibility with older versions <= v1.2.0 / /===== ZSTD_CStream management functions =====/ ZSTDLIB_API ZSTD_CStream ZSTD_createCStream(void); ZSTDLIB_API size_t ZSTD_freeCStream(ZSTD_CStream* zcs); /* accept NULL pointer / /===== Streaming compression functions =====/ typedef enum { ZSTD_e_continue=0, / collect more data, encoder decides when to output compressed result, for optimal compression ratio / ZSTD_e_flush=1, / flush any data provided so far, * it creates (at least) one new block, that can be decoded immediately on reception; * frame will continue: any future data can still reference previously compressed data, improving compression. * note : multithreaded compression will block to flush as much output as possible. / ZSTD_e_end=2 / flush any remaining data _and_ close current frame. * note that frame is only closed after compressed data is fully flushed (return value == 0). * After that point, any additional data starts a new frame. * note : each frame is independent (does not reference any content from previous frame). : note : multithreaded compression will block to flush as much output as possible. / } ZSTD_EndDirective; /! ZSTD_compressStream2() : Requires v1.4.0+ * Behaves about the same as ZSTD_compressStream, with additional control on end directive. * - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set() - Compression parameters cannot be changed once compression is started (save a list of exceptions in multi-threading mode) * - output->pos must be <= dstCapacity, input->pos must be <= srcSize * - output->pos and input->pos will be updated. They are guaranteed to remain below their respective limit. * - endOp must be a valid directive * - When nbWorkers==0 (default), function is blocking : it completes its job before returning to caller. * - When nbWorkers>=1, function is non-blocking : it copies a portion of input, distributes jobs to internal worker threads, flush to output whatever is available, * and then immediately returns, just indicating that there is some data remaining to be flushed. * The function nonetheless guarantees forward progress : it will return only after it reads or write at least 1+ byte. * - Exception : if the first call requests a ZSTD_e_end directive and provides enough dstCapacity, the function delegates to ZSTD_compress2() which is always blocking. * - @return provides a minimum amount of data remaining to be flushed from internal buffers * or an error code, which can be tested using ZSTD_isError(). * if @return != 0, flush is not fully completed, there is still some data left within internal buffers. * This is useful for ZSTD_e_flush, since in this case more flushes are necessary to empty all buffers. * For ZSTD_e_end, @return == 0 when internal buffers are fully flushed and frame is completed. * - after a ZSTD_e_end directive, if internal buffer is not fully flushed (@return != 0), * only ZSTD_e_end or ZSTD_e_flush operations are allowed. * Before starting a new compression job, or changing compression parameters, * it is required to fully flush internal buffers. / ZSTDLIB_API size_t ZSTD_compressStream2( ZSTD_CCtx cctx, ZSTD_outBuffer* output, ZSTD_inBuffer* input, ZSTD_EndDirective endOp); /* These buffer sizes are softly recommended. * They are not required : ZSTD_compressStream() happily accepts any buffer size, for both input and output. Respecting the recommended size just makes it a bit easier for ZSTD_compressStream(), reducing the amount of memory shuffling and buffering, resulting in minor performance savings. * * However, note that these recommendations are from the perspective of a C caller program. * If the streaming interface is invoked from some other language, * especially managed ones such as Java or Go, through a foreign function interface such as jni or cgo, * a major performance rule is to reduce crossing such interface to an absolute minimum. * It's not rare that performance ends being spent more into the interface, rather than compression itself. * In which cases, prefer using large buffers, as large as practical, * for both input and output, to reduce the nb of roundtrips. / ZSTDLIB_API size_t ZSTD_CStreamInSize(void); /< recommended size for input buffer / ZSTDLIB_API size_t ZSTD_CStreamOutSize(void); /*< recommended size for output buffer. Guarantee to successfully flush at least one complete compressed block. / /* ***************************************************************************** * This following is a legacy streaming API, available since v1.0+ . * It can be replaced by ZSTD_CCtx_reset() and ZSTD_compressStream2(). * It is redundant, but remains fully supported. *****************************************************************************/ /! * Equivalent to: * * ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only); * ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any) * ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel); * * Note that ZSTD_initCStream() clears any previously set dictionary. Use the new API * to compress with a dictionary. / ZSTDLIB_API size_t ZSTD_initCStream(ZSTD_CStream zcs, int compressionLevel); /! Alternative for ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue). * NOTE: The return value is different. ZSTD_compressStream() returns a hint for * the next read size (if non-zero and not an error). ZSTD_compressStream2() * returns the minimum nb of bytes left to flush (if non-zero and not an error). / ZSTDLIB_API size_t ZSTD_compressStream(ZSTD_CStream zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input); /! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_flush). / ZSTDLIB_API size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output); /! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_end). / ZSTDLIB_API size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output); /-************************************************************************** * Streaming decompression - HowTo * * A ZSTD_DStream object is required to track streaming operations. * Use ZSTD_createDStream() and ZSTD_freeDStream() to create/release resources. * ZSTD_DStream objects can be re-used multiple times. * * Use ZSTD_initDStream() to start a new decompression operation. * @return : recommended first input size * Alternatively, use advanced API to set specific properties. * * Use ZSTD_decompressStream() repetitively to consume your input. * The function will update both `pos` fields. * If `input.pos < input.size`, some input has not been consumed. * It's up to the caller to present again remaining data. * The function tries to flush all data decoded immediately, respecting output buffer size. * If `output.pos < output.size`, decoder has flushed everything it could. * But if `output.pos == output.size`, there might be some data left within internal buffers., * In which case, call ZSTD_decompressStream() again to flush whatever remains in the buffer. * Note : with no additional input provided, amount of data flushed is necessarily <= ZSTD_BLOCKSIZE_MAX. * @return : 0 when a frame is completely decoded and fully flushed, * or an error code, which can be tested using ZSTD_isError(), * or any other value > 0, which means there is still some decoding or flushing to do to complete current frame : * the return value is a suggested next input size (just a hint for better latency) * that will never request more than the remaining frame size. * *****************************************************************************/ typedef ZSTD_DCtx ZSTD_DStream; /< DCtx and DStream are now effectively same object (>= v1.3.0) / / For compatibility with versions <= v1.2.0, prefer differentiating them. / /===== ZSTD_DStream management functions =====/ ZSTDLIB_API ZSTD_DStream ZSTD_createDStream(void); ZSTDLIB_API size_t ZSTD_freeDStream(ZSTD_DStream* zds); /* accept NULL pointer / /===== Streaming decompression functions =====/ /! ZSTD_initDStream() : * Initialize/reset DStream state for new decompression operation. * Call before new decompression operation using same DStream. * * Note : This function is redundant with the advanced API and equivalent to: * ZSTD_DCtx_reset(zds, ZSTD_reset_session_only); * ZSTD_DCtx_refDDict(zds, NULL); / ZSTDLIB_API size_t ZSTD_initDStream(ZSTD_DStream zds); /! ZSTD_decompressStream() : Streaming decompression function. * Call repetitively to consume full input updating it as necessary. * Function will update both input and output `pos` fields exposing current state via these fields: * - `input.pos < input.size`, some input remaining and caller should provide remaining input * on the next call. * - `output.pos < output.size`, decoder finished and flushed all remaining buffers. * - `output.pos == output.size`, potentially uncflushed data present in the internal buffers, * call ZSTD_decompressStream() again to flush remaining data to output. * Note : with no additional input, amount of data flushed <= ZSTD_BLOCKSIZE_MAX. * * @return : 0 when a frame is completely decoded and fully flushed, * or an error code, which can be tested using ZSTD_isError(), * or any other value > 0, which means there is some decoding or flushing to do to complete current frame. / ZSTDLIB_API size_t ZSTD_decompressStream(ZSTD_DStream zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input); ZSTDLIB_API size_t ZSTD_DStreamInSize(void); /!< recommended size for input buffer / ZSTDLIB_API size_t ZSTD_DStreamOutSize(void); /!< recommended size for output buffer. Guarantee to successfully flush at least one complete block in all circumstances. / /************************** * Simple dictionary API **************************/ /! ZSTD_compress_usingDict() : * Compression at an explicit compression level using a Dictionary. * A dictionary can be any arbitrary data segment (also called a prefix), * or a buffer with specified information (see zdict.h). * Note : This function loads the dictionary, resulting in significant startup delay. * It's intended for a dictionary used only once. * Note 2 : When `dict == NULL \|\| dictSize < 8` no dictionary is used. / ZSTDLIB_API size_t ZSTD_compress_usingDict(ZSTD_CCtx ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const void* dict,size_t dictSize, int compressionLevel); /! ZSTD_decompress_usingDict() : Decompression using a known Dictionary. * Dictionary must be identical to the one used during compression. * Note : This function loads the dictionary, resulting in significant startup delay. * It's intended for a dictionary used only once. * Note : When `dict == NULL \|\| dictSize < 8` no dictionary is used. / ZSTDLIB_API size_t ZSTD_decompress_usingDict(ZSTD_DCtx dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const void* dict,size_t dictSize); /*********************************** * Bulk processing dictionary API *********************************/ typedef struct ZSTD_CDict_s ZSTD_CDict; /! ZSTD_createCDict() : * When compressing multiple messages or blocks using the same dictionary, * it's recommended to digest the dictionary only once, since it's a costly operation. * ZSTD_createCDict() will create a state from digesting a dictionary. * The resulting state can be used for future compression operations with very limited startup cost. * ZSTD_CDict can be created once and shared by multiple threads concurrently, since its usage is read-only. * @dictBuffer can be released after ZSTD_CDict creation, because its content is copied within CDict. * Note 1 : Consider experimental function `ZSTD_createCDict_byReference()` if you prefer to not duplicate @dictBuffer content. * Note 2 : A ZSTD_CDict can be created from an empty @dictBuffer, * in which case the only thing that it transports is the @compressionLevel. * This can be useful in a pipeline featuring ZSTD_compress_usingCDict() exclusively, * expecting a ZSTD_CDict parameter with any data, including those without a known dictionary. / ZSTDLIB_API ZSTD_CDict ZSTD_createCDict(const void* dictBuffer, size_t dictSize, int compressionLevel); /! ZSTD_freeCDict() : Function frees memory allocated by ZSTD_createCDict(). * If a NULL pointer is passed, no operation is performed. / ZSTDLIB_API size_t ZSTD_freeCDict(ZSTD_CDict CDict); /! ZSTD_compress_usingCDict() : Compression using a digested Dictionary. * Recommended when same dictionary is used multiple times. * Note : compression level is _decided at dictionary creation time_, * and frame parameters are hardcoded (dictID=yes, contentSize=yes, checksum=no) / ZSTDLIB_API size_t ZSTD_compress_usingCDict(ZSTD_CCtx cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const ZSTD_CDict* cdict); typedef struct ZSTD_DDict_s ZSTD_DDict; /! ZSTD_createDDict() : Create a digested dictionary, ready to start decompression operation without startup delay. * dictBuffer can be released after DDict creation, as its content is copied inside DDict. / ZSTDLIB_API ZSTD_DDict ZSTD_createDDict(const void* dictBuffer, size_t dictSize); /! ZSTD_freeDDict() : Function frees memory allocated with ZSTD_createDDict() * If a NULL pointer is passed, no operation is performed. / ZSTDLIB_API size_t ZSTD_freeDDict(ZSTD_DDict ddict); /! ZSTD_decompress_usingDDict() : Decompression using a digested Dictionary. * Recommended when same dictionary is used multiple times. / ZSTDLIB_API size_t ZSTD_decompress_usingDDict(ZSTD_DCtx dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const ZSTD_DDict* ddict); /******************************** * Dictionary helper functions ******************************/ /! ZSTD_getDictID_fromDict() : Requires v1.4.0+ * Provides the dictID stored within dictionary. * if @return == 0, the dictionary is not conformant with Zstandard specification. * It can still be loaded, but as a content-only dictionary. / ZSTDLIB_API unsigned ZSTD_getDictID_fromDict(const void dict, size_t dictSize); /! ZSTD_getDictID_fromCDict() : Requires v1.5.0+ Provides the dictID of the dictionary loaded into `cdict`. * If @return == 0, the dictionary is not conformant to Zstandard specification, or empty. * Non-conformant dictionaries can still be loaded, but as content-only dictionaries. / ZSTDLIB_API unsigned ZSTD_getDictID_fromCDict(const ZSTD_CDict cdict); /! ZSTD_getDictID_fromDDict() : Requires v1.4.0+ Provides the dictID of the dictionary loaded into `ddict`. * If @return == 0, the dictionary is not conformant to Zstandard specification, or empty. * Non-conformant dictionaries can still be loaded, but as content-only dictionaries. / ZSTDLIB_API unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict ddict); /! ZSTD_getDictID_fromFrame() : Requires v1.4.0+ Provides the dictID required to decompressed the frame stored within `src`. * If @return == 0, the dictID could not be decoded. * This could for one of the following reasons : * - The frame does not require a dictionary to be decoded (most common case). * - The frame was built with dictID intentionally removed. Whatever dictionary is necessary is a hidden piece of information. * Note : this use case also happens when using a non-conformant dictionary. * - `srcSize` is too small, and as a result, the frame header could not be decoded (only possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`). * - This is not a Zstandard frame. * When identifying the exact failure cause, it's possible to use ZSTD_getFrameHeader(), which will provide a more precise error code. / ZSTDLIB_API unsigned ZSTD_getDictID_fromFrame(const void src, size_t srcSize); /******************************************************************************* * Advanced dictionary and prefix API (Requires v1.4.0+) * * This API allows dictionaries to be used with ZSTD_compress2(), * ZSTD_compressStream2(), and ZSTD_decompressDCtx(). * Dictionaries are sticky, they remain valid when same context is re-used, * they only reset when the context is reset * with ZSTD_reset_parameters or ZSTD_reset_session_and_parameters. * In contrast, Prefixes are single-use. *****************************************************************************/ /! ZSTD_CCtx_loadDictionary() : Requires v1.4.0+ * Create an internal CDict from `dict` buffer. * Decompression will have to use same dictionary. * @result : 0, or an error code (which can be tested with ZSTD_isError()). * Special: Loading a NULL (or 0-size) dictionary invalidates previous dictionary, * meaning "return to no-dictionary mode". * Note 1 : Dictionary is sticky, it will be used for all future compressed frames, * until parameters are reset, a new dictionary is loaded, or the dictionary * is explicitly invalidated by loading a NULL dictionary. * Note 2 : Loading a dictionary involves building tables. * It's also a CPU consuming operation, with non-negligible impact on latency. * Tables are dependent on compression parameters, and for this reason, * compression parameters can no longer be changed after loading a dictionary. * Note 3 :`dict` content will be copied internally. * Use experimental ZSTD_CCtx_loadDictionary_byReference() to reference content instead. * In such a case, dictionary buffer must outlive its users. * Note 4 : Use ZSTD_CCtx_loadDictionary_advanced() * to precisely select how dictionary content must be interpreted. * Note 5 : This method does not benefit from LDM (long distance mode). * If you want to employ LDM on some large dictionary content, * prefer employing ZSTD_CCtx_refPrefix() described below. / ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary(ZSTD_CCtx cctx, const void* dict, size_t dictSize); /! ZSTD_CCtx_refCDict() : Requires v1.4.0+ Reference a prepared dictionary, to be used for all future compressed frames. * Note that compression parameters are enforced from within CDict, * and supersede any compression parameter previously set within CCtx. * The parameters ignored are labelled as "superseded-by-cdict" in the ZSTD_cParameter enum docs. * The ignored parameters will be used again if the CCtx is returned to no-dictionary mode. * The dictionary will remain valid for future compressed frames using same CCtx. * @result : 0, or an error code (which can be tested with ZSTD_isError()). * Special : Referencing a NULL CDict means "return to no-dictionary mode". * Note 1 : Currently, only one dictionary can be managed. * Referencing a new dictionary effectively "discards" any previous one. * Note 2 : CDict is just referenced, its lifetime must outlive its usage within CCtx. / ZSTDLIB_API size_t ZSTD_CCtx_refCDict(ZSTD_CCtx cctx, const ZSTD_CDict* cdict); /! ZSTD_CCtx_refPrefix() : Requires v1.4.0+ Reference a prefix (single-usage dictionary) for next compressed frame. * A prefix is only used once. Tables are discarded at end of frame (ZSTD_e_end). * Decompression will need same prefix to properly regenerate data. * Compressing with a prefix is similar in outcome as performing a diff and compressing it, * but performs much faster, especially during decompression (compression speed is tunable with compression level). * This method is compatible with LDM (long distance mode). * @result : 0, or an error code (which can be tested with ZSTD_isError()). * Special: Adding any prefix (including NULL) invalidates any previous prefix or dictionary * Note 1 : Prefix buffer is referenced. It must outlive compression. * Its content must remain unmodified during compression. * Note 2 : If the intention is to diff some large src data blob with some prior version of itself, * ensure that the window size is large enough to contain the entire source. * See ZSTD_c_windowLog. * Note 3 : Referencing a prefix involves building tables, which are dependent on compression parameters. * It's a CPU consuming operation, with non-negligible impact on latency. * If there is a need to use the same prefix multiple times, consider loadDictionary instead. * Note 4 : By default, the prefix is interpreted as raw content (ZSTD_dct_rawContent). * Use experimental ZSTD_CCtx_refPrefix_advanced() to alter dictionary interpretation. / ZSTDLIB_API size_t ZSTD_CCtx_refPrefix(ZSTD_CCtx cctx, const void* prefix, size_t prefixSize); /! ZSTD_DCtx_loadDictionary() : Requires v1.4.0+ Create an internal DDict from dict buffer, to be used to decompress all future frames. * The dictionary remains valid for all future frames, until explicitly invalidated, or * a new dictionary is loaded. * @result : 0, or an error code (which can be tested with ZSTD_isError()). * Special : Adding a NULL (or 0-size) dictionary invalidates any previous dictionary, * meaning "return to no-dictionary mode". * Note 1 : Loading a dictionary involves building tables, * which has a non-negligible impact on CPU usage and latency. * It's recommended to "load once, use many times", to amortize the cost * Note 2 :`dict` content will be copied internally, so `dict` can be released after loading. * Use ZSTD_DCtx_loadDictionary_byReference() to reference dictionary content instead. * Note 3 : Use ZSTD_DCtx_loadDictionary_advanced() to take control of * how dictionary content is loaded and interpreted. / ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx dctx, const void* dict, size_t dictSize); /! ZSTD_DCtx_refDDict() : Requires v1.4.0+ Reference a prepared dictionary, to be used to decompress next frames. * The dictionary remains active for decompression of future frames using same DCtx. * * If called with ZSTD_d_refMultipleDDicts enabled, repeated calls of this function * will store the DDict references in a table, and the DDict used for decompression * will be determined at decompression time, as per the dict ID in the frame. * The memory for the table is allocated on the first call to refDDict, and can be * freed with ZSTD_freeDCtx(). * * If called with ZSTD_d_refMultipleDDicts disabled (the default), only one dictionary * will be managed, and referencing a dictionary effectively "discards" any previous one. * * @result : 0, or an error code (which can be tested with ZSTD_isError()). * Special: referencing a NULL DDict means "return to no-dictionary mode". * Note 2 : DDict is just referenced, its lifetime must outlive its usage from DCtx. / ZSTDLIB_API size_t ZSTD_DCtx_refDDict(ZSTD_DCtx dctx, const ZSTD_DDict* ddict); /! ZSTD_DCtx_refPrefix() : Requires v1.4.0+ Reference a prefix (single-usage dictionary) to decompress next frame. * This is the reverse operation of ZSTD_CCtx_refPrefix(), * and must use the same prefix as the one used during compression. * Prefix is only used once. Reference is discarded at end of frame. * End of frame is reached when ZSTD_decompressStream() returns 0. * @result : 0, or an error code (which can be tested with ZSTD_isError()). * Note 1 : Adding any prefix (including NULL) invalidates any previously set prefix or dictionary * Note 2 : Prefix buffer is referenced. It must outlive decompression. * Prefix buffer must remain unmodified up to the end of frame, * reached when ZSTD_decompressStream() returns 0. * Note 3 : By default, the prefix is treated as raw content (ZSTD_dct_rawContent). * Use ZSTD_CCtx_refPrefix_advanced() to alter dictMode (Experimental section) * Note 4 : Referencing a raw content prefix has almost no cpu nor memory cost. * A full dictionary is more costly, as it requires building tables. / ZSTDLIB_API size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx dctx, const void* prefix, size_t prefixSize); /* === Memory management === / /! ZSTD_sizeof_() : Requires v1.4.0+ These functions give the _current_ memory usage of selected object. * Note that object memory usage can evolve (increase or decrease) over time. / ZSTDLIB_API size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx cctx); ZSTDLIB_API size_t ZSTD_sizeof_DCtx(const ZSTD_DCtx* dctx); ZSTDLIB_API size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs); ZSTDLIB_API size_t ZSTD_sizeof_DStream(const ZSTD_DStream* zds); ZSTDLIB_API size_t ZSTD_sizeof_CDict(const ZSTD_CDict* cdict); ZSTDLIB_API size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict); #endif /* ZSTD_H_235446 / / ************************************************************************************** * ADVANCED AND EXPERIMENTAL FUNCTIONS **************************************************************************************** * The definitions in the following section are considered experimental. * They are provided for advanced scenarios. * They should never be used with a dynamic library, as prototypes may change in the future. * Use them only in association with static linking. * **************************************************************************************/ #if defined(ZSTD_STATIC_LINKING_ONLY) && !defined(ZSTD_H_ZSTD_STATIC_LINKING_ONLY) #define ZSTD_H_ZSTD_STATIC_LINKING_ONLY / This can be overridden externally to hide static symbols. / #ifndef ZSTDLIB_STATIC_API # if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1) # define ZSTDLIB_STATIC_API __declspec(dllexport) ZSTDLIB_VISIBLE # elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1) # define ZSTDLIB_STATIC_API __declspec(dllimport) ZSTDLIB_VISIBLE # else # define ZSTDLIB_STATIC_API ZSTDLIB_VISIBLE # endif #endif /*************************************************************************************** * experimental API (static linking only) **************************************************************************************** * The following symbols and constants * are not planned to join "stable API" status in the near future. * They can still change in future versions. * Some of them are planned to remain in the static_only section indefinitely. * Some of them might be removed in the future (especially when redundant with existing stable functions) * **************************************************************************************/ #define ZSTD_FRAMEHEADERSIZE_PREFIX(format) ((format) == ZSTD_f_zstd1 ? 5 : 1) / minimum input size required to query frame header size / #define ZSTD_FRAMEHEADERSIZE_MIN(format) ((format) == ZSTD_f_zstd1 ? 6 : 2) #define ZSTD_FRAMEHEADERSIZE_MAX 18 / can be useful for static allocation / #define ZSTD_SKIPPABLEHEADERSIZE 8 / compression parameter bounds / #define ZSTD_WINDOWLOG_MAX_32 30 #define ZSTD_WINDOWLOG_MAX_64 31 #define ZSTD_WINDOWLOG_MAX ((int)(sizeof(size_t) == 4 ? ZSTD_WINDOWLOG_MAX_32 : ZSTD_WINDOWLOG_MAX_64)) #define ZSTD_WINDOWLOG_MIN 10 #define ZSTD_HASHLOG_MAX ((ZSTD_WINDOWLOG_MAX < 30) ? ZSTD_WINDOWLOG_MAX : 30) #define ZSTD_HASHLOG_MIN 6 #define ZSTD_CHAINLOG_MAX_32 29 #define ZSTD_CHAINLOG_MAX_64 30 #define ZSTD_CHAINLOG_MAX ((int)(sizeof(size_t) == 4 ? ZSTD_CHAINLOG_MAX_32 : ZSTD_CHAINLOG_MAX_64)) #define ZSTD_CHAINLOG_MIN ZSTD_HASHLOG_MIN #define ZSTD_SEARCHLOG_MAX (ZSTD_WINDOWLOG_MAX-1) #define ZSTD_SEARCHLOG_MIN 1 #define ZSTD_MINMATCH_MAX 7 / only for ZSTD_fast, other strategies are limited to 6 / #define ZSTD_MINMATCH_MIN 3 / only for ZSTD_btopt+, faster strategies are limited to 4 / #define ZSTD_TARGETLENGTH_MAX ZSTD_BLOCKSIZE_MAX #define ZSTD_TARGETLENGTH_MIN 0 / note : comparing this constant to an unsigned results in a tautological test / #define ZSTD_STRATEGY_MIN ZSTD_fast #define ZSTD_STRATEGY_MAX ZSTD_btultra2 #define ZSTD_BLOCKSIZE_MAX_MIN (1 << 10) / The minimum valid max blocksize. Maximum blocksizes smaller than this make compressBound() inaccurate. / #define ZSTD_OVERLAPLOG_MIN 0 #define ZSTD_OVERLAPLOG_MAX 9 #define ZSTD_WINDOWLOG_LIMIT_DEFAULT 27 / by default, the streaming decoder will refuse any frame * requiring larger than (1<<ZSTD_WINDOWLOG_LIMIT_DEFAULT) window size, * to preserve host's memory from unreasonable requirements. * This limit can be overridden using ZSTD_DCtx_setParameter(,ZSTD_d_windowLogMax,). * The limit does not apply for one-pass decoders (such as ZSTD_decompress()), since no additional memory is allocated / / LDM parameter bounds / #define ZSTD_LDM_HASHLOG_MIN ZSTD_HASHLOG_MIN #define ZSTD_LDM_HASHLOG_MAX ZSTD_HASHLOG_MAX #define ZSTD_LDM_MINMATCH_MIN 4 #define ZSTD_LDM_MINMATCH_MAX 4096 #define ZSTD_LDM_BUCKETSIZELOG_MIN 1 #define ZSTD_LDM_BUCKETSIZELOG_MAX 8 #define ZSTD_LDM_HASHRATELOG_MIN 0 #define ZSTD_LDM_HASHRATELOG_MAX (ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN) / Advanced parameter bounds / #define ZSTD_TARGETCBLOCKSIZE_MIN 64 #define ZSTD_TARGETCBLOCKSIZE_MAX ZSTD_BLOCKSIZE_MAX #define ZSTD_SRCSIZEHINT_MIN 0 #define ZSTD_SRCSIZEHINT_MAX INT_MAX / --- Advanced types --- / typedef struct ZSTD_CCtx_params_s ZSTD_CCtx_params; typedef struct { unsigned int offset; / The offset of the match. (NOT the same as the offset code) * If offset == 0 and matchLength == 0, this sequence represents the last * literals in the block of litLength size. / unsigned int litLength; / Literal length of the sequence. / unsigned int matchLength; / Match length of the sequence. / / Note: Users of this API may provide a sequence with matchLength == litLength == offset == 0. * In this case, we will treat the sequence as a marker for a block boundary. / unsigned int rep; / Represents which repeat offset is represented by the field 'offset'. * Ranges from [0, 3]. * * Repeat offsets are essentially previous offsets from previous sequences sorted in * recency order. For more detail, see doc/zstd_compression_format.md * * If rep == 0, then 'offset' does not contain a repeat offset. * If rep > 0: * If litLength != 0: * rep == 1 --> offset == repeat_offset_1 * rep == 2 --> offset == repeat_offset_2 * rep == 3 --> offset == repeat_offset_3 * If litLength == 0: * rep == 1 --> offset == repeat_offset_2 * rep == 2 --> offset == repeat_offset_3 * rep == 3 --> offset == repeat_offset_1 - 1 * * Note: This field is optional. ZSTD_generateSequences() will calculate the value of * 'rep', but repeat offsets do not necessarily need to be calculated from an external * sequence provider's perspective. For example, ZSTD_compressSequences() does not * use this 'rep' field at all (as of now). / } ZSTD_Sequence; typedef struct { unsigned windowLog; /< largest match distance : larger == more compression, more memory needed during decompression / unsigned chainLog; /*< fully searched segment : larger == more compression, slower, more memory (useless for fast) / unsigned hashLog; /*< dispatch table : larger == faster, more memory / unsigned searchLog; /*< nb of searches : larger == more compression, slower / unsigned minMatch; /*< match length searched : larger == faster decompression, sometimes less compression / unsigned targetLength; /*< acceptable match size for optimal parser (only) : larger == more compression, slower / ZSTD_strategy strategy; /*< see ZSTD_strategy definition above / } ZSTD_compressionParameters; typedef struct { int contentSizeFlag; /*< 1: content size will be in frame header (when known) / int checksumFlag; /*< 1: generate a 32-bits checksum using XXH64 algorithm at end of frame, for error detection / int noDictIDFlag; /*< 1: no dictID will be saved into frame header (dictID is only useful for dictionary compression) / } ZSTD_frameParameters; typedef struct { ZSTD_compressionParameters cParams; ZSTD_frameParameters fParams; } ZSTD_parameters; typedef enum { ZSTD_dct_auto = 0, /* dictionary is "full" when starting with ZSTD_MAGIC_DICTIONARY, otherwise it is "rawContent" / ZSTD_dct_rawContent = 1, / ensures dictionary is always loaded as rawContent, even if it starts with ZSTD_MAGIC_DICTIONARY / ZSTD_dct_fullDict = 2 / refuses to load a dictionary if it does not respect Zstandard's specification, starting with ZSTD_MAGIC_DICTIONARY / } ZSTD_dictContentType_e; typedef enum { ZSTD_dlm_byCopy = 0, /< Copy dictionary content internally / ZSTD_dlm_byRef = 1 /*< Reference dictionary content -- the dictionary buffer must outlive its users. / } ZSTD_dictLoadMethod_e; typedef enum { ZSTD_f_zstd1 = 0, /* zstd frame format, specified in zstd_compression_format.md (default) / ZSTD_f_zstd1_magicless = 1 / Variant of zstd frame format, without initial 4-bytes magic number. * Useful to save 4 bytes per generated frame. * Decoder cannot recognise automatically this format, requiring this instruction. / } ZSTD_format_e; typedef enum { / Note: this enum controls ZSTD_d_forceIgnoreChecksum / ZSTD_d_validateChecksum = 0, ZSTD_d_ignoreChecksum = 1 } ZSTD_forceIgnoreChecksum_e; typedef enum { / Note: this enum controls ZSTD_d_refMultipleDDicts / ZSTD_rmd_refSingleDDict = 0, ZSTD_rmd_refMultipleDDicts = 1 } ZSTD_refMultipleDDicts_e; typedef enum { / Note: this enum and the behavior it controls are effectively internal * implementation details of the compressor. They are expected to continue * to evolve and should be considered only in the context of extremely * advanced performance tuning. * * Zstd currently supports the use of a CDict in three ways: * * - The contents of the CDict can be copied into the working context. This * means that the compression can search both the dictionary and input * while operating on a single set of internal tables. This makes * the compression faster per-byte of input. However, the initial copy of * the CDict's tables incurs a fixed cost at the beginning of the * compression. For small compressions (< 8 KB), that copy can dominate * the cost of the compression. * * - The CDict's tables can be used in-place. In this model, compression is * slower per input byte, because the compressor has to search two sets of * tables. However, this model incurs no start-up cost (as long as the * working context's tables can be reused). For small inputs, this can be * faster than copying the CDict's tables. * * - The CDict's tables are not used at all, and instead we use the working * context alone to reload the dictionary and use params based on the source * size. See ZSTD_compress_insertDictionary() and ZSTD_compress_usingDict(). * This method is effective when the dictionary sizes are very small relative * to the input size, and the input size is fairly large to begin with. * * Zstd has a simple internal heuristic that selects which strategy to use * at the beginning of a compression. However, if experimentation shows that * Zstd is making poor choices, it is possible to override that choice with * this enum. / ZSTD_dictDefaultAttach = 0, / Use the default heuristic. / ZSTD_dictForceAttach = 1, / Never copy the dictionary. / ZSTD_dictForceCopy = 2, / Always copy the dictionary. / ZSTD_dictForceLoad = 3 / Always reload the dictionary / } ZSTD_dictAttachPref_e; typedef enum { ZSTD_lcm_auto = 0, /< Automatically determine the compression mode based on the compression level. Negative compression levels will be uncompressed, and positive compression * levels will be compressed. / ZSTD_lcm_huffman = 1, /< Always attempt Huffman compression. Uncompressed literals will still be emitted if Huffman compression is not profitable. / ZSTD_lcm_uncompressed = 2 /< Always emit uncompressed literals. / } ZSTD_literalCompressionMode_e; typedef enum { /* Note: This enum controls features which are conditionally beneficial. Zstd typically will make a final * decision on whether or not to enable the feature (ZSTD_ps_auto), but setting the switch to ZSTD_ps_enable * or ZSTD_ps_disable allow for a force enable/disable the feature. / ZSTD_ps_auto = 0, / Let the library automatically determine whether the feature shall be enabled / ZSTD_ps_enable = 1, / Force-enable the feature / ZSTD_ps_disable = 2 / Do not use the feature / } ZSTD_paramSwitch_e; /************************************** * Frame header and size functions **************************************/ /! ZSTD_findDecompressedSize() : * `src` should point to the start of a series of ZSTD encoded and/or skippable frames * `srcSize` must be the _exact_ size of this series * (i.e. there should be a frame boundary at `src + srcSize`) * @return : - decompressed size of all data in all successive frames * - if the decompressed size cannot be determined: ZSTD_CONTENTSIZE_UNKNOWN * - if an error occurred: ZSTD_CONTENTSIZE_ERROR * * note 1 : decompressed size is an optional field, that may not be present, especially in streaming mode. * When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size. * In which case, it's necessary to use streaming mode to decompress data. * note 2 : decompressed size is always present when compression is done with ZSTD_compress() * note 3 : decompressed size can be very large (64-bits value), * potentially larger than what local system can handle as a single memory segment. * In which case, it's necessary to use streaming mode to decompress data. * note 4 : If source is untrusted, decompressed size could be wrong or intentionally modified. * Always ensure result fits within application's authorized limits. * Each application can set its own limits. * note 5 : ZSTD_findDecompressedSize handles multiple frames, and so it must traverse the input to * read each contained frame header. This is fast as most of the data is skipped, * however it does mean that all frame data must be present and valid. / ZSTDLIB_STATIC_API unsigned long long ZSTD_findDecompressedSize(const void src, size_t srcSize); /! ZSTD_decompressBound() : `src` should point to the start of a series of ZSTD encoded and/or skippable frames * `srcSize` must be the _exact_ size of this series * (i.e. there should be a frame boundary at `src + srcSize`) * @return : - upper-bound for the decompressed size of all data in all successive frames * - if an error occurred: ZSTD_CONTENTSIZE_ERROR * * note 1 : an error can occur if `src` contains an invalid or incorrectly formatted frame. * note 2 : the upper-bound is exact when the decompressed size field is available in every ZSTD encoded frame of `src`. * in this case, `ZSTD_findDecompressedSize` and `ZSTD_decompressBound` return the same value. * note 3 : when the decompressed size field isn't available, the upper-bound for that frame is calculated by: * upper-bound = # blocks * min(128 KB, Window_Size) / ZSTDLIB_STATIC_API unsigned long long ZSTD_decompressBound(const void src, size_t srcSize); /! ZSTD_frameHeaderSize() : srcSize must be >= ZSTD_FRAMEHEADERSIZE_PREFIX. * @return : size of the Frame Header, * or an error code (if srcSize is too small) / ZSTDLIB_STATIC_API size_t ZSTD_frameHeaderSize(const void src, size_t srcSize); typedef enum { ZSTD_frame, ZSTD_skippableFrame } ZSTD_frameType_e; typedef struct { unsigned long long frameContentSize; /* if == ZSTD_CONTENTSIZE_UNKNOWN, it means this field is not available. 0 means "empty" / unsigned long long windowSize; / can be very large, up to <= frameContentSize / unsigned blockSizeMax; ZSTD_frameType_e frameType; / if == ZSTD_skippableFrame, frameContentSize is the size of skippable content / unsigned headerSize; unsigned dictID; unsigned checksumFlag; unsigned _reserved1; unsigned _reserved2; } ZSTD_frameHeader; /! ZSTD_getFrameHeader() : * decode Frame Header, or requires larger `srcSize`. * @return : 0, `zfhPtr` is correctly filled, * >0, `srcSize` is too small, value is wanted `srcSize` amount, * or an error code, which can be tested using ZSTD_isError() / ZSTDLIB_STATIC_API size_t ZSTD_getFrameHeader(ZSTD_frameHeader zfhPtr, const void* src, size_t srcSize); /*< doesn't consume input / /! ZSTD_getFrameHeader_advanced() : same as ZSTD_getFrameHeader(), * with added capability to select a format (like ZSTD_f_zstd1_magicless) / ZSTDLIB_STATIC_API size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format); /! ZSTD_decompressionMargin() : Zstd supports in-place decompression, where the input and output buffers overlap. * In this case, the output buffer must be at least (Margin + Output_Size) bytes large, * and the input buffer must be at the end of the output buffer. * * _______________________ Output Buffer ________________________ * \| \| * \| ____ Input Buffer ____\| * \| \| \| * v v v * \|---------------------------------------\|-----------\|----------\| * ^ ^ ^ * \|___________________ Output_Size ___________________\|_ Margin _\| * * NOTE: See also ZSTD_DECOMPRESSION_MARGIN(). * NOTE: This applies only to single-pass decompression through ZSTD_decompress() or * ZSTD_decompressDCtx(). * NOTE: This function supports multi-frame input. * * @param src The compressed frame(s) * @param srcSize The size of the compressed frame(s) * @returns The decompression margin or an error that can be checked with ZSTD_isError(). / ZSTDLIB_STATIC_API size_t ZSTD_decompressionMargin(const void src, size_t srcSize); /! ZSTD_DECOMPRESS_MARGIN() : Similar to ZSTD_decompressionMargin(), but instead of computing the margin from * the compressed frame, compute it from the original size and the blockSizeLog. * See ZSTD_decompressionMargin() for details. * * WARNING: This macro does not support multi-frame input, the input must be a single * zstd frame. If you need that support use the function, or implement it yourself. * * @param originalSize The original uncompressed size of the data. * @param blockSize The block size == MIN(windowSize, ZSTD_BLOCKSIZE_MAX). * Unless you explicitly set the windowLog smaller than * ZSTD_BLOCKSIZELOG_MAX you can just use ZSTD_BLOCKSIZE_MAX. / #define ZSTD_DECOMPRESSION_MARGIN(originalSize, blockSize) ((size_t)( \ ZSTD_FRAMEHEADERSIZE_MAX / Frame header / + \ 4 / checksum / + \ ((originalSize) == 0 ? 0 : 3 (((originalSize) + (blockSize) - 1) / blockSize)) /* 3 bytes per block / + \ (blockSize) / One block of margin / \ )) typedef enum { ZSTD_sf_noBlockDelimiters = 0, / Representation of ZSTD_Sequence has no block delimiters, sequences only / ZSTD_sf_explicitBlockDelimiters = 1 / Representation of ZSTD_Sequence contains explicit block delimiters / } ZSTD_sequenceFormat_e; /! ZSTD_sequenceBound() : * `srcSize` : size of the input buffer * @return : upper-bound for the number of sequences that can be generated * from a buffer of srcSize bytes * * note : returns number of sequences - to get bytes, multiply by sizeof(ZSTD_Sequence). / ZSTDLIB_STATIC_API size_t ZSTD_sequenceBound(size_t srcSize); /! ZSTD_generateSequences() : * Generate sequences using ZSTD_compress2(), given a source buffer. * * Each block will end with a dummy sequence * with offset == 0, matchLength == 0, and litLength == length of last literals. * litLength may be == 0, and if so, then the sequence of (of: 0 ml: 0 ll: 0) * simply acts as a block delimiter. * * @zc can be used to insert custom compression params. * This function invokes ZSTD_compress2(). * * The output of this function can be fed into ZSTD_compressSequences() with CCtx * setting of ZSTD_c_blockDelimiters as ZSTD_sf_explicitBlockDelimiters * @return : number of sequences generated / ZSTDLIB_STATIC_API size_t ZSTD_generateSequences( ZSTD_CCtx zc, ZSTD_Sequence* outSeqs, size_t outSeqsSize, const void* src, size_t srcSize); /! ZSTD_mergeBlockDelimiters() : Given an array of ZSTD_Sequence, remove all sequences that represent block delimiters/last literals * by merging them into the literals of the next sequence. * * As such, the final generated result has no explicit representation of block boundaries, * and the final last literals segment is not represented in the sequences. * * The output of this function can be fed into ZSTD_compressSequences() with CCtx * setting of ZSTD_c_blockDelimiters as ZSTD_sf_noBlockDelimiters * @return : number of sequences left after merging / ZSTDLIB_STATIC_API size_t ZSTD_mergeBlockDelimiters(ZSTD_Sequence sequences, size_t seqsSize); /! ZSTD_compressSequences() : Compress an array of ZSTD_Sequence, associated with @src buffer, into dst. * @src contains the entire input (not just the literals). * If @srcSize > sum(sequence.length), the remaining bytes are considered all literals * If a dictionary is included, then the cctx should reference the dict. (see: ZSTD_CCtx_refCDict(), ZSTD_CCtx_loadDictionary(), etc.) * The entire source is compressed into a single frame. * * The compression behavior changes based on cctx params. In particular: * If ZSTD_c_blockDelimiters == ZSTD_sf_noBlockDelimiters, the array of ZSTD_Sequence is expected to contain * no block delimiters (defined in ZSTD_Sequence). Block boundaries are roughly determined based on * the block size derived from the cctx, and sequences may be split. This is the default setting. * * If ZSTD_c_blockDelimiters == ZSTD_sf_explicitBlockDelimiters, the array of ZSTD_Sequence is expected to contain * block delimiters (defined in ZSTD_Sequence). Behavior is undefined if no block delimiters are provided. * * If ZSTD_c_validateSequences == 0, this function will blindly accept the sequences provided. Invalid sequences cause undefined * behavior. If ZSTD_c_validateSequences == 1, then if sequence is invalid (see doc/zstd_compression_format.md for * specifics regarding offset/matchlength requirements) then the function will bail out and return an error. * * In addition to the two adjustable experimental params, there are other important cctx params. * - ZSTD_c_minMatch MUST be set as less than or equal to the smallest match generated by the match finder. It has a minimum value of ZSTD_MINMATCH_MIN. * - ZSTD_c_compressionLevel accordingly adjusts the strength of the entropy coder, as it would in typical compression. * - ZSTD_c_windowLog affects offset validation: this function will return an error at higher debug levels if a provided offset * is larger than what the spec allows for a given window log and dictionary (if present). See: doc/zstd_compression_format.md * * Note: Repcodes are, as of now, always re-calculated within this function, so ZSTD_Sequence::rep is unused. * Note 2: Once we integrate ability to ingest repcodes, the explicit block delims mode must respect those repcodes exactly, * and cannot emit an RLE block that disagrees with the repcode history * @return : final compressed size, or a ZSTD error code. / ZSTDLIB_STATIC_API size_t ZSTD_compressSequences( ZSTD_CCtx cctx, void* dst, size_t dstSize, const ZSTD_Sequence* inSeqs, size_t inSeqsSize, const void* src, size_t srcSize); /! ZSTD_writeSkippableFrame() : Generates a zstd skippable frame containing data given by src, and writes it to dst buffer. * * Skippable frames begin with a 4-byte magic number. There are 16 possible choices of magic number, * ranging from ZSTD_MAGIC_SKIPPABLE_START to ZSTD_MAGIC_SKIPPABLE_START+15. * As such, the parameter magicVariant controls the exact skippable frame magic number variant used, so * the magic number used will be ZSTD_MAGIC_SKIPPABLE_START + magicVariant. * * Returns an error if destination buffer is not large enough, if the source size is not representable * with a 4-byte unsigned int, or if the parameter magicVariant is greater than 15 (and therefore invalid). * * @return : number of bytes written or a ZSTD error. / ZSTDLIB_STATIC_API size_t ZSTD_writeSkippableFrame(void dst, size_t dstCapacity, const void* src, size_t srcSize, unsigned magicVariant); /! ZSTD_readSkippableFrame() : Retrieves a zstd skippable frame containing data given by src, and writes it to dst buffer. * * The parameter magicVariant will receive the magicVariant that was supplied when the frame was written, * i.e. magicNumber - ZSTD_MAGIC_SKIPPABLE_START. This can be NULL if the caller is not interested * in the magicVariant. * * Returns an error if destination buffer is not large enough, or if the frame is not skippable. * * @return : number of bytes written or a ZSTD error. / ZSTDLIB_API size_t ZSTD_readSkippableFrame(void dst, size_t dstCapacity, unsigned* magicVariant, const void* src, size_t srcSize); /! ZSTD_isSkippableFrame() : Tells if the content of `buffer` starts with a valid Frame Identifier for a skippable frame. / ZSTDLIB_API unsigned ZSTD_isSkippableFrame(const void buffer, size_t size); /*************************************** * Memory management **************************************/ /! ZSTD_estimate() : These functions make it possible to estimate memory usage * of a future {D,C}Ctx, before its creation. * * ZSTD_estimateCCtxSize() will provide a memory budget large enough * for any compression level up to selected one. * Note : Unlike ZSTD_estimateCStreamSize(), this estimate does not include space for a window buffer. * Therefore, the estimation is only guaranteed for single-shot compressions, not streaming. * The estimate will assume the input may be arbitrarily large, * which is the worst case. * * When srcSize can be bound by a known and rather "small" value, * this fact can be used to provide a tighter estimation * because the CCtx compression context will need less memory. * This tighter estimation can be provided by more advanced functions * ZSTD_estimateCCtxSize_usingCParams(), which can be used in tandem with ZSTD_getCParams(), * and ZSTD_estimateCCtxSize_usingCCtxParams(), which can be used in tandem with ZSTD_CCtxParams_setParameter(). * Both can be used to estimate memory using custom compression parameters and arbitrary srcSize limits. * * Note : only single-threaded compression is supported. * ZSTD_estimateCCtxSize_usingCCtxParams() will return an error code if ZSTD_c_nbWorkers is >= 1. * * Note 2 : ZSTD_estimateCCtxSize* functions are not compatible with the Block-Level Sequence Producer API at this time. * Size estimates assume that no external sequence producer is registered. / ZSTDLIB_STATIC_API size_t ZSTD_estimateCCtxSize(int compressionLevel); ZSTDLIB_STATIC_API size_t ZSTD_estimateCCtxSize_usingCParams(ZSTD_compressionParameters cParams); ZSTDLIB_STATIC_API size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params params); ZSTDLIB_STATIC_API size_t ZSTD_estimateDCtxSize(void); /! ZSTD_estimateCStreamSize() : ZSTD_estimateCStreamSize() will provide a budget large enough for any compression level up to selected one. * It will also consider src size to be arbitrarily "large", which is worst case. * If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation. * ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel. * ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParams_setParameter(). Only single-threaded compression is supported. This function will return an error code if ZSTD_c_nbWorkers is >= 1. * Note : CStream size estimation is only correct for single-threaded compression. * ZSTD_DStream memory budget depends on window Size. * This information can be passed manually, using ZSTD_estimateDStreamSize, * or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame(); * Note : if streaming is init with function ZSTD_init?Stream_usingDict(), * an internal ?Dict will be created, which additional size is not estimated here. * In this case, get total size by adding ZSTD_estimate?DictSize * Note 2 : only single-threaded compression is supported. * ZSTD_estimateCStreamSize_usingCCtxParams() will return an error code if ZSTD_c_nbWorkers is >= 1. * Note 3 : ZSTD_estimateCStreamSize* functions are not compatible with the Block-Level Sequence Producer API at this time. * Size estimates assume that no external sequence producer is registered. / ZSTDLIB_STATIC_API size_t ZSTD_estimateCStreamSize(int compressionLevel); ZSTDLIB_STATIC_API size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams); ZSTDLIB_STATIC_API size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params params); ZSTDLIB_STATIC_API size_t ZSTD_estimateDStreamSize(size_t windowSize); ZSTDLIB_STATIC_API size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize); /! ZSTD_estimate?DictSize() : ZSTD_estimateCDictSize() will bet that src size is relatively "small", and content is copied, like ZSTD_createCDict(). * ZSTD_estimateCDictSize_advanced() makes it possible to control compression parameters precisely, like ZSTD_createCDict_advanced(). * Note : dictionaries created by reference (`ZSTD_dlm_byRef`) are logically smaller. / ZSTDLIB_STATIC_API size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel); ZSTDLIB_STATIC_API size_t ZSTD_estimateCDictSize_advanced(size_t dictSize, ZSTD_compressionParameters cParams, ZSTD_dictLoadMethod_e dictLoadMethod); ZSTDLIB_STATIC_API size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod); /! ZSTD_initStatic() : Initialize an object using a pre-allocated fixed-size buffer. * workspace: The memory area to emplace the object into. * Provided pointer must be 8-bytes aligned. * Buffer must outlive object. * workspaceSize: Use ZSTD_estimateSize() to determine how large workspace must be to support target scenario. * @return : pointer to object (same address as workspace, just different type), * or NULL if error (size too small, incorrect alignment, etc.) * Note : zstd will never resize nor malloc() when using a static buffer. * If the object requires more memory than available, * zstd will just error out (typically ZSTD_error_memory_allocation). * Note 2 : there is no corresponding "free" function. * Since workspace is allocated externally, it must be freed externally too. * Note 3 : cParams : use ZSTD_getCParams() to convert a compression level * into its associated cParams. * Limitation 1 : currently not compatible with internal dictionary creation, triggered by * ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict(). * Limitation 2 : static cctx currently not compatible with multi-threading. * Limitation 3 : static dctx is incompatible with legacy support. / ZSTDLIB_STATIC_API ZSTD_CCtx ZSTD_initStaticCCtx(void* workspace, size_t workspaceSize); ZSTDLIB_STATIC_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize); /*< same as ZSTD_initStaticCCtx() / ZSTDLIB_STATIC_API ZSTD_DCtx* ZSTD_initStaticDCtx(void* workspace, size_t workspaceSize); ZSTDLIB_STATIC_API ZSTD_DStream* ZSTD_initStaticDStream(void* workspace, size_t workspaceSize); /*< same as ZSTD_initStaticDCtx() / ZSTDLIB_STATIC_API const ZSTD_CDict* ZSTD_initStaticCDict( void* workspace, size_t workspaceSize, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType, ZSTD_compressionParameters cParams); ZSTDLIB_STATIC_API const ZSTD_DDict* ZSTD_initStaticDDict( void* workspace, size_t workspaceSize, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType); /! Custom memory allocation : These prototypes make it possible to pass your own allocation/free functions. * ZSTD_customMem is provided at creation time, using ZSTD_create_advanced() variants listed below. All allocation/free operations will be completed using these custom variants instead of regular <stdlib.h> ones. / typedef void (ZSTD_allocFunction) (void opaque, size_t size); typedef void (ZSTD_freeFunction) (void opaque, void* address); typedef struct { ZSTD_allocFunction customAlloc; ZSTD_freeFunction customFree; void* opaque; } ZSTD_customMem; static #ifdef __GNUC__ __attribute__((__unused__)) #endif ZSTD_customMem const ZSTD_defaultCMem = { NULL, NULL, NULL }; /*< this constant defers to stdlib's functions / ZSTDLIB_STATIC_API ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem); ZSTDLIB_STATIC_API ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem); ZSTDLIB_STATIC_API ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem); ZSTDLIB_STATIC_API ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem); ZSTDLIB_STATIC_API ZSTD_CDict* ZSTD_createCDict_advanced(const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType, ZSTD_compressionParameters cParams, ZSTD_customMem customMem); /! Thread pool : These prototypes make it possible to share a thread pool among multiple compression contexts. * This can limit resources for applications with multiple threads where each one uses * a threaded compression mode (via ZSTD_c_nbWorkers parameter). * ZSTD_createThreadPool creates a new thread pool with a given number of threads. * Note that the lifetime of such pool must exist while being used. * ZSTD_CCtx_refThreadPool assigns a thread pool to a context (use NULL argument value * to use an internal thread pool). * ZSTD_freeThreadPool frees a thread pool, accepts NULL pointer. / typedef struct POOL_ctx_s ZSTD_threadPool; ZSTDLIB_STATIC_API ZSTD_threadPool ZSTD_createThreadPool(size_t numThreads); ZSTDLIB_STATIC_API void ZSTD_freeThreadPool (ZSTD_threadPool* pool); /* accept NULL pointer / ZSTDLIB_STATIC_API size_t ZSTD_CCtx_refThreadPool(ZSTD_CCtx cctx, ZSTD_threadPool* pool); /* * This API is temporary and is expected to change or disappear in the future! / ZSTDLIB_STATIC_API ZSTD_CDict ZSTD_createCDict_advanced2( const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType, const ZSTD_CCtx_params* cctxParams, ZSTD_customMem customMem); ZSTDLIB_STATIC_API ZSTD_DDict* ZSTD_createDDict_advanced( const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType, ZSTD_customMem customMem); /*************************************** * Advanced compression functions **************************************/ /! ZSTD_createCDict_byReference() : * Create a digested dictionary for compression * Dictionary content is just referenced, not duplicated. * As a consequence, `dictBuffer` must outlive CDict, * and its content must remain unmodified throughout the lifetime of CDict. * note: equivalent to ZSTD_createCDict_advanced(), with dictLoadMethod==ZSTD_dlm_byRef / ZSTDLIB_STATIC_API ZSTD_CDict ZSTD_createCDict_byReference(const void* dictBuffer, size_t dictSize, int compressionLevel); /! ZSTD_getCParams() : @return ZSTD_compressionParameters structure for a selected compression level and estimated srcSize. * `estimatedSrcSize` value is optional, select 0 if not known / ZSTDLIB_STATIC_API ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize); /! ZSTD_getParams() : * same as ZSTD_getCParams(), but @return a full `ZSTD_parameters` object instead of sub-component `ZSTD_compressionParameters`. * All fields of `ZSTD_frameParameters` are set to default : contentSize=1, checksum=0, noDictID=0 / ZSTDLIB_STATIC_API ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize); /! ZSTD_checkCParams() : * Ensure param values remain within authorized range. * @return 0 on success, or an error code (can be checked with ZSTD_isError()) / ZSTDLIB_STATIC_API size_t ZSTD_checkCParams(ZSTD_compressionParameters params); /! ZSTD_adjustCParams() : * optimize params for a given `srcSize` and `dictSize`. * `srcSize` can be unknown, in which case use ZSTD_CONTENTSIZE_UNKNOWN. * `dictSize` must be `0` when there is no dictionary. * cPar can be invalid : all parameters will be clamped within valid range in the @return struct. * This function never fails (wide contract) / ZSTDLIB_STATIC_API ZSTD_compressionParameters ZSTD_adjustCParams(ZSTD_compressionParameters cPar, unsigned long long srcSize, size_t dictSize); /! ZSTD_CCtx_setCParams() : * Set all parameters provided within @p cparams into the working @p cctx. * Note : if modifying parameters during compression (MT mode only), * note that changes to the .windowLog parameter will be ignored. * @return 0 on success, or an error code (can be checked with ZSTD_isError()). * On failure, no parameters are updated. / ZSTDLIB_STATIC_API size_t ZSTD_CCtx_setCParams(ZSTD_CCtx cctx, ZSTD_compressionParameters cparams); /! ZSTD_CCtx_setFParams() : Set all parameters provided within @p fparams into the working @p cctx. * @return 0 on success, or an error code (can be checked with ZSTD_isError()). / ZSTDLIB_STATIC_API size_t ZSTD_CCtx_setFParams(ZSTD_CCtx cctx, ZSTD_frameParameters fparams); /! ZSTD_CCtx_setParams() : Set all parameters provided within @p params into the working @p cctx. * @return 0 on success, or an error code (can be checked with ZSTD_isError()). / ZSTDLIB_STATIC_API size_t ZSTD_CCtx_setParams(ZSTD_CCtx cctx, ZSTD_parameters params); /! ZSTD_compress_advanced() : Note : this function is now DEPRECATED. * It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_setParameter() and other parameter setters. * This prototype will generate compilation warnings. / ZSTD_DEPRECATED("use ZSTD_compress2") ZSTDLIB_STATIC_API size_t ZSTD_compress_advanced(ZSTD_CCtx cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const void* dict,size_t dictSize, ZSTD_parameters params); /! ZSTD_compress_usingCDict_advanced() : Note : this function is now DEPRECATED. * It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_loadDictionary() and other parameter setters. * This prototype will generate compilation warnings. / ZSTD_DEPRECATED("use ZSTD_compress2 with ZSTD_CCtx_loadDictionary") ZSTDLIB_STATIC_API size_t ZSTD_compress_usingCDict_advanced(ZSTD_CCtx cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const ZSTD_CDict* cdict, ZSTD_frameParameters fParams); /! ZSTD_CCtx_loadDictionary_byReference() : Same as ZSTD_CCtx_loadDictionary(), but dictionary content is referenced, instead of being copied into CCtx. * It saves some memory, but also requires that `dict` outlives its usage within `cctx` / ZSTDLIB_STATIC_API size_t ZSTD_CCtx_loadDictionary_byReference(ZSTD_CCtx cctx, const void* dict, size_t dictSize); /! ZSTD_CCtx_loadDictionary_advanced() : Same as ZSTD_CCtx_loadDictionary(), but gives finer control over * how to load the dictionary (by copy ? by reference ?) * and how to interpret it (automatic ? force raw mode ? full mode only ?) / ZSTDLIB_STATIC_API size_t ZSTD_CCtx_loadDictionary_advanced(ZSTD_CCtx cctx, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType); /! ZSTD_CCtx_refPrefix_advanced() : Same as ZSTD_CCtx_refPrefix(), but gives finer control over * how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?) / ZSTDLIB_STATIC_API size_t ZSTD_CCtx_refPrefix_advanced(ZSTD_CCtx cctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType); /* === experimental parameters === / / these parameters can be used with ZSTD_setParameter() * they are not guaranteed to remain supported in the future / / Enables rsyncable mode, * which makes compressed files more rsync friendly * by adding periodic synchronization points to the compressed data. * The target average block size is ZSTD_c_jobSize / 2. * It's possible to modify the job size to increase or decrease * the granularity of the synchronization point. * Once the jobSize is smaller than the window size, * it will result in compression ratio degradation. * NOTE 1: rsyncable mode only works when multithreading is enabled. * NOTE 2: rsyncable performs poorly in combination with long range mode, * since it will decrease the effectiveness of synchronization points, * though mileage may vary. * NOTE 3: Rsyncable mode limits maximum compression speed to ~400 MB/s. * If the selected compression level is already running significantly slower, * the overall speed won't be significantly impacted. / #define ZSTD_c_rsyncable ZSTD_c_experimentalParam1 / Select a compression format. * The value must be of type ZSTD_format_e. * See ZSTD_format_e enum definition for details / #define ZSTD_c_format ZSTD_c_experimentalParam2 / Force back-reference distances to remain < windowSize, * even when referencing into Dictionary content (default:0) / #define ZSTD_c_forceMaxWindow ZSTD_c_experimentalParam3 / Controls whether the contents of a CDict * are used in place, or copied into the working context. * Accepts values from the ZSTD_dictAttachPref_e enum. * See the comments on that enum for an explanation of the feature. / #define ZSTD_c_forceAttachDict ZSTD_c_experimentalParam4 / Controlled with ZSTD_paramSwitch_e enum. * Default is ZSTD_ps_auto. * Set to ZSTD_ps_disable to never compress literals. * Set to ZSTD_ps_enable to always compress literals. (Note: uncompressed literals * may still be emitted if huffman is not beneficial to use.) * * By default, in ZSTD_ps_auto, the library will decide at runtime whether to use * literals compression based on the compression parameters - specifically, * negative compression levels do not use literal compression. / #define ZSTD_c_literalCompressionMode ZSTD_c_experimentalParam5 / Tries to fit compressed block size to be around targetCBlockSize. * No target when targetCBlockSize == 0. * There is no guarantee on compressed block size (default:0) / #define ZSTD_c_targetCBlockSize ZSTD_c_experimentalParam6 / User's best guess of source size. * Hint is not valid when srcSizeHint == 0. * There is no guarantee that hint is close to actual source size, * but compression ratio may regress significantly if guess considerably underestimates / #define ZSTD_c_srcSizeHint ZSTD_c_experimentalParam7 / Controls whether the new and experimental "dedicated dictionary search * structure" can be used. This feature is still rough around the edges, be * prepared for surprising behavior! * * How to use it: * * When using a CDict, whether to use this feature or not is controlled at * CDict creation, and it must be set in a CCtxParams set passed into that * construction (via ZSTD_createCDict_advanced2()). A compression will then * use the feature or not based on how the CDict was constructed; the value of * this param, set in the CCtx, will have no effect. * * However, when a dictionary buffer is passed into a CCtx, such as via * ZSTD_CCtx_loadDictionary(), this param can be set on the CCtx to control * whether the CDict that is created internally can use the feature or not. * * What it does: * * Normally, the internal data structures of the CDict are analogous to what * would be stored in a CCtx after compressing the contents of a dictionary. * To an approximation, a compression using a dictionary can then use those * data structures to simply continue what is effectively a streaming * compression where the simulated compression of the dictionary left off. * Which is to say, the search structures in the CDict are normally the same * format as in the CCtx. * * It is possible to do better, since the CDict is not like a CCtx: the search * structures are written once during CDict creation, and then are only read * after that, while the search structures in the CCtx are both read and * written as the compression goes along. This means we can choose a search * structure for the dictionary that is read-optimized. * * This feature enables the use of that different structure. * * Note that some of the members of the ZSTD_compressionParameters struct have * different semantics and constraints in the dedicated search structure. It is * highly recommended that you simply set a compression level in the CCtxParams * you pass into the CDict creation call, and avoid messing with the cParams * directly. * * Effects: * * This will only have any effect when the selected ZSTD_strategy * implementation supports this feature. Currently, that's limited to * ZSTD_greedy, ZSTD_lazy, and ZSTD_lazy2. * * Note that this means that the CDict tables can no longer be copied into the * CCtx, so the dict attachment mode ZSTD_dictForceCopy will no longer be * usable. The dictionary can only be attached or reloaded. * * In general, you should expect compression to be faster--sometimes very much * so--and CDict creation to be slightly slower. Eventually, we will probably * make this mode the default. / #define ZSTD_c_enableDedicatedDictSearch ZSTD_c_experimentalParam8 / ZSTD_c_stableInBuffer * Experimental parameter. * Default is 0 == disabled. Set to 1 to enable. * * Tells the compressor that input data presented with ZSTD_inBuffer * will ALWAYS be the same between calls. * Technically, the @src pointer must never be changed, * and the @pos field can only be updated by zstd. * However, it's possible to increase the @size field, * allowing scenarios where more data can be appended after compressions starts. * These conditions are checked by the compressor, * and compression will fail if they are not respected. * Also, data in the ZSTD_inBuffer within the range [src, src + pos) * MUST not be modified during compression or it will result in data corruption. * * When this flag is enabled zstd won't allocate an input window buffer, * because the user guarantees it can reference the ZSTD_inBuffer until * the frame is complete. But, it will still allocate an output buffer * large enough to fit a block (see ZSTD_c_stableOutBuffer). This will also * avoid the memcpy() from the input buffer to the input window buffer. * * NOTE: So long as the ZSTD_inBuffer always points to valid memory, using * this flag is ALWAYS memory safe, and will never access out-of-bounds * memory. However, compression WILL fail if conditions are not respected. * * WARNING: The data in the ZSTD_inBuffer in the range [src, src + pos) MUST * not be modified during compression or it will result in data corruption. * This is because zstd needs to reference data in the ZSTD_inBuffer to find * matches. Normally zstd maintains its own window buffer for this purpose, * but passing this flag tells zstd to rely on user provided buffer instead. / #define ZSTD_c_stableInBuffer ZSTD_c_experimentalParam9 / ZSTD_c_stableOutBuffer * Experimental parameter. * Default is 0 == disabled. Set to 1 to enable. * * Tells he compressor that the ZSTD_outBuffer will not be resized between * calls. Specifically: (out.size - out.pos) will never grow. This gives the * compressor the freedom to say: If the compressed data doesn't fit in the * output buffer then return ZSTD_error_dstSizeTooSmall. This allows us to * always decompress directly into the output buffer, instead of decompressing * into an internal buffer and copying to the output buffer. * * When this flag is enabled zstd won't allocate an output buffer, because * it can write directly to the ZSTD_outBuffer. It will still allocate the * input window buffer (see ZSTD_c_stableInBuffer). * * Zstd will check that (out.size - out.pos) never grows and return an error * if it does. While not strictly necessary, this should prevent surprises. / #define ZSTD_c_stableOutBuffer ZSTD_c_experimentalParam10 / ZSTD_c_blockDelimiters * Default is 0 == ZSTD_sf_noBlockDelimiters. * * For use with sequence compression API: ZSTD_compressSequences(). * * Designates whether or not the given array of ZSTD_Sequence contains block delimiters * and last literals, which are defined as sequences with offset == 0 and matchLength == 0. * See the definition of ZSTD_Sequence for more specifics. / #define ZSTD_c_blockDelimiters ZSTD_c_experimentalParam11 / ZSTD_c_validateSequences * Default is 0 == disabled. Set to 1 to enable sequence validation. * * For use with sequence compression API: ZSTD_compressSequences(). * Designates whether or not we validate sequences provided to ZSTD_compressSequences() * during function execution. * * Without validation, providing a sequence that does not conform to the zstd spec will cause * undefined behavior, and may produce a corrupted block. * * With validation enabled, if sequence is invalid (see doc/zstd_compression_format.md for * specifics regarding offset/matchlength requirements) then the function will bail out and * return an error. * / #define ZSTD_c_validateSequences ZSTD_c_experimentalParam12 / ZSTD_c_useBlockSplitter * Controlled with ZSTD_paramSwitch_e enum. * Default is ZSTD_ps_auto. * Set to ZSTD_ps_disable to never use block splitter. * Set to ZSTD_ps_enable to always use block splitter. * * By default, in ZSTD_ps_auto, the library will decide at runtime whether to use * block splitting based on the compression parameters. / #define ZSTD_c_useBlockSplitter ZSTD_c_experimentalParam13 / ZSTD_c_useRowMatchFinder * Controlled with ZSTD_paramSwitch_e enum. * Default is ZSTD_ps_auto. * Set to ZSTD_ps_disable to never use row-based matchfinder. * Set to ZSTD_ps_enable to force usage of row-based matchfinder. * * By default, in ZSTD_ps_auto, the library will decide at runtime whether to use * the row-based matchfinder based on support for SIMD instructions and the window log. * Note that this only pertains to compression strategies: greedy, lazy, and lazy2 / #define ZSTD_c_useRowMatchFinder ZSTD_c_experimentalParam14 / ZSTD_c_deterministicRefPrefix * Default is 0 == disabled. Set to 1 to enable. * * Zstd produces different results for prefix compression when the prefix is * directly adjacent to the data about to be compressed vs. when it isn't. * This is because zstd detects that the two buffers are contiguous and it can * use a more efficient match finding algorithm. However, this produces different * results than when the two buffers are non-contiguous. This flag forces zstd * to always load the prefix in non-contiguous mode, even if it happens to be * adjacent to the data, to guarantee determinism. * * If you really care about determinism when using a dictionary or prefix, * like when doing delta compression, you should select this option. It comes * at a speed penalty of about ~2.5% if the dictionary and data happened to be * contiguous, and is free if they weren't contiguous. We don't expect that * intentionally making the dictionary and data contiguous will be worth the * cost to memcpy() the data. / #define ZSTD_c_deterministicRefPrefix ZSTD_c_experimentalParam15 / ZSTD_c_prefetchCDictTables * Controlled with ZSTD_paramSwitch_e enum. Default is ZSTD_ps_auto. * * In some situations, zstd uses CDict tables in-place rather than copying them * into the working context. (See docs on ZSTD_dictAttachPref_e above for details). * In such situations, compression speed is seriously impacted when CDict tables are * "cold" (outside CPU cache). This parameter instructs zstd to prefetch CDict tables * when they are used in-place. * * For sufficiently small inputs, the cost of the prefetch will outweigh the benefit. * For sufficiently large inputs, zstd will by default memcpy() CDict tables * into the working context, so there is no need to prefetch. This parameter is * targeted at a middle range of input sizes, where a prefetch is cheap enough to be * useful but memcpy() is too expensive. The exact range of input sizes where this * makes sense is best determined by careful experimentation. * * Note: for this parameter, ZSTD_ps_auto is currently equivalent to ZSTD_ps_disable, * but in the future zstd may conditionally enable this feature via an auto-detection * heuristic for cold CDicts. * Use ZSTD_ps_disable to opt out of prefetching under any circumstances. / #define ZSTD_c_prefetchCDictTables ZSTD_c_experimentalParam16 / ZSTD_c_enableSeqProducerFallback * Allowed values are 0 (disable) and 1 (enable). The default setting is 0. * * Controls whether zstd will fall back to an internal sequence producer if an * external sequence producer is registered and returns an error code. This fallback * is block-by-block: the internal sequence producer will only be called for blocks * where the external sequence producer returns an error code. Fallback parsing will * follow any other cParam settings, such as compression level, the same as in a * normal (fully-internal) compression operation. * * The user is strongly encouraged to read the full Block-Level Sequence Producer API * documentation (below) before setting this parameter. / #define ZSTD_c_enableSeqProducerFallback ZSTD_c_experimentalParam17 / ZSTD_c_maxBlockSize * Allowed values are between 1KB and ZSTD_BLOCKSIZE_MAX (128KB). * The default is ZSTD_BLOCKSIZE_MAX, and setting to 0 will set to the default. * * This parameter can be used to set an upper bound on the blocksize * that overrides the default ZSTD_BLOCKSIZE_MAX. It cannot be used to set upper * bounds greater than ZSTD_BLOCKSIZE_MAX or bounds lower than 1KB (will make * compressBound() inaccurate). Only currently meant to be used for testing. * / #define ZSTD_c_maxBlockSize ZSTD_c_experimentalParam18 / ZSTD_c_searchForExternalRepcodes * This parameter affects how zstd parses external sequences, such as sequences * provided through the compressSequences() API or from an external block-level * sequence producer. * * If set to ZSTD_ps_enable, the library will check for repeated offsets in * external sequences, even if those repcodes are not explicitly indicated in * the "rep" field. Note that this is the only way to exploit repcode matches * while using compressSequences() or an external sequence producer, since zstd * currently ignores the "rep" field of external sequences. * * If set to ZSTD_ps_disable, the library will not exploit repeated offsets in * external sequences, regardless of whether the "rep" field has been set. This * reduces sequence compression overhead by about 25% while sacrificing some * compression ratio. * * The default value is ZSTD_ps_auto, for which the library will enable/disable * based on compression level. * * Note: for now, this param only has an effect if ZSTD_c_blockDelimiters is * set to ZSTD_sf_explicitBlockDelimiters. That may change in the future. / #define ZSTD_c_searchForExternalRepcodes ZSTD_c_experimentalParam19 /! ZSTD_CCtx_getParameter() : * Get the requested compression parameter value, selected by enum ZSTD_cParameter, * and store it into int* value. * @return : 0, or an error code (which can be tested with ZSTD_isError()). / ZSTDLIB_STATIC_API size_t ZSTD_CCtx_getParameter(const ZSTD_CCtx cctx, ZSTD_cParameter param, int* value); /! ZSTD_CCtx_params : Quick howto : * - ZSTD_createCCtxParams() : Create a ZSTD_CCtx_params structure * - ZSTD_CCtxParams_setParameter() : Push parameters one by one into * an existing ZSTD_CCtx_params structure. * This is similar to * ZSTD_CCtx_setParameter(). * - ZSTD_CCtx_setParametersUsingCCtxParams() : Apply parameters to * an existing CCtx. * These parameters will be applied to * all subsequent frames. * - ZSTD_compressStream2() : Do compression using the CCtx. * - ZSTD_freeCCtxParams() : Free the memory, accept NULL pointer. * * This can be used with ZSTD_estimateCCtxSize_advanced_usingCCtxParams() * for static allocation of CCtx for single-threaded compression. / ZSTDLIB_STATIC_API ZSTD_CCtx_params ZSTD_createCCtxParams(void); ZSTDLIB_STATIC_API size_t ZSTD_freeCCtxParams(ZSTD_CCtx_params* params); /* accept NULL pointer / /! ZSTD_CCtxParams_reset() : * Reset params to default values. / ZSTDLIB_STATIC_API size_t ZSTD_CCtxParams_reset(ZSTD_CCtx_params params); /! ZSTD_CCtxParams_init() : Initializes the compression parameters of cctxParams according to * compression level. All other parameters are reset to their default values. / ZSTDLIB_STATIC_API size_t ZSTD_CCtxParams_init(ZSTD_CCtx_params cctxParams, int compressionLevel); /! ZSTD_CCtxParams_init_advanced() : Initializes the compression and frame parameters of cctxParams according to * params. All other parameters are reset to their default values. / ZSTDLIB_STATIC_API size_t ZSTD_CCtxParams_init_advanced(ZSTD_CCtx_params cctxParams, ZSTD_parameters params); /! ZSTD_CCtxParams_setParameter() : Requires v1.4.0+ Similar to ZSTD_CCtx_setParameter. * Set one compression parameter, selected by enum ZSTD_cParameter. * Parameters must be applied to a ZSTD_CCtx using * ZSTD_CCtx_setParametersUsingCCtxParams(). * @result : a code representing success or failure (which can be tested with * ZSTD_isError()). / ZSTDLIB_STATIC_API size_t ZSTD_CCtxParams_setParameter(ZSTD_CCtx_params params, ZSTD_cParameter param, int value); /! ZSTD_CCtxParams_getParameter() : Similar to ZSTD_CCtx_getParameter. * Get the requested value of one compression parameter, selected by enum ZSTD_cParameter. * @result : 0, or an error code (which can be tested with ZSTD_isError()). / ZSTDLIB_STATIC_API size_t ZSTD_CCtxParams_getParameter(const ZSTD_CCtx_params params, ZSTD_cParameter param, int* value); /! ZSTD_CCtx_setParametersUsingCCtxParams() : Apply a set of ZSTD_CCtx_params to the compression context. * This can be done even after compression is started, * if nbWorkers==0, this will have no impact until a new compression is started. * if nbWorkers>=1, new parameters will be picked up at next job, * with a few restrictions (windowLog, pledgedSrcSize, nbWorkers, jobSize, and overlapLog are not updated). / ZSTDLIB_STATIC_API size_t ZSTD_CCtx_setParametersUsingCCtxParams( ZSTD_CCtx cctx, const ZSTD_CCtx_params* params); /! ZSTD_compressStream2_simpleArgs() : Same as ZSTD_compressStream2(), * but using only integral types as arguments. * This variant might be helpful for binders from dynamic languages * which have troubles handling structures containing memory pointers. / ZSTDLIB_STATIC_API size_t ZSTD_compressStream2_simpleArgs ( ZSTD_CCtx cctx, void* dst, size_t dstCapacity, size_t* dstPos, const void* src, size_t srcSize, size_t* srcPos, ZSTD_EndDirective endOp); /*************************************** * Advanced decompression functions **************************************/ /! ZSTD_isFrame() : * Tells if the content of `buffer` starts with a valid Frame Identifier. * Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0. * Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled. * Note 3 : Skippable Frame Identifiers are considered valid. / ZSTDLIB_STATIC_API unsigned ZSTD_isFrame(const void buffer, size_t size); /! ZSTD_createDDict_byReference() : Create a digested dictionary, ready to start decompression operation without startup delay. * Dictionary content is referenced, and therefore stays in dictBuffer. * It is important that dictBuffer outlives DDict, * it must remain read accessible throughout the lifetime of DDict / ZSTDLIB_STATIC_API ZSTD_DDict ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize); /! ZSTD_DCtx_loadDictionary_byReference() : Same as ZSTD_DCtx_loadDictionary(), * but references `dict` content instead of copying it into `dctx`. * This saves memory if `dict` remains around., * However, it's imperative that `dict` remains accessible (and unmodified) while being used, so it must outlive decompression. / ZSTDLIB_STATIC_API size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx dctx, const void* dict, size_t dictSize); /! ZSTD_DCtx_loadDictionary_advanced() : Same as ZSTD_DCtx_loadDictionary(), * but gives direct control over * how to load the dictionary (by copy ? by reference ?) * and how to interpret it (automatic ? force raw mode ? full mode only ?). / ZSTDLIB_STATIC_API size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx dctx, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType); /! ZSTD_DCtx_refPrefix_advanced() : Same as ZSTD_DCtx_refPrefix(), but gives finer control over * how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?) / ZSTDLIB_STATIC_API size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType); /! ZSTD_DCtx_setMaxWindowSize() : Refuses allocating internal buffers for frames requiring a window size larger than provided limit. * This protects a decoder context from reserving too much memory for itself (potential attack scenario). * This parameter is only useful in streaming mode, since no internal buffer is allocated in single-pass mode. * By default, a decompression context accepts all window sizes <= (1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT) * @return : 0, or an error code (which can be tested using ZSTD_isError()). / ZSTDLIB_STATIC_API size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx dctx, size_t maxWindowSize); /! ZSTD_DCtx_getParameter() : Get the requested decompression parameter value, selected by enum ZSTD_dParameter, * and store it into int* value. * @return : 0, or an error code (which can be tested with ZSTD_isError()). / ZSTDLIB_STATIC_API size_t ZSTD_DCtx_getParameter(ZSTD_DCtx dctx, ZSTD_dParameter param, int* value); /* ZSTD_d_format * experimental parameter, * allowing selection between ZSTD_format_e input compression formats / #define ZSTD_d_format ZSTD_d_experimentalParam1 / ZSTD_d_stableOutBuffer * Experimental parameter. * Default is 0 == disabled. Set to 1 to enable. * * Tells the decompressor that the ZSTD_outBuffer will ALWAYS be the same * between calls, except for the modifications that zstd makes to pos (the * caller must not modify pos). This is checked by the decompressor, and * decompression will fail if it ever changes. Therefore the ZSTD_outBuffer * MUST be large enough to fit the entire decompressed frame. This will be * checked when the frame content size is known. The data in the ZSTD_outBuffer * in the range [dst, dst + pos) MUST not be modified during decompression * or you will get data corruption. * * When this flag is enabled zstd won't allocate an output buffer, because * it can write directly to the ZSTD_outBuffer, but it will still allocate * an input buffer large enough to fit any compressed block. This will also * avoid the memcpy() from the internal output buffer to the ZSTD_outBuffer. * If you need to avoid the input buffer allocation use the buffer-less * streaming API. * * NOTE: So long as the ZSTD_outBuffer always points to valid memory, using * this flag is ALWAYS memory safe, and will never access out-of-bounds * memory. However, decompression WILL fail if you violate the preconditions. * * WARNING: The data in the ZSTD_outBuffer in the range [dst, dst + pos) MUST * not be modified during decompression or you will get data corruption. This * is because zstd needs to reference data in the ZSTD_outBuffer to regenerate * matches. Normally zstd maintains its own buffer for this purpose, but passing * this flag tells zstd to use the user provided buffer. / #define ZSTD_d_stableOutBuffer ZSTD_d_experimentalParam2 / ZSTD_d_forceIgnoreChecksum * Experimental parameter. * Default is 0 == disabled. Set to 1 to enable * * Tells the decompressor to skip checksum validation during decompression, regardless * of whether checksumming was specified during compression. This offers some * slight performance benefits, and may be useful for debugging. * Param has values of type ZSTD_forceIgnoreChecksum_e / #define ZSTD_d_forceIgnoreChecksum ZSTD_d_experimentalParam3 / ZSTD_d_refMultipleDDicts * Experimental parameter. * Default is 0 == disabled. Set to 1 to enable * * If enabled and dctx is allocated on the heap, then additional memory will be allocated * to store references to multiple ZSTD_DDict. That is, multiple calls of ZSTD_refDDict() * using a given ZSTD_DCtx, rather than overwriting the previous DDict reference, will instead * store all references. At decompression time, the appropriate dictID is selected * from the set of DDicts based on the dictID in the frame. * * Usage is simply calling ZSTD_refDDict() on multiple dict buffers. * * Param has values of byte ZSTD_refMultipleDDicts_e * * WARNING: Enabling this parameter and calling ZSTD_DCtx_refDDict(), will trigger memory * allocation for the hash table. ZSTD_freeDCtx() also frees this memory. * Memory is allocated as per ZSTD_DCtx::customMem. * * Although this function allocates memory for the table, the user is still responsible for * memory management of the underlying ZSTD_DDict* themselves. / #define ZSTD_d_refMultipleDDicts ZSTD_d_experimentalParam4 / ZSTD_d_disableHuffmanAssembly * Set to 1 to disable the Huffman assembly implementation. * The default value is 0, which allows zstd to use the Huffman assembly * implementation if available. * * This parameter can be used to disable Huffman assembly at runtime. * If you want to disable it at compile time you can define the macro * ZSTD_DISABLE_ASM. / #define ZSTD_d_disableHuffmanAssembly ZSTD_d_experimentalParam5 /! ZSTD_DCtx_setFormat() : * This function is REDUNDANT. Prefer ZSTD_DCtx_setParameter(). * Instruct the decoder context about what kind of data to decode next. * This instruction is mandatory to decode data without a fully-formed header, * such ZSTD_f_zstd1_magicless for example. * @return : 0, or an error code (which can be tested using ZSTD_isError()). / ZSTD_DEPRECATED("use ZSTD_DCtx_setParameter() instead") ZSTDLIB_STATIC_API size_t ZSTD_DCtx_setFormat(ZSTD_DCtx dctx, ZSTD_format_e format); /! ZSTD_decompressStream_simpleArgs() : Same as ZSTD_decompressStream(), * but using only integral types as arguments. * This can be helpful for binders from dynamic languages * which have troubles handling structures containing memory pointers. / ZSTDLIB_STATIC_API size_t ZSTD_decompressStream_simpleArgs ( ZSTD_DCtx dctx, void* dst, size_t dstCapacity, size_t* dstPos, const void* src, size_t srcSize, size_t* srcPos); /******************************************************************** * Advanced streaming functions * Warning : most of these functions are now redundant with the Advanced API. * Once Advanced API reaches "stable" status, * redundant functions will be deprecated, and then at some point removed. *******************************************************************/ /===== Advanced Streaming compression functions =====/ /! ZSTD_initCStream_srcSize() : * This function is DEPRECATED, and equivalent to: * ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only); * ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any) * ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel); * ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize); * * pledgedSrcSize must be correct. If it is not known at init time, use * ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs, * "0" also disables frame content size field. It may be enabled in the future. * This prototype will generate compilation warnings. / ZSTD_DEPRECATED("use ZSTD_CCtx_reset, see zstd.h for detailed instructions") ZSTDLIB_STATIC_API size_t ZSTD_initCStream_srcSize(ZSTD_CStream zcs, int compressionLevel, unsigned long long pledgedSrcSize); /! ZSTD_initCStream_usingDict() : This function is DEPRECATED, and is equivalent to: * ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only); * ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel); * ZSTD_CCtx_loadDictionary(zcs, dict, dictSize); * * Creates of an internal CDict (incompatible with static CCtx), except if * dict == NULL or dictSize < 8, in which case no dict is used. * Note: dict is loaded with ZSTD_dct_auto (treated as a full zstd dictionary if * it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy. * This prototype will generate compilation warnings. / ZSTD_DEPRECATED("use ZSTD_CCtx_reset, see zstd.h for detailed instructions") ZSTDLIB_STATIC_API size_t ZSTD_initCStream_usingDict(ZSTD_CStream zcs, const void* dict, size_t dictSize, int compressionLevel); /! ZSTD_initCStream_advanced() : This function is DEPRECATED, and is equivalent to: * ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only); * ZSTD_CCtx_setParams(zcs, params); * ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize); * ZSTD_CCtx_loadDictionary(zcs, dict, dictSize); * * dict is loaded with ZSTD_dct_auto and ZSTD_dlm_byCopy. * pledgedSrcSize must be correct. * If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. * This prototype will generate compilation warnings. / ZSTD_DEPRECATED("use ZSTD_CCtx_reset, see zstd.h for detailed instructions") ZSTDLIB_STATIC_API size_t ZSTD_initCStream_advanced(ZSTD_CStream zcs, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize); /! ZSTD_initCStream_usingCDict() : This function is DEPRECATED, and equivalent to: * ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only); * ZSTD_CCtx_refCDict(zcs, cdict); * * note : cdict will just be referenced, and must outlive compression session * This prototype will generate compilation warnings. / ZSTD_DEPRECATED("use ZSTD_CCtx_reset and ZSTD_CCtx_refCDict, see zstd.h for detailed instructions") ZSTDLIB_STATIC_API size_t ZSTD_initCStream_usingCDict(ZSTD_CStream zcs, const ZSTD_CDict* cdict); /! ZSTD_initCStream_usingCDict_advanced() : This function is DEPRECATED, and is equivalent to: * ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only); * ZSTD_CCtx_setFParams(zcs, fParams); * ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize); * ZSTD_CCtx_refCDict(zcs, cdict); * * same as ZSTD_initCStream_usingCDict(), with control over frame parameters. * pledgedSrcSize must be correct. If srcSize is not known at init time, use * value ZSTD_CONTENTSIZE_UNKNOWN. * This prototype will generate compilation warnings. / ZSTD_DEPRECATED("use ZSTD_CCtx_reset and ZSTD_CCtx_refCDict, see zstd.h for detailed instructions") ZSTDLIB_STATIC_API size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream zcs, const ZSTD_CDict* cdict, ZSTD_frameParameters fParams, unsigned long long pledgedSrcSize); /! ZSTD_resetCStream() : This function is DEPRECATED, and is equivalent to: * ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only); * ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize); * Note: ZSTD_resetCStream() interprets pledgedSrcSize == 0 as ZSTD_CONTENTSIZE_UNKNOWN, but * ZSTD_CCtx_setPledgedSrcSize() does not do the same, so ZSTD_CONTENTSIZE_UNKNOWN must be * explicitly specified. * * start a new frame, using same parameters from previous frame. * This is typically useful to skip dictionary loading stage, since it will re-use it in-place. * Note that zcs must be init at least once before using ZSTD_resetCStream(). * If pledgedSrcSize is not known at reset time, use macro ZSTD_CONTENTSIZE_UNKNOWN. * If pledgedSrcSize > 0, its value must be correct, as it will be written in header, and controlled at the end. * For the time being, pledgedSrcSize==0 is interpreted as "srcSize unknown" for compatibility with older programs, * but it will change to mean "empty" in future version, so use macro ZSTD_CONTENTSIZE_UNKNOWN instead. * @return : 0, or an error code (which can be tested using ZSTD_isError()) * This prototype will generate compilation warnings. / ZSTD_DEPRECATED("use ZSTD_CCtx_reset, see zstd.h for detailed instructions") ZSTDLIB_STATIC_API size_t ZSTD_resetCStream(ZSTD_CStream zcs, unsigned long long pledgedSrcSize); typedef struct { unsigned long long ingested; /* nb input bytes read and buffered / unsigned long long consumed; / nb input bytes actually compressed / unsigned long long produced; / nb of compressed bytes generated and buffered / unsigned long long flushed; / nb of compressed bytes flushed : not provided; can be tracked from caller side / unsigned currentJobID; / MT only : latest started job nb / unsigned nbActiveWorkers; / MT only : nb of workers actively compressing at probe time / } ZSTD_frameProgression; / ZSTD_getFrameProgression() : * tells how much data has been ingested (read from input) * consumed (input actually compressed) and produced (output) for current frame. * Note : (ingested - consumed) is amount of input data buffered internally, not yet compressed. * Aggregates progression inside active worker threads. / ZSTDLIB_STATIC_API ZSTD_frameProgression ZSTD_getFrameProgression(const ZSTD_CCtx cctx); /! ZSTD_toFlushNow() : Tell how many bytes are ready to be flushed immediately. * Useful for multithreading scenarios (nbWorkers >= 1). * Probe the oldest active job, defined as oldest job not yet entirely flushed, * and check its output buffer. * @return : amount of data stored in oldest job and ready to be flushed immediately. * if @return == 0, it means either : * + there is no active job (could be checked with ZSTD_frameProgression()), or * + oldest job is still actively compressing data, * but everything it has produced has also been flushed so far, * therefore flush speed is limited by production speed of oldest job * irrespective of the speed of concurrent (and newer) jobs. / ZSTDLIB_STATIC_API size_t ZSTD_toFlushNow(ZSTD_CCtx cctx); /===== Advanced Streaming decompression functions =====/ /! This function is deprecated, and is equivalent to: * * ZSTD_DCtx_reset(zds, ZSTD_reset_session_only); * ZSTD_DCtx_loadDictionary(zds, dict, dictSize); * * note: no dictionary will be used if dict == NULL or dictSize < 8 / ZSTD_DEPRECATED("use ZSTD_DCtx_reset + ZSTD_DCtx_loadDictionary, see zstd.h for detailed instructions") ZSTDLIB_STATIC_API size_t ZSTD_initDStream_usingDict(ZSTD_DStream zds, const void* dict, size_t dictSize); /! This function is deprecated, and is equivalent to: * * ZSTD_DCtx_reset(zds, ZSTD_reset_session_only); * ZSTD_DCtx_refDDict(zds, ddict); * * note : ddict is referenced, it must outlive decompression session / ZSTD_DEPRECATED("use ZSTD_DCtx_reset + ZSTD_DCtx_refDDict, see zstd.h for detailed instructions") ZSTDLIB_STATIC_API size_t ZSTD_initDStream_usingDDict(ZSTD_DStream zds, const ZSTD_DDict* ddict); /! This function is deprecated, and is equivalent to: * * ZSTD_DCtx_reset(zds, ZSTD_reset_session_only); * * re-use decompression parameters from previous init; saves dictionary loading / ZSTD_DEPRECATED("use ZSTD_DCtx_reset, see zstd.h for detailed instructions") ZSTDLIB_STATIC_API size_t ZSTD_resetDStream(ZSTD_DStream zds); /* ******************* BLOCK-LEVEL SEQUENCE PRODUCER API ******************* * * * OVERVIEW * * The Block-Level Sequence Producer API allows users to provide their own custom * sequence producer which libzstd invokes to process each block. The produced list * of sequences (literals and matches) is then post-processed by libzstd to produce * valid compressed blocks. * * This block-level offload API is a more granular complement of the existing * frame-level offload API compressSequences() (introduced in v1.5.1). It offers * an easier migration story for applications already integrated with libzstd: the * user application continues to invoke the same compression functions * ZSTD_compress2() or ZSTD_compressStream2() as usual, and transparently benefits * from the specific advantages of the external sequence producer. For example, * the sequence producer could be tuned to take advantage of known characteristics * of the input, to offer better speed / ratio, or could leverage hardware * acceleration not available within libzstd itself. * * See contrib/externalSequenceProducer for an example program employing the * Block-Level Sequence Producer API. * * * USAGE * * The user is responsible for implementing a function of type * ZSTD_sequenceProducer_F. For each block, zstd will pass the following * arguments to the user-provided function: * * - sequenceProducerState: a pointer to a user-managed state for the sequence * producer. * * - outSeqs, outSeqsCapacity: an output buffer for the sequence producer. * outSeqsCapacity is guaranteed >= ZSTD_sequenceBound(srcSize). The memory * backing outSeqs is managed by the CCtx. * * - src, srcSize: an input buffer for the sequence producer to parse. * srcSize is guaranteed to be <= ZSTD_BLOCKSIZE_MAX. * * - dict, dictSize: a history buffer, which may be empty, which the sequence * producer may reference as it parses the src buffer. Currently, zstd will * always pass dictSize == 0 into external sequence producers, but this will * change in the future. * * - compressionLevel: a signed integer representing the zstd compression level * set by the user for the current operation. The sequence producer may choose * to use this information to change its compression strategy and speed/ratio * tradeoff. Note: the compression level does not reflect zstd parameters set * through the advanced API. * * - windowSize: a size_t representing the maximum allowed offset for external * sequences. Note that sequence offsets are sometimes allowed to exceed the * windowSize if a dictionary is present, see doc/zstd_compression_format.md * for details. * * The user-provided function shall return a size_t representing the number of * sequences written to outSeqs. This return value will be treated as an error * code if it is greater than outSeqsCapacity. The return value must be non-zero * if srcSize is non-zero. The ZSTD_SEQUENCE_PRODUCER_ERROR macro is provided * for convenience, but any value greater than outSeqsCapacity will be treated as * an error code. * * If the user-provided function does not return an error code, the sequences * written to outSeqs must be a valid parse of the src buffer. Data corruption may * occur if the parse is not valid. A parse is defined to be valid if the * following conditions hold: * - The sum of matchLengths and literalLengths must equal srcSize. * - All sequences in the parse, except for the final sequence, must have * matchLength >= ZSTD_MINMATCH_MIN. The final sequence must have * matchLength >= ZSTD_MINMATCH_MIN or matchLength == 0. * - All offsets must respect the windowSize parameter as specified in * doc/zstd_compression_format.md. * - If the final sequence has matchLength == 0, it must also have offset == 0. * * zstd will only validate these conditions (and fail compression if they do not * hold) if the ZSTD_c_validateSequences cParam is enabled. Note that sequence * validation has a performance cost. * * If the user-provided function returns an error, zstd will either fall back * to an internal sequence producer or fail the compression operation. The user can * choose between the two behaviors by setting the ZSTD_c_enableSeqProducerFallback * cParam. Fallback compression will follow any other cParam settings, such as * compression level, the same as in a normal compression operation. * * The user shall instruct zstd to use a particular ZSTD_sequenceProducer_F * function by calling * ZSTD_registerSequenceProducer(cctx, * sequenceProducerState, * sequenceProducer) * This setting will persist until the next parameter reset of the CCtx. * * The sequenceProducerState must be initialized by the user before calling * ZSTD_registerSequenceProducer(). The user is responsible for destroying the * sequenceProducerState. * * * LIMITATIONS * * This API is compatible with all zstd compression APIs which respect advanced parameters. * However, there are three limitations: * * First, the ZSTD_c_enableLongDistanceMatching cParam is not currently supported. * COMPRESSION WILL FAIL if it is enabled and the user tries to compress with a block-level * external sequence producer. * - Note that ZSTD_c_enableLongDistanceMatching is auto-enabled by default in some * cases (see its documentation for details). Users must explicitly set * ZSTD_c_enableLongDistanceMatching to ZSTD_ps_disable in such cases if an external * sequence producer is registered. * - As of this writing, ZSTD_c_enableLongDistanceMatching is disabled by default * whenever ZSTD_c_windowLog < 128MB, but that's subject to change. Users should * check the docs on ZSTD_c_enableLongDistanceMatching whenever the Block-Level Sequence * Producer API is used in conjunction with advanced settings (like ZSTD_c_windowLog). * * Second, history buffers are not currently supported. Concretely, zstd will always pass * dictSize == 0 to the external sequence producer (for now). This has two implications: * - Dictionaries are not currently supported. Compression will not fail if the user * references a dictionary, but the dictionary won't have any effect. * - Stream history is not currently supported. All advanced compression APIs, including * streaming APIs, work with external sequence producers, but each block is treated as * an independent chunk without history from previous blocks. * * Third, multi-threading within a single compression is not currently supported. In other words, * COMPRESSION WILL FAIL if ZSTD_c_nbWorkers > 0 and an external sequence producer is registered. * Multi-threading across compressions is fine: simply create one CCtx per thread. * * Long-term, we plan to overcome all three limitations. There is no technical blocker to * overcoming them. It is purely a question of engineering effort. / #define ZSTD_SEQUENCE_PRODUCER_ERROR ((size_t)(-1)) typedef size_t ZSTD_sequenceProducer_F ( void sequenceProducerState, ZSTD_Sequence* outSeqs, size_t outSeqsCapacity, const void* src, size_t srcSize, const void* dict, size_t dictSize, int compressionLevel, size_t windowSize ); /! ZSTD_registerSequenceProducer() : Instruct zstd to use a block-level external sequence producer function. * * The sequenceProducerState must be initialized by the caller, and the caller is * responsible for managing its lifetime. This parameter is sticky across * compressions. It will remain set until the user explicitly resets compression * parameters. * * Sequence producer registration is considered to be an "advanced parameter", * part of the "advanced API". This means it will only have an effect on compression * APIs which respect advanced parameters, such as compress2() and compressStream2(). * Older compression APIs such as compressCCtx(), which predate the introduction of * "advanced parameters", will ignore any external sequence producer setting. * * The sequence producer can be "cleared" by registering a NULL function pointer. This * removes all limitations described above in the "LIMITATIONS" section of the API docs. * * The user is strongly encouraged to read the full API documentation (above) before * calling this function. / ZSTDLIB_STATIC_API void ZSTD_registerSequenceProducer( ZSTD_CCtx cctx, void* sequenceProducerState, ZSTD_sequenceProducer_F* sequenceProducer ); /********************************************************************* * Buffer-less and synchronous inner streaming functions (DEPRECATED) * * This API is deprecated, and will be removed in a future version. * It allows streaming (de)compression with user allocated buffers. * However, it is hard to use, and not as well tested as the rest of * our API. * * Please use the normal streaming API instead: ZSTD_compressStream2, * and ZSTD_decompressStream. * If there is functionality that you need, but it doesn't provide, * please open an issue on our GitHub. ********************************************************************* / /* Buffer-less streaming compression (synchronous mode) A ZSTD_CCtx object is required to track streaming operations. Use ZSTD_createCCtx() / ZSTD_freeCCtx() to manage resource. ZSTD_CCtx object can be re-used multiple times within successive compression operations. Start by initializing a context. Use ZSTD_compressBegin(), or ZSTD_compressBegin_usingDict() for dictionary compression. Then, consume your input using ZSTD_compressContinue(). There are some important considerations to keep in mind when using this advanced function : - ZSTD_compressContinue() has no internal buffer. It uses externally provided buffers only. - Interface is synchronous : input is consumed entirely and produces 1+ compressed blocks. - Caller must ensure there is enough space in `dst` to store compressed data under worst case scenario. Worst case evaluation is provided by ZSTD_compressBound(). ZSTD_compressContinue() doesn't guarantee recover after a failed compression. - ZSTD_compressContinue() presumes prior input *is still accessible and unmodified* (up to maximum distance size, see WindowLog). It remembers all previous contiguous blocks, plus one separated memory segment (which can itself consists of multiple contiguous blocks) - ZSTD_compressContinue() detects that prior input has been overwritten when `src` buffer overlaps. In which case, it will "discard" the relevant memory section from its history. Finish a frame with ZSTD_compressEnd(), which will write the last block(s) and optional checksum. It's possible to use srcSize==0, in which case, it will write a final empty block to end the frame. Without last block mark, frames are considered unfinished (hence corrupted) by compliant decoders. `ZSTD_CCtx` object can be re-used (ZSTD_compressBegin()) to compress again. / /===== Buffer-less streaming compression functions =====/ ZSTD_DEPRECATED("The buffer-less API is deprecated in favor of the normal streaming API. See docs.") ZSTDLIB_STATIC_API size_t ZSTD_compressBegin(ZSTD_CCtx cctx, int compressionLevel); ZSTD_DEPRECATED("The buffer-less API is deprecated in favor of the normal streaming API. See docs.") ZSTDLIB_STATIC_API size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel); ZSTD_DEPRECATED("The buffer-less API is deprecated in favor of the normal streaming API. See docs.") ZSTDLIB_STATIC_API size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict); /*< note: fails if cdict==NULL / ZSTD_DEPRECATED("This function will likely be removed in a future release. It is misleading and has very limited utility.") ZSTDLIB_STATIC_API size_t ZSTD_copyCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx, unsigned long long pledgedSrcSize); /*< note: if pledgedSrcSize is not known, use ZSTD_CONTENTSIZE_UNKNOWN / ZSTD_DEPRECATED("The buffer-less API is deprecated in favor of the normal streaming API. See docs.") ZSTDLIB_STATIC_API size_t ZSTD_compressContinue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); ZSTD_DEPRECATED("The buffer-less API is deprecated in favor of the normal streaming API. See docs.") ZSTDLIB_STATIC_API size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); /* The ZSTD_compressBegin_advanced() and ZSTD_compressBegin_usingCDict_advanced() are now DEPRECATED and will generate a compiler warning / ZSTD_DEPRECATED("use advanced API to access custom parameters") ZSTDLIB_STATIC_API size_t ZSTD_compressBegin_advanced(ZSTD_CCtx cctx, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize); /*< pledgedSrcSize : If srcSize is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN / ZSTD_DEPRECATED("use advanced API to access custom parameters") ZSTDLIB_STATIC_API size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict, ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize); /* compression parameters are already set within cdict. pledgedSrcSize must be correct. If srcSize is not known, use macro ZSTD_CONTENTSIZE_UNKNOWN / /* Buffer-less streaming decompression (synchronous mode) A ZSTD_DCtx object is required to track streaming operations. Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it. A ZSTD_DCtx object can be re-used multiple times. First typical operation is to retrieve frame parameters, using ZSTD_getFrameHeader(). Frame header is extracted from the beginning of compressed frame, so providing only the frame's beginning is enough. Data fragment must be large enough to ensure successful decoding. `ZSTD_frameHeaderSize_max` bytes is guaranteed to always be large enough. result : 0 : successful decoding, the `ZSTD_frameHeader` structure is correctly filled. >0 : `srcSize` is too small, please provide at least result bytes on next attempt. errorCode, which can be tested using ZSTD_isError(). It fills a ZSTD_frameHeader structure with important information to correctly decode the frame, such as the dictionary ID, content size, or maximum back-reference distance (`windowSize`). Note that these values could be wrong, either because of data corruption, or because a 3rd party deliberately spoofs false information. As a consequence, check that values remain within valid application range. For example, do not allocate memory blindly, check that `windowSize` is within expectation. Each application can set its own limits, depending on local restrictions. For extended interoperability, it is recommended to support `windowSize` of at least 8 MB. ZSTD_decompressContinue() needs previous data blocks during decompression, up to `windowSize` bytes. ZSTD_decompressContinue() is very sensitive to contiguity, if 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place, or that previous contiguous segment is large enough to properly handle maximum back-reference distance. There are multiple ways to guarantee this condition. The most memory efficient way is to use a round buffer of sufficient size. Sufficient size is determined by invoking ZSTD_decodingBufferSize_min(), which can return an error code if required value is too large for current system (in 32-bits mode). In a round buffer methodology, ZSTD_decompressContinue() decompresses each block next to previous one, up to the moment there is not enough room left in the buffer to guarantee decoding another full block, which maximum size is provided in `ZSTD_frameHeader` structure, field `blockSizeMax`. At which point, decoding can resume from the beginning of the buffer. Note that already decoded data stored in the buffer should be flushed before being overwritten. There are alternatives possible, for example using two or more buffers of size `windowSize` each, though they consume more memory. Finally, if you control the compression process, you can also ignore all buffer size rules, as long as the encoder and decoder progress in "lock-step", aka use exactly the same buffer sizes, break contiguity at the same place, etc. Once buffers are setup, start decompression, with ZSTD_decompressBegin(). If decompression requires a dictionary, use ZSTD_decompressBegin_usingDict() or ZSTD_decompressBegin_usingDDict(). Then use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively. ZSTD_nextSrcSizeToDecompress() tells how many bytes to provide as 'srcSize' to ZSTD_decompressContinue(). ZSTD_decompressContinue() requires this _exact_ amount of bytes, or it will fail. result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity). It can be zero : it just means ZSTD_decompressContinue() has decoded some metadata item. It can also be an error code, which can be tested with ZSTD_isError(). A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero. Context can then be reset to start a new decompression. Note : it's possible to know if next input to present is a header or a block, using ZSTD_nextInputType(). This information is not required to properly decode a frame. == Special case : skippable frames == Skippable frames allow integration of user-defined data into a flow of concatenated frames. Skippable frames will be ignored (skipped) by decompressor. The format of skippable frames is as follows : a) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F b) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits c) Frame Content - any content (User Data) of length equal to Frame Size For skippable frames ZSTD_getFrameHeader() returns zfhPtr->frameType==ZSTD_skippableFrame. For skippable frames ZSTD_decompressContinue() always returns 0 : it only skips the content. / /===== Buffer-less streaming decompression functions =====/ ZSTDLIB_STATIC_API size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize); /< when frame content size is not known, pass in frameContentSize == ZSTD_CONTENTSIZE_UNKNOWN / ZSTDLIB_STATIC_API size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx); ZSTDLIB_STATIC_API size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize); ZSTDLIB_STATIC_API size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict); ZSTDLIB_STATIC_API size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx); ZSTDLIB_STATIC_API size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); /* misc / ZSTD_DEPRECATED("This function will likely be removed in the next minor release. It is misleading and has very limited utility.") ZSTDLIB_STATIC_API void ZSTD_copyDCtx(ZSTD_DCtx dctx, const ZSTD_DCtx* preparedDCtx); typedef enum { ZSTDnit_frameHeader, ZSTDnit_blockHeader, ZSTDnit_block, ZSTDnit_lastBlock, ZSTDnit_checksum, ZSTDnit_skippableFrame } ZSTD_nextInputType_e; ZSTDLIB_STATIC_API ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx); /* ========================================= / /* Block level API (DEPRECATED) / / ========================================= / /! This API is deprecated in favor of the regular compression API. You can get the frame header down to 2 bytes by setting: - ZSTD_c_format = ZSTD_f_zstd1_magicless - ZSTD_c_contentSizeFlag = 0 - ZSTD_c_checksumFlag = 0 - ZSTD_c_dictIDFlag = 0 This API is not as well tested as our normal API, so we recommend not using it. We will be removing it in a future version. If the normal API doesn't provide the functionality you need, please open a GitHub issue. Block functions produce and decode raw zstd blocks, without frame metadata. Frame metadata cost is typically ~12 bytes, which can be non-negligible for very small blocks (< 100 bytes). But users will have to take in charge needed metadata to regenerate data, such as compressed and content sizes. A few rules to respect : - Compressing and decompressing require a context structure + Use ZSTD_createCCtx() and ZSTD_createDCtx() - It is necessary to init context before starting + compression : any ZSTD_compressBegin() variant, including with dictionary + decompression : any ZSTD_decompressBegin() variant, including with dictionary - Block size is limited, it must be <= ZSTD_getBlockSize() <= ZSTD_BLOCKSIZE_MAX == 128 KB + If input is larger than a block size, it's necessary to split input data into multiple blocks + For inputs larger than a single block, consider using regular ZSTD_compress() instead. Frame metadata is not that costly, and quickly becomes negligible as source size grows larger than a block. - When a block is considered not compressible enough, ZSTD_compressBlock() result will be 0 (zero) ! ===> In which case, nothing is produced into `dst` ! + User __must__ test for such outcome and deal directly with uncompressed data + A block cannot be declared incompressible if ZSTD_compressBlock() return value was != 0. Doing so would mess up with statistics history, leading to potential data corruption. + ZSTD_decompressBlock() _doesn't accept uncompressed data as input_ !! + In case of multiple successive blocks, should some of them be uncompressed, decoder must be informed of their existence in order to follow proper history. Use ZSTD_insertBlock() for such a case. / /===== Raw zstd block functions =====/ ZSTD_DEPRECATED("The block API is deprecated in favor of the normal compression API. See docs.") ZSTDLIB_STATIC_API size_t ZSTD_getBlockSize (const ZSTD_CCtx cctx); ZSTD_DEPRECATED("The block API is deprecated in favor of the normal compression API. See docs.") ZSTDLIB_STATIC_API size_t ZSTD_compressBlock (ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); ZSTD_DEPRECATED("The block API is deprecated in favor of the normal compression API. See docs.") ZSTDLIB_STATIC_API size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); ZSTD_DEPRECATED("The block API is deprecated in favor of the normal compression API. See docs.") ZSTDLIB_STATIC_API size_t ZSTD_insertBlock (ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize); /*< insert uncompressed block into `dctx` history. Useful for multi-blocks decompression. / #endif /* ZSTD_H_ZSTD_STATIC_LINKING_ONLY */ #if defined (__cplusplus) } #endif	167.36 KB	2023-04-04 20:13
📄 zstd_errors.h /* * Copyright (c) Meta Platforms, Inc. and affiliates. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. / #ifndef ZSTD_ERRORS_H_398273423 #define ZSTD_ERRORS_H_398273423 #if defined (__cplusplus) extern "C" { #endif /===== dependency =====/ #include <stddef.h> / size_t / / ===== ZSTDERRORLIB_API : control library symbols visibility ===== / #ifndef ZSTDERRORLIB_VISIBLE / Backwards compatibility with old macro name / # ifdef ZSTDERRORLIB_VISIBILITY # define ZSTDERRORLIB_VISIBLE ZSTDERRORLIB_VISIBILITY # elif defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__) # define ZSTDERRORLIB_VISIBLE __attribute__ ((visibility ("default"))) # else # define ZSTDERRORLIB_VISIBLE # endif #endif #ifndef ZSTDERRORLIB_HIDDEN # if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__) # define ZSTDERRORLIB_HIDDEN __attribute__ ((visibility ("hidden"))) # else # define ZSTDERRORLIB_HIDDEN # endif #endif #if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1) # define ZSTDERRORLIB_API __declspec(dllexport) ZSTDERRORLIB_VISIBLE #elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1) # define ZSTDERRORLIB_API __declspec(dllimport) ZSTDERRORLIB_VISIBLE / It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump./ #else # define ZSTDERRORLIB_API ZSTDERRORLIB_VISIBLE #endif /-********************************************* * Error codes list -******************************************** * Error codes _values_ are pinned down since v1.3.1 only. * Therefore, don't rely on values if you may link to any version < v1.3.1. * * Only values < 100 are considered stable. * * note 1 : this API shall be used with static linking only. * dynamic linking is not yet officially supported. * note 2 : Prefer relying on the enum than on its value whenever possible * This is the only supported way to use the error list < v1.3.1 * note 3 : ZSTD_isError() is always correct, whatever the library version. *********************************************/ typedef enum { ZSTD_error_no_error = 0, ZSTD_error_GENERIC = 1, ZSTD_error_prefix_unknown = 10, ZSTD_error_version_unsupported = 12, ZSTD_error_frameParameter_unsupported = 14, ZSTD_error_frameParameter_windowTooLarge = 16, ZSTD_error_corruption_detected = 20, ZSTD_error_checksum_wrong = 22, ZSTD_error_literals_headerWrong = 24, ZSTD_error_dictionary_corrupted = 30, ZSTD_error_dictionary_wrong = 32, ZSTD_error_dictionaryCreation_failed = 34, ZSTD_error_parameter_unsupported = 40, ZSTD_error_parameter_combination_unsupported = 41, ZSTD_error_parameter_outOfBound = 42, ZSTD_error_tableLog_tooLarge = 44, ZSTD_error_maxSymbolValue_tooLarge = 46, ZSTD_error_maxSymbolValue_tooSmall = 48, ZSTD_error_stabilityCondition_notRespected = 50, ZSTD_error_stage_wrong = 60, ZSTD_error_init_missing = 62, ZSTD_error_memory_allocation = 64, ZSTD_error_workSpace_tooSmall= 66, ZSTD_error_dstSize_tooSmall = 70, ZSTD_error_srcSize_wrong = 72, ZSTD_error_dstBuffer_null = 74, ZSTD_error_noForwardProgress_destFull = 80, ZSTD_error_noForwardProgress_inputEmpty = 82, / following error codes are __NOT STABLE__, they can be removed or changed in future versions / ZSTD_error_frameIndex_tooLarge = 100, ZSTD_error_seekableIO = 102, ZSTD_error_dstBuffer_wrong = 104, ZSTD_error_srcBuffer_wrong = 105, ZSTD_error_sequenceProducer_failed = 106, ZSTD_error_externalSequences_invalid = 107, ZSTD_error_maxCode = 120 / never EVER use this value directly, it can change in future versions! Use ZSTD_isError() instead / } ZSTD_ErrorCode; /! ZSTD_getErrorCode() : convert a `size_t` function result into a `ZSTD_ErrorCode` enum type, which can be used to compare with enum list published above / ZSTDERRORLIB_API ZSTD_ErrorCode ZSTD_getErrorCode(size_t functionResult); ZSTDERRORLIB_API const char ZSTD_getErrorString(ZSTD_ErrorCode code); /*< Same as ZSTD_getErrorName, but using a `ZSTD_ErrorCode` enum argument / #if defined (__cplusplus) } #endif #endif /* ZSTD_ERRORS_H_398273423 */	4.43 KB	2023-04-04 20:13

Edit File:

Terminal