tripathysagar/man_text huggingface dataset:
# pmiputvaluehandle

## NAME



           **pmiPutValueHandle** - add a value for a metric-instance pair via a
           handle
    


## C SYNOPSIS



           **#include <pcp/pmapi.h>**
           **#include <pcp/import.h>**
    
           **int pmiPutValueHandle(int** _handle_**, const char ***_value_**);**
    
           **cc ... -lpcp_import -lpcp**
    


## Perl SYNOPSIS



           **use PCP::LogImport;**
    
           **pmiPutValueHandle($**_handle_**, $**_value_**);**
    


## DESCRIPTION



           As   part   of  the  Performance  Co-Pilot  Log  Import  API  (see
           LOGIMPORT(3)), **pmiPutValueHandle** adds a single value to  the  cur‐
           rent output record for a given metric and instance, using the _han‐_
           _dle_ defined by an earlier call to pmiGetHandle(3).
    
           The  _value_ should be in a format consistent with the metric's type
           as defined in the call to pmiAddMetric(3).
    
           No data will be written until pmiWrite(3) is called,  so  multiple
           calls to **pmiPutValueHandle** or pmiPutValue(3) are typically used to
           accumulate  data  values  for several metric-instance pairs before
           calling pmiWrite(3).
    


## DIAGNOSTICS



           **pmiPutValueHandle** returns zero on success else  a  negative  value
           that can be turned into an error message by calling pmiErrStr(3).
    


* * *
# sem_getvalue

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           sem_getvalue — get the value of a semaphore
    


## SYNOPSIS



           #include <semaphore.h>
    
           int sem_getvalue(sem_t *restrict _sem_ , int *restrict _sval_);
    


## DESCRIPTION



           The _sem_getvalue_() function shall update the location referenced
           by the _sval_ argument to have the value of the semaphore referenced
           by _sem_ without affecting the state of the semaphore. The updated
           value represents an actual semaphore value that occurred at some
           unspecified time during the call, but it need not be the actual
           value of the semaphore when it is returned to the calling process.
    
           If _sem_ is locked, then the object to which _sval_ points shall
           either be set to zero or to a negative number whose absolute value
           represents the number of processes waiting for the semaphore at
           some unspecified time during the call.
    


## RETURN VALUE



           Upon successful completion, the _sem_getvalue_() function shall
           return a value of zero. Otherwise, it shall return a value of -1
           and set _errno_ to indicate the error.
    


## ERRORS



           The _sem_getvalue_() function may fail if:
    
           **EINVAL** The _sem_ argument does not refer to a valid semaphore.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           None.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *
# function::ipmib_filter_key

## NAME



           function::ipmib_filter_key - Default filter function for ipmib.*
           probes
    


## SYNOPSIS



               ipmib_filter_key:long(skb:long,op:long,SourceIsLocal:long)
    


## ARGUMENTS



           _skb_
               pointer to the struct sk_buff
    
           _op_
               value to be counted if _skb_ passes the filter
    
           _SourceIsLocal_
               1 is local operation and 0 is non-local operation
    


## DESCRIPTION



           This function is a default filter function. The user can replace
           this function with their own. The user-supplied filter function
           returns an index key based on the values in _skb_. A return value of
           0 means this particular _skb_ should be not be counted.
    


* * *
# gethostid

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           gethostid — get an identifier for the current host
    


## SYNOPSIS



           #include <unistd.h>
    
           long gethostid(void);
    


## DESCRIPTION



           The _gethostid_() function shall retrieve a 32-bit identifier for
           the current host.
    


## RETURN VALUE



           Upon successful completion, _gethostid_() shall return an identifier
           for the current host.
    


## ERRORS



           No errors are defined.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           This volume of POSIX.1‐2017 does not define the domain in which
           the return value is unique.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *
# gnutls_x509_ext_export_policies

## NAME



           gnutls_x509_ext_export_policies - API function
    


## SYNOPSIS



           **#include <gnutls/x509-ext.h>**
    
           **int gnutls_x509_ext_export_policies(gnutls_x509_policies_t**
           _policies_**, gnutls_datum_t ***_ext_**);**
    


## ARGUMENTS



           gnutls_x509_policies_t policies
                       A pointer to an initialized policies.
    
           gnutls_datum_t * ext
                       The DER-encoded extension data; must be freed using
                       **gnutls_free()**.
    


## DESCRIPTION



           This function will convert the provided policies, to a certificate
           policy DER encoded extension (2.5.29.32).
    
           The  _ext_ data will be allocated using **gnutls_malloc()**.
    


## RETURNS



           On success, **GNUTLS_E_SUCCESS**(0) is returned, otherwise a negative
           error value.
    


## SINCE



           3.3.0
    


* * *
# gnutls_pkcs7_set_crt_raw

## NAME



           gnutls_pkcs7_set_crt_raw - API function
    


## SYNOPSIS



           **#include <gnutls/pkcs7.h>**
    
           **int gnutls_pkcs7_set_crt_raw(gnutls_pkcs7_t** _pkcs7_**, const**
           **gnutls_datum_t ***_crt_**);**
    


## ARGUMENTS



           gnutls_pkcs7_t pkcs7
                       The pkcs7 type
    
           const gnutls_datum_t * crt
                       the DER encoded certificate to be added
    


## DESCRIPTION



           This function will add a certificate to the PKCS7 or RFC2630
           certificate set.
    


## RETURNS



           On success, **GNUTLS_E_SUCCESS**(0) is returned, otherwise a negative
           error value.
    


* * *
# csin

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           csin, csinf, csinl — complex sine functions
    


## SYNOPSIS



           #include <complex.h>
    
           double complex csin(double complex _z_);
           float complex csinf(float complex _z_);
           long double complex csinl(long double complex _z_);
    


## DESCRIPTION



           The functionality described on this reference page is aligned with
           the ISO C standard. Any conflict between the requirements
           described here and the ISO C standard is unintentional. This
           volume of POSIX.1‐2017 defers to the ISO C standard.
    
           These functions shall compute the complex sine of _z_.
    


## RETURN VALUE



           These functions shall return the complex sine value.
    


## ERRORS



           No errors are defined.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           None.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *
# gnutls_x509_crt_check_hostname2

## NAME



           gnutls_x509_crt_check_hostname2 - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **unsigned gnutls_x509_crt_check_hostname2(gnutls_x509_crt_t** _cert_**,**
           **const char ***_hostname_**, unsigned int** _flags_**);**
    


## ARGUMENTS



           gnutls_x509_crt_t cert
                       should contain an gnutls_x509_crt_t type
    
           const char * hostname
                       A null terminated string that contains a DNS name
    
           unsigned int flags
                       gnutls_certificate_verify_flags
    


## DESCRIPTION



           This function will check if the given certificate's subject
           matches the given hostname.  This is a basic implementation of the
           matching described in RFC6125, and takes into account wildcards,
           and the DNSName/IPAddress subject alternative name PKIX extension.
    
           IPv4 addresses are accepted by this function in the dotted-decimal
           format (e.g, ddd.ddd.ddd.ddd), and IPv6 addresses in the
           hexadecimal x:x:x:x:x:x:x:x format. For them the IPAddress subject
           alternative name extension is consulted. Previous versions to
           3.6.0 of GnuTLS in case of a non-match would consult (in a
           non-standard extension) the DNSname and CN fields. This is no
           longer the case.
    
           When the flag **GNUTLS_VERIFY_DO_NOT_ALLOW_WILDCARDS** is specified no
           wildcards are considered. Otherwise they are only considered if
           the domain name consists of three components or more, and the
           wildcard starts at the leftmost position.  When the flag
           **GNUTLS_VERIFY_DO_NOT_ALLOW_IP_MATCHES** is specified, the input will
           be treated as a DNS name, and matching of textual IP addresses
           against the IPAddress part of the alternative name will not be
           allowed.
    
           The function **gnutls_x509_crt_check_ip()** is available for matching
           IP addresses.
    


## RETURNS



           non-zero for a successful match, and zero on failure.
    


## SINCE



           3.3.0
    


* * *
# libpfm_mips_74k

## NAME



           libpfm_mips_74k - support for MIPS 74k processors
    


## SYNOPSIS



           **#include <perfmon/pfmlib.h>**
    
           **PMU name: mips_74k**
           **PMU desc: MIPS 74k**
    


## DESCRIPTION



           The library supports MIPS 74k processors in big or little endian
           modes.
    


## ENCODINGS



           On this processor, what is measured by an event depends on the
           event code and on the counter it is programmed on. Usually the
           meaning of the event code changes between odd and even indexed
           counters. For instance, event code **0x2** means 'PREDICTED_JR31' when
           programmed on even-indexed counters and it means
           'JR_31_MISPREDICTIONS' when programmed on odd-indexed counters. To
           correctly measure an event, one needs both the event encoding and
           a list of possible counters.
    
           When pfm_get_os_event_encoding() is used with **PFM_OS_NONE** to
           return the raw PMU encoding, the library returns two values: the
           event encoding as per the architecture manual and a bitmask of
           valid counters to program it on. For instance, for
           'JR_31_MISPREDICTIONS' The library returns codes[0] = 0x4a,
           codes[1]= 0xa (supported on counter 1, 3).
    
           The encoding for a specific kernel interface may vary and is
           handled internally by the library.
    


## MODIFIERS



           The following modifiers are supported on MIPS 74k.
    
           **u** Measure at user level. This corresponds to **PFM_PLM3**.  This
                  is a boolean modifier.
    
           **k** Measure at kernel level. This corresponds to **PFM_PLM0**.
                  This is a boolean modifier.
    
           **e** Measure at exception level. This corresponds to **PFM_PLM2**.
                  This is a boolean modifier.
    
           **s** Measure at supervisor level. This corresponds to **PFM_PLM1**.
                  This is a boolean modifier.
    
                  It should be noted that those modifiers are available for
                  encoding as raw mode with **PFM_OS_NONE** but they may not all
                  be present with specific kernel interfaces.
    


* * *
# MB_LEN_MAX

## NAME



           MB_LEN_MAX - maximum multibyte length of a character across all
           locales
    


## LIBRARY



           Standard C library (_libc_)
    


## SYNOPSIS



           **#include <limits.h>**
    


## DESCRIPTION



           The **MB_LEN_MAX** macro is the maximum number of bytes needed to
           represent a single wide character, in any of the supported
           locales.
    


## RETURN VALUE



           A constant integer greater than zero.
    


## STANDARDS



           C11, POSIX.1-2008.
    


## NOTES



           The entities **MB_LEN_MAX** and _sizeof(wchar_t)_ are totally unrelated.
           In glibc, **MB_LEN_MAX** is typically 16 (6 in glibc versions earlier
           than 2.2), while _sizeof(wchar_t)_ is 4.
    


* * *
# wcscoll

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           wcscoll, wcscoll_l — wide-character string comparison using
           collating information
    


## SYNOPSIS



           #include <wchar.h>
    
           int wcscoll(const wchar_t *_ws1_ , const wchar_t *_ws2_);
           int wcscoll_l(const wchar_t *_ws1_ , const wchar_t *_ws2_ ,
               locale_t _locale_);
    


## DESCRIPTION



           For _wcscoll_(): The functionality described on this reference page
           is aligned with the ISO C standard. Any conflict between the
           requirements described here and the ISO C standard is
           unintentional. This volume of POSIX.1‐2017 defers to the ISO C
           standard.
    
           The _wcscoll_() and _wcscoll_l_() functions shall compare the wide-
           character string pointed to by _ws1_ to the wide-character string
           pointed to by _ws2_ , both interpreted as appropriate to the
           _LC_COLLATE_ category of the current locale, or the locale
           represented by _locale_ , respectively.
    
           The _wcscoll_() and _wcscoll_l_() functions shall not change the
           setting of _errno_ if successful.
    
           An application wishing to check for error situations should set
           _errno_ to 0 before calling _wcscoll_() or _wcscoll_l_().  If _errno_ is
           non-zero on return, an error has occurred.
    
           The behavior is undefined if the _locale_ argument to _wcscoll_l_() is
           the special locale object LC_GLOBAL_LOCALE or is not a valid
           locale object handle.
    


## RETURN VALUE



           Upon successful completion, _wcscoll_() and _wcscoll_l_() shall return
           an integer greater than, equal to, or less than 0, according to
           whether the wide-character string pointed to by _ws1_ is greater
           than, equal to, or less than the wide-character string pointed to
           by _ws2_ , when both are interpreted as appropriate to the current
           locale, or to the locale represented by _locale_ , respectively. On
           error, _wcscoll_() and _wcscoll_l_() shall set _errno_ , but no return
           value is reserved to indicate an error.
    


## ERRORS



           These functions may fail if:
    
           **EINVAL** The _ws1_ or _ws2_ arguments contain wide-character codes
                  outside the domain of the collating sequence.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           The _wcsxfrm_() and _wcscmp_() functions should be used for sorting
           large lists.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *
# wcrtomb

## NAME



           wcrtomb - convert a wide character to a multibyte sequence
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <wchar.h>**
    
           **size_t wcrtomb(char *restrict** _s_**, wchar_t** _wc_**, mbstate_t *restrict** _ps_**);**
    


## DESCRIPTION



           The main case for this function is when _s_ is not NULL and _wc_ is
           not a null wide character (L'\0').  In this case, the **wcrtomb**()
           function converts the wide character _wc_ to its multibyte
           representation and stores it at the beginning of the character
           array pointed to by _s_.  It updates the shift state _*ps_ , and
           returns the length of said multibyte representation, that is, the
           number of bytes written at _s_.
    
           A different case is when _s_ is not NULL, but _wc_ is a null wide
           character (L'\0').  In this case, the **wcrtomb**() function stores at
           the character array pointed to by _s_ the shift sequence needed to
           bring _*ps_ back to the initial state, followed by a '\0' byte.  It
           updates the shift state _*ps_ (i.e., brings it into the initial
           state), and returns the length of the shift sequence plus one,
           that is, the number of bytes written at _s_.
    
           A third case is when _s_ is NULL.  In this case, _wc_ is ignored, and
           the function effectively returns
    
               wcrtomb(buf, L'\0', ps)
    
           where _buf_ is an internal anonymous buffer.
    
           In all of the above cases, if _ps_ is NULL, a static anonymous state
           known only to the **wcrtomb**() function is used instead.
    
           At most **MB_CUR_MAX** bytes will be written at _s_.  The programmer
           must ensure that there is enough room to store the multibyte
           sequence at _s_.
    


## RETURN VALUE



           The **wcrtomb**() function returns the number of bytes that have been
           or would have been written to the byte array at _s_.  If _wc_ can not
           be represented as a multibyte sequence (according to the current
           locale), _(size_t) -1_ is returned, and _errno_ set to **EILSEQ**.
    


## ATTRIBUTES



           For an explanation of the terms used in this section, see
           attributes(7).
           ┌───────────────────┬───────────────┬────────────────────────────┐
           │ **Interface** │ **Attribute** │ **Value** │
           ├───────────────────┼───────────────┼────────────────────────────┤
           │ **wcrtomb**()         │ Thread safety │ MT-Unsafe race:wcrtomb/!ps │
           └───────────────────┴───────────────┴────────────────────────────┘
    


## STANDARDS



           C11, POSIX.1-2008.
    


## NOTES



           The behavior of **wcrtomb**() depends on the **LC_CTYPE** category of the
           current locale.
    
           Passing NULL as _ps_ is not multithread safe.
    


* * *
# putchar_unlocked

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           putchar_unlocked — stdio with explicit client locking
    


## SYNOPSIS



           #include <stdio.h>
    
           int putchar_unlocked(int _c_);
    


## DESCRIPTION



           Refer to getc_unlocked(3p).
    


* * *
# function::atomic_read

## NAME



           function::atomic_read - Retrieves an atomic variable from kernel
           memory
    


## SYNOPSIS



               atomic_read:long(addr:long)
    


## ARGUMENTS



           _addr_
               pointer to atomic variable
    


## DESCRIPTION



           Safely perform the read of an atomic variable.
    


* * *
# pcre2_general_context_copy

## NAME



           PCRE2 - Perl-compatible regular expressions (revised API)
    


## SYNOPSIS



    
           **#include <pcre2.h>**
    
           **pcre2_general_context *pcre2_general_context_copy(**
             **pcre2_general_context ***_gcontext_**);**
    


## DESCRIPTION



    
           This function makes a new copy of a general context, using the
           memory allocation functions in the context, if set, to get the
           necessary memory.  Otherwise **malloc()** is used. The result is NULL
           if the memory cannot be obtained.
    
           There is a complete description of the PCRE2 native API in the
           **pcre2api** page and a description of the POSIX API in the **pcre2posix**
           page.
    


* * *
# cbrt

## NAME



           cbrt, cbrtf, cbrtl - cube root function
    


## LIBRARY



           Math library (_libm_ , _-lm_)
    


## SYNOPSIS



           **#include <math.h>**
    
           **double cbrt(double** _x_**);**
           **float cbrtf(float** _x_**);**
           **long double cbrtl(long double** _x_**);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           **cbrt**():
               _ISOC99_SOURCE || _POSIX_C_SOURCE >= 200112L
                   || _XOPEN_SOURCE >= 500
                   || /* Since glibc 2.19: */ _DEFAULT_SOURCE
                   || /* glibc <= 2.19: */ _BSD_SOURCE || _SVID_SOURCE
    
           **cbrtf**(), **cbrtl**():
               _ISOC99_SOURCE || _POSIX_C_SOURCE >= 200112L
                   || /* Since glibc 2.19: */ _DEFAULT_SOURCE
                   || /* glibc <= 2.19: */ _BSD_SOURCE || _SVID_SOURCE
    


## DESCRIPTION



           These functions return the (real) cube root of _x_.  This function
           cannot fail; every representable real value has a real cube root,
           and rounding it to a representable value never causes overflow nor
           underflow.
    


## RETURN VALUE



           These functions return the cube root of _x_.
    
           If _x_ is +0, -0, positive infinity, negative infinity, or NaN, _x_ is
           returned.
    


## ERRORS



           No errors occur.
    


## ATTRIBUTES



           For an explanation of the terms used in this section, see
           attributes(7).
           ┌──────────────────────────────────────┬───────────────┬─────────┐
           │ **Interface** │ **Attribute** │ **Value** │
           ├──────────────────────────────────────┼───────────────┼─────────┤
           │ **cbrt**(), **cbrtf**(), **cbrtl**()             │ Thread safety │ MT-Safe │
           └──────────────────────────────────────┴───────────────┴─────────┘
    


## STANDARDS



           C11, POSIX.1-2008.
    


* * *
# gnutls_pcert_export_x509

## NAME



           gnutls_pcert_export_x509 - API function
    


## SYNOPSIS



           **#include <gnutls/abstract.h>**
    
           **int gnutls_pcert_export_x509(gnutls_pcert_st ***_pcert_**,**
           **gnutls_x509_crt_t ***_crt_**);**
    


## ARGUMENTS



           gnutls_pcert_st * pcert
                       The pcert structure.
    
           gnutls_x509_crt_t * crt
                       An initialized **gnutls_x509_crt_t**.
    


## DESCRIPTION



           Converts the given **gnutls_pcert_t** type into a **gnutls_x509_crt_t**.
           This function only works if the type of  _pcert_ is **GNUTLS_CRT_X509**.
           When successful, the value written to  _crt_ must be freed with
           **gnutls_x509_crt_deinit()** when no longer needed.
    


## RETURNS



           On success, **GNUTLS_E_SUCCESS**(0) is returned, otherwise a negative
           error value.
    


## SINCE



           3.4.0
    


* * *
# gnutls_pkcs11_obj_export2

## NAME



           gnutls_pkcs11_obj_export2 - API function
    


## SYNOPSIS



           **#include <gnutls/pkcs11.h>**
    
           **int gnutls_pkcs11_obj_export2(gnutls_pkcs11_obj_t** _obj_**,**
           **gnutls_datum_t ***_out_**);**
    


## ARGUMENTS



           gnutls_pkcs11_obj_t obj
                       Holds the object
    
           gnutls_datum_t * out
                       will contain the object data
    


## DESCRIPTION



           This function will export the PKCS11 object data.  It is normal
           for data to be inaccessible and in that case
           **GNUTLS_E_INVALID_REQUEST** will be returned.
    
           The output buffer is allocated using **gnutls_malloc()**.
    


## RETURNS



           In case of failure a negative error code will be returned, and
           **GNUTLS_E_SUCCESS**(0) on success.
    


## SINCE



           3.1.3
    


* * *
# function::ns_uid

## NAME



           function::ns_uid - Returns the user ID of a target process as seen
           in a user namespace
    


## SYNOPSIS



               ns_uid:long()
    


## ARGUMENTS



           None
    


## DESCRIPTION



           This function returns the user ID of the target process as seen in
           the target user namespace if provided, or the stap process
           namespace.
    


* * *
# io_uring_set_iowait

## NAME



           io_uring_set_iowait - toggle of iowait usage when waiting on CQEs
    


## SYNOPSIS



           **#include <liburing.h>**
    
           **int io_uring_set_iowait(struct io_uring ***_ring_**,**
                                   **bool** _enable_iowait_**);**
    


## DESCRIPTION



           By default, io_uring marks a waiting task as being in iowait if
           it's sleeping waiting on events and there are pending requests.
           This isn't necessarily always useful, and may be confusing on non-
           storage setups where iowait isn't expected. It can also cause
           extra power usage by preventing the CPU from entering lower sleep
           states.
    
           The io_uring_set_iowait(3) function allows the user to toggle this
           behavior. If **enable_iowait** is set to true, the iowait behavior is
           enabled. If it is set to false, the iowait behavior is disabled.
           The iowait behavior is enabled by default when a ring is created.
    
           If the iowait is disabled, the submit functions will set
           **IORING_ENTER_NO_IOWAIT** in the **flags** argument to io_uring_enter(2).
    
           If the kernel supports this feature, it will be marked by having
           the **IORING_FEAT_NO_IOWAIT** feature flag set.
    
           Available since kernel 6.15.
    


## RETURN VALUE



           On success, io_uring_set_iowait(3) returns 0. On failure, it
           returns **-EOPNOTSUPP**.
    


* * *
# gnutls_record_disable_padding

## NAME



           gnutls_record_disable_padding - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **void gnutls_record_disable_padding(gnutls_session_t** _session_**);**
    


## ARGUMENTS



           gnutls_session_t session
                       is a **gnutls_session_t** type.
    


## DESCRIPTION



           Used to disabled padding in TLS 1.0 and above.  Normally you do
           not need to use this function, but there are buggy clients that
           complain if a server pads the encrypted data.  This of course will
           disable protection against statistical attacks on the data.
    
           This function is defunct since 3.1.7. Random padding is disabled
           by default unless requested using **gnutls_record_send_range()**.
    


* * *
# opendir

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           opendir — open directory associated with file descriptor
    


## SYNOPSIS



           #include <dirent.h>
    
           DIR *opendir(const char *_dirname_);
    


## DESCRIPTION



           Refer to fdopendir(3p).
    


* * *
# gnutls_x509_ext_export_crl_dist_points

## NAME



           gnutls_x509_ext_export_crl_dist_points - API function
    


## SYNOPSIS



           **#include <gnutls/x509-ext.h>**
    
           **int**
           **gnutls_x509_ext_export_crl_dist_points(gnutls_x509_crl_dist_points_t**
           _cdp_**, gnutls_datum_t ***_ext_**);**
    


## ARGUMENTS



           gnutls_x509_crl_dist_points_t cdp
                       A pointer to an initialized CRL distribution points.
    
           gnutls_datum_t * ext
                       The DER-encoded extension data; must be freed using
                       **gnutls_free()**.
    


## DESCRIPTION



           This function will convert the provided policies, to a certificate
           policy DER encoded extension (2.5.29.31).
    
           The  _ext_ data will be allocated using **gnutls_malloc()**.
    


## RETURNS



           On success, **GNUTLS_E_SUCCESS**(0) is returned, otherwise a negative
           error value.
    


## SINCE



           3.3.0
    


* * *
# probe::nfs.fop.flush

## NAME



           probe::nfs.fop.flush - NFS client flush file operation
    


## SYNOPSIS



           nfs.fop.flush
    


## VALUES



           _dev_
               device identifier
    
           _ino_
               inode number
    
           _ndirty_
               number of dirty page
    
           _mode_
               file mode
    


* * *
# rdma_destroy_qp

## NAME



           rdma_destroy_qp - Deallocate a QP.
    


## SYNOPSIS



           **#include <rdma/rdma_cma.h>**
    
           **void rdma_destroy_qp (struct rdma_cm_id ***_id_**);**
    


## ARGUMENTS



           id          RDMA identifier.
    


## DESCRIPTION



           Destroy a QP allocated on the rdma_cm_id.
    


## NOTES



           Users must destroy any QP associated with an rdma_cm_id before
           destroying the ID.
    


* * *
# gnutls_decode_ber_digest_info

## NAME



           gnutls_decode_ber_digest_info - API function
    


## SYNOPSIS



           **#include <gnutls/crypto.h>**
    
           **int gnutls_decode_ber_digest_info(const gnutls_datum_t ***_info_**,**
           **gnutls_digest_algorithm_t ***_hash_**, unsigned char ***_digest_**, unsigned**
           **int ***_digest_size_**);**
    


## ARGUMENTS



           const gnutls_datum_t * info
                       an RSA BER encoded DigestInfo structure
    
           gnutls_digest_algorithm_t * hash
                       will contain the hash algorithm of the structure
    
           unsigned char * digest
                       will contain the hash output of the structure
    
           unsigned int * digest_size
                       will contain the hash size of the structure; initially
                       must hold the maximum size of  _digest_
    


## DESCRIPTION



           This function will parse an RSA PKCS**1** 1.5 DigestInfo structure and
           report the hash algorithm used as well as the digest data.
    


## RETURNS



           On success, **GNUTLS_E_SUCCESS**(0) is returned, otherwise an error
           code is returned.
    


## SINCE



           3.5.0
    


* * *
# ctanl

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           ctanl — complex tangent functions
    


## SYNOPSIS



           #include <complex.h>
    
           long double complex ctanl(long double complex _z_);
    


## DESCRIPTION



           Refer to ctan(3p).
    


* * *
# ldap_first_message

## NAME



           ldap_first_message, ldap_next_message, ldap_count_messages -
           Stepping through messages in a result chain
    


## LIBRARY



           OpenLDAP LDAP (libldap, -lldap)
    


## SYNOPSIS



           **#include <ldap.h>**
    
           **int ldap_count_messages( LDAP *ld, LDAPMessage *result )**
    
           **LDAPMessage *ldap_first_message( LDAP *ld, LDAPMessage *result )**
    
           **LDAPMessage *ldap_next_message( LDAP *ld, LDAPMessage *message )**
    


## DESCRIPTION



           These routines are used to step through the messages in a result
           chain received from ldap_result(3).  For search operations, the
           result chain can contain referral, entry and result messages. The
           ldap_msgtype(3) function can be used to distinguish between the
           different message types.
    
           The **ldap_first_message()** routine is used to retrieve the first
           message in a result chain.  It takes the _result_ as returned by a
           call to ldap_result(3), ldap_search_s(3) or ldap_search_st(3) and
           returns a pointer to the first message in the result chain.
    
           This pointer should be supplied on a subsequent call to
           **ldap_next_message()** to get the next message, the result of which
           should be supplied to the next call to **ldap_next_message()** , etc.
           **ldap_next_message()** will return NULL when there are no more
           messages.
    
           These functions are useful when using routines like
           ldap_parse_result(3) that only operate on the first result in the
           chain.
    
           A count of the number of messages in the result chain can be
           obtained by calling **ldap_count_messages()**.  It can also be used to
           count the number of remaining messages in a chain if called with a
           message, entry or reference returned by **ldap_first_message() ,**
           **ldap_next_message() , ldap_first_entry**(3), ldap_next_entry(3),
           ldap_first_reference(3), ldap_next_reference(3).
    


## ERRORS



           If an error occurs in **ldap_first_message()** or **ldap_next_message()** ,
           NULL is returned.  If an error occurs in **ldap_count_messages()** , -1
           is returned.
    


## ACKNOWLEDGEMENTS



           **OpenLDAP Software** is developed and maintained by The OpenLDAP
           Project <http://www.openldap.org/>.  **OpenLDAP Software** is derived
           from the University of Michigan LDAP 3.3 Release.
    


* * *
# audit_log_acct_message

## NAME



           audit_log_acct_message - log a user account message
    


## SYNOPSIS



           **#include <libaudit.h>**
    
           **int**
           **audit_log_acct_message(int** _audit_fd,_**int"**_type,_**const** _char_***"**_pgname,_**const** _char_***"**_op,_**const** _char_***"**_name,_**unsigned** _int"_**id,**_const_**char** _*"_**host,**_const_**char** _*"_**addr,**_const_**char** _*"_**tty,**_int"_**result);"**
    


## DESCRIPTION



           This function will log a message to the audit system using a
           predefined message format. It should be used for all account
           manipulation operations. The function parameters are as follows:
    
                  _audit_fd_ - The fd returned by audit_open
    
                  _type_ - type of message: AUDIT_USER_CHAUTHTOK for changing
                  any account attributes.
    
                  _pgname_ - program's name, if NULL will attempt to figure out
    
                  op  -  operation. Ex: "adding-user", "changing-finger-
                  info", "deleting-group". This value should have a dash or
                  underscore between the words so that report parsers group
                  them together.
    
                  _name_ - user's account or group name. If not available use
                  NULL.
    
                  id  -  uid or gid that the operation is being performed on.
                  If the user is unknown, pass a -1 and fill in the name
                  parameter. This is used only when user is NULL.
    
                  _host_ - The hostname if known. If not available pass a NULL.
    
                  _addr_ - The network address of the user. If not available
                  pass a NULL.
    
                  tty  - The tty of the user, if NULL will attempt to figure
                  out
    
                  _result_ - 1 is "success" and 0 is "failed"
    


## RETURN VALUE



           It returns the sequence number which is > 0 on success or <= 0 on
           error.
    


## ERRORS



           This function returns -1 on failure. Examine errno for more info.
    


* * *
# gnutls_certificate_get_x509_crt

## NAME



           gnutls_certificate_get_x509_crt - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **int**
           **gnutls_certificate_get_x509_crt(gnutls_certificate_credentials_t**
           _res_**, unsigned** _index_**, gnutls_x509_crt_t ****_crt_list_**, unsigned ***
           _crt_list_size_**);**
    


## ARGUMENTS



           gnutls_certificate_credentials_t res
                       is a **gnutls_certificate_credentials_t** type.
    
           unsigned index
                       The index of the certificate list to obtain.
    
           gnutls_x509_crt_t ** crt_list
                       Where to store the certificate list.
    
           unsigned * crt_list_size
                       Will hold the number of certificates.
    


## DESCRIPTION



           Obtains a X.509 certificate list that has been stored in  _res_ with
           one of **gnutls_certificate_set_x509_key()** ,
           **gnutls_certificate_set_key()** ,
           **gnutls_certificate_set_x509_key_file()** ,
           **gnutls_certificate_set_x509_key_file2()** ,
           **gnutls_certificate_set_x509_key_mem()** , or
           **gnutls_certificate_set_x509_key_mem2()**. Each certificate in the
           returned certificate list must be deallocated with
           **gnutls_x509_crt_deinit()** , and the list itself must be freed with
           **gnutls_free()**.
    
           The  _index_ matches the return value of
           **gnutls_certificate_set_x509_key()** and friends functions, when the
           **GNUTLS_CERTIFICATE_API_V2** flag is set.
    
           If there is no certificate with the given index,
           **GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE** is returned. If the
           certificate with the given index is not a X.509 certificate,
           **GNUTLS_E_INVALID_REQUEST** is returned. The returned certificates
           must be deinitialized after use, and the  _crt_list_ pointer must be
           freed using **gnutls_free()**.
    


## RETURNS



           **GNUTLS_E_SUCCESS**(0) on success, or a negative error code.
    


## SINCE



           3.4.0
    


* * *
# acl_valid

## NAME



           **acl_valid** — validate an ACL
    


## LIBRARY



           Linux Access Control Lists library (libacl, -lacl).
    


## SYNOPSIS



           <_sys/types.h_ > <_sys/acl.h_ > _int_ **acl_valid**(_acl_t acl_)
    


## DESCRIPTION



           The **acl_valid**() function checks the ACL referred to by the
           argument _acl_ for validity.
    
           The three required entries ACL_USER_OBJ, ACL_GROUP_OBJ, and
           ACL_OTHER must exist exactly once in the ACL. If the ACL contains
           any ACL_USER or ACL_GROUP entries, then an ACL_MASK entry is also
           required. The ACL may contain at most one ACL_MASK entry.
    
           The user identifiers must be unique among all entries of type
           ACL_USER.  The group identifiers must be unique among all entries
           of type ACL_GROUP.
    


## RETURN VALUE



           The **acl_valid**() function returns the value 0 if successful;
           otherwise the value -1 is returned and the global variable _errno_
           is set to indicate the error.
    


## ERRORS



           If any of the following conditions occur, the **acl_valid**() function
           returns **-1** and sets _errno_ to the corresponding value:
    
           [EINVAL]           The argument _acl_ is not a valid pointer to an
                              ACL.
    
                              The argument _acl_ does not point to a valid ACL.
    
                              One or more of the required ACL entries is not
                              present in _acl_.
    
                              The ACL contains entries that are not unique.
    


## STANDARDS



           IEEE Std 1003.1e draft 17 (“POSIX.1e”, abandoned)
    


* * *
# QmcContext

## NAME



           **QmcContext** - container for a PMAPI context and its metrics
    


## C++ SYNOPSIS



           **#include <QmcContext.h>**
    
           **c++ ... -lpcp_qmc -lpcp**
    


## DESCRIPTION



           A  **QmcContext** object is a container for a single PMAPI(3) context.
           The object maintains a list of all the metric descriptors  (**QmcDe‐**
           **sc**), instance domains (**QmcIndom**) and metrics (**QmcMetric**) using the
           context to minimize the duplication of these objects.
    


## CONSTRUCTORS



           A  **QmcContext** object  should  be  constructed  through  the  **Qmc‐**
           **Group::use** interface.
    


## DESCRIPTOR LOOKUP



           The metric and instance domain descriptors are cached by the  **Qmc‐**
           **Context** object to reduce duplicate QmcDesc(3) and QmcIndom(3) ob‐
           jects and PMAPI(3) calls required to create them.  Also  the  map‐
           ping  from  metrics  names  to  **pmID** s  is also maintained to avoid
           pmLookupName(3) calls.
    
           **int lookupDesc(const char *name, pmID & id);**
               Search for the metric _name_ in the name list and set **id** to the
               known **pmID**.  If not found, use pmLookupName(3) to get the map‐
               ping.  If this call fails, the PMAPI(3) error code will be re‐
               turned.
    
           **int lookupDesc(const char *name, uint_t & desc, uint_t& indom);**
               Find the index _desc_ and _indom_ to the **QmcDesc** object and the
               **QmcIndom** object for the metric _name_.  The indexes can then be
               used with **QmcContext::desc** and **QmcContext::indom** to obtain
               references to the real objects.  The methods will return a
               PMAPI(3) error code if the metric descriptor or instance do‐
               main could not be obtained.
    
           **int lookupDesc(pmID pmid, uint_t & desc, uint_t& indom);**
               Find the index _desc_ and _indom_ to the **QmcDesc** object and the
               **QmcIndom** object for the metric _pmid_.  The indexes can then be
               used with **QmcContext::desc** and **QmcContext::indom** to obtain
               references to the real objects.  The methods will return a
               PMAPI(3) error code if the metric descriptor or instance do‐
               main could not be obtained.
    


## DIAGNOSTICS



           Error messages are generated using pmprintf(3) but are not
           flushed. It is the responsibility of the user to call pmflush(3)
           to output any messages.
    
           Additional diagnostics may be activated by adding the options **pmc**
           and/or **optfetch** to the global debugging specification, as de‐
           scribed in pmSetDebug(3).
    


* * *
# gnutls_x509_crt_get_key_usage

## NAME



           gnutls_x509_crt_get_key_usage - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **int gnutls_x509_crt_get_key_usage(gnutls_x509_crt_t** _cert_**, unsigned**
           **int ***_key_usage_**, unsigned int ***_critical_**);**
    


## ARGUMENTS



           gnutls_x509_crt_t cert
                       should contain a **gnutls_x509_crt_t** type
    
           unsigned int * key_usage
                       where the key usage bits will be stored
    
           unsigned int * critical
                       will be non-zero if the extension is marked as
                       critical
    


## DESCRIPTION



           This function will return certificate's key usage, by reading the
           keyUsage X.509 extension (2.5.29.15). The key usage value will
           ORed values of the: **GNUTLS_KEY_DIGITAL_SIGNATURE** ,
           **GNUTLS_KEY_NON_REPUDIATION** , **GNUTLS_KEY_KEY_ENCIPHERMENT** ,
           **GNUTLS_KEY_DATA_ENCIPHERMENT** , **GNUTLS_KEY_KEY_AGREEMENT** ,
           **GNUTLS_KEY_KEY_CERT_SIGN** , **GNUTLS_KEY_CRL_SIGN** ,
           **GNUTLS_KEY_ENCIPHER_ONLY** , **GNUTLS_KEY_DECIPHER_ONLY**.
    


## RETURNS



           zero on success, or a negative error code in case of parsing
           error.  If the certificate does not contain the keyUsage extension
           **GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE** will be returned.
    


* * *
# function::ulonglong_arg

## NAME



           function::ulonglong_arg - Return function argument as 64-bit value
    


## SYNOPSIS



               ulonglong_arg:long(n:long)
    


## ARGUMENTS



           _n_
               index of argument to return
    


## DESCRIPTION



           Return the value of argument n as a 64-bit value. (Same as
           longlong_arg.)
    


* * *
# pcap_open_live

## NAME



           pcap_open_live - open a device for capturing
    


## SYNOPSIS



           **#include <pcap/pcap.h>**
    
           **char errbuf[PCAP_ERRBUF_SIZE];**
    
           **pcap_t *pcap_open_live(const char *device, int snaplen,**
               **int promisc, int to_ms, char *errbuf);**
    


## DESCRIPTION



           **pcap_open_live**() is used to obtain a packet capture handle to
           capture packets on a device (typically a network interface, see
           **pcap_findalldevs**(3PCAP) for a more detailed explanation).  _device_
           is a string that specifies the capture device to open, in this
           function **NULL** means the same as the string "any".
    
           _snaplen_ specifies the snapshot length to be set on the handle.  If
           the packet data should not be truncated at the end, a value of
           262144 should be sufficient for most devices, but D-Bus devices
           require a value of 128MiB (128*1024*1024).
    
           _promisc_ specifies whether the device is to be put into promiscuous
           mode.  If _promisc_ is non-zero, promiscuous mode will be set,
           otherwise it will not be set.
    
           _to_ms_ specifies the packet buffer timeout, as a non-negative
           value, in milliseconds.  (See **pcap**(3PCAP) for an explanation of
           the packet buffer timeout.)
    
           _errbuf_ is a buffer large enough to hold at least **PCAP_ERRBUF_SIZE**
           chars.
    


## RETURN VALUE



           **pcap_open_live**() returns a **pcap_t *** on success and **NULL** on
           failure.  If **NULL** is returned, _errbuf_ is filled in with an
           appropriate error message.  _errbuf_ may also be set to warning text
           when **pcap_open_live**() succeeds; to detect this case the caller
           should store a zero-length string in _errbuf_ before calling
           **pcap_open_live**() and display the warning to the user if _errbuf_ is
           no longer a zero-length string.
    


* * *