tripathysagar/man_text huggingface dataset:
# malloc

## 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



           malloc — a memory allocator
    


## SYNOPSIS



           #include <stdlib.h>
    
           void *malloc(size_t _size_);
    


## 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.
    
           The _malloc_() function shall allocate unused space for an object
           whose size in bytes is specified by _size_ and whose value is
           unspecified.
    
           The order and contiguity of storage allocated by successive calls
           to _malloc_() is unspecified. The pointer returned if the allocation
           succeeds shall be suitably aligned so that it may be assigned to a
           pointer to any type of object and then used to access such an
           object in the space allocated (until the space is explicitly freed
           or reallocated). Each such allocation shall yield a pointer to an
           object disjoint from any other object. The pointer returned points
           to the start (lowest byte address) of the allocated space. If the
           space cannot be allocated, a null pointer shall be returned. If
           the size of the space requested is 0, the behavior is
           implementation-defined: either a null pointer shall be returned,
           or the behavior shall be as if the size were some non-zero value,
           except that the behavior is undefined if the returned pointer is
           used to access an object.
    


## RETURN VALUE



           Upon successful completion with _size_ not equal to 0, _malloc_()
           shall return a pointer to the allocated space. If _size_ is 0,
           either:
    
            *  A null pointer shall be returned and _errno_ may be set to an
               implementation-defined value, or
    
            *  A pointer to the allocated space shall be returned. The
               application shall ensure that the pointer is not used to
               access an object.
    
           Otherwise, it shall return a null pointer and set _errno_ to
           indicate the error.
    


## ERRORS



           The _malloc_() function shall fail if:
    
           **ENOMEM** Insufficient storage space is available.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           None.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *
# gnutls_x509_crl_get_issuer_dn

## NAME



           gnutls_x509_crl_get_issuer_dn - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **int gnutls_x509_crl_get_issuer_dn(gnutls_x509_crl_t** _crl_**, char ***
           _buf_**, size_t ***_sizeof_buf_**);**
    


## ARGUMENTS



           gnutls_x509_crl_t crl
                       should contain a gnutls_x509_crl_t type
    
           char * buf  a pointer to a structure to hold the peer's name (may
                       be null)
    
           size_t * sizeof_buf
                       initially holds the size of  _buf_
    


## DESCRIPTION



           This function will copy the name of the CRL issuer in the provided
           buffer. The name will be in the form "C=xxxx,O=yyyy,CN=zzzz" as
           described in RFC4514. The output string will be ASCII or UTF-8
           encoded, depending on the certificate data.
    
           If buf is **NULL** then only the size will be filled.
    
           This function does not output a fully RFC4514 compliant string, if
           that is required see **gnutls_x509_crl_get_issuer_dn3()**.
    


## RETURNS



           **GNUTLS_E_SHORT_MEMORY_BUFFER** if the provided buffer is not long
           enough, and in that case the sizeof_buf will be updated with the
           required size, and 0 on success.
    


* * *
# gnutls_pkcs11_privkey_generate3

## NAME



           gnutls_pkcs11_privkey_generate3 - API function
    


## SYNOPSIS



           **#include <gnutls/pkcs11.h>**
    
           **int gnutls_pkcs11_privkey_generate3(const char ***_url_**,**
           **gnutls_pk_algorithm_t** _pk_**, unsigned int** _bits_**, const char ***_label_**,**
           **const gnutls_datum_t ***_cid_**, gnutls_x509_crt_fmt_t** _fmt_**,**
           **gnutls_datum_t ***_pubkey_**, unsigned int** _key_usage_**, unsigned int**
           _flags_**);**
    


## ARGUMENTS



           const char * url
                       a token URL
    
           gnutls_pk_algorithm_t pk
                       the public key algorithm
    
           unsigned int bits
                       the security bits
    
           const char * label
                       a label
    
           const gnutls_datum_t * cid
                       The CKA_ID to use for the new object
    
           gnutls_x509_crt_fmt_t fmt
                       the format of output params. PEM or DER
    
           gnutls_datum_t * pubkey
                       will hold the public key (may be **NULL**)
    
           unsigned int key_usage
                       One of GNUTLS_KEY_*
    
           unsigned int flags
                       zero or an OR'ed sequence of **GNUTLS_PKCS11_OBJ_FLAGs**
    


## DESCRIPTION



           This function will generate a private key in the specified by the
           _url_ token. The private key will be generate within the token and
           will not be exportable. This function will store the DER-encoded
           public key in the SubjectPublicKeyInfo format in  _pubkey_ . The
           _pubkey_ should be deinitialized using **gnutls_free()**.
    
           Note that when generating an elliptic curve key, the curve can be
           substituted in the place of the bits parameter using the
           **GNUTLS_CURVE_TO_BITS()** macro.
    
           Since 3.6.3 the objects are marked as sensitive by default unless
           **GNUTLS_PKCS11_OBJ_FLAG_MARK_NOT_SENSITIVE** is specified.
    


## RETURNS



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


## SINCE



           3.4.0
    


* * *
# function::stop_stopwatch

## NAME



           function::stop_stopwatch - Stop a stopwatch
    


## SYNOPSIS



               stop_stopwatch(name:string)
    


## ARGUMENTS



           _name_
               the stopwatch name
    


## DESCRIPTION



           Stop stopwatch _name_. Creates stopwatch _name_ if it does not
           currently exist.
    


* * *
# function::tcpmib_remote_port

## NAME



           function::tcpmib_remote_port - Get the remote port
    


## SYNOPSIS



               tcpmib_remote_port:long(sk:long)
    


## ARGUMENTS



           _sk_
               pointer to a struct inet_sock
    


## DESCRIPTION



           Returns the dport from a struct inet_sock in host order.
    


* * *
# function::cpu_clock_us

## NAME



           function::cpu_clock_us - Number of microseconds on the given cpu's
           clock
    


## SYNOPSIS



               cpu_clock_us:long(cpu:long)
    


## ARGUMENTS



           _cpu_
               Which processor's clock to read
    


## DESCRIPTION



           This function returns the number of microseconds on the given
           cpu's clock. This is always monotonic comparing on the same cpu,
           but may have some drift between cpus (within about a jiffy).
    


* * *
# pam_syslog

## NAME



           pam_syslog, pam_vsyslog - send messages to the system logger
    


## SYNOPSIS



           **#include <syslog.h>**
    
           **#include <security/pam_ext.h>**
    
           **void pam_syslog(const pam_handle_t ***_pamh_**, int** _priority_**,**
                           **const char ***_fmt_**,**_..._**);**
    
           **void pam_vsyslog(const pam_handle_t ***_pamh_**, int** _priority_**,**
                            **const char ***_fmt_**, va_list** _args_**);**
    


## DESCRIPTION



           The **pam_syslog** function logs messages using syslog(3) and is
           intended for internal use by Linux-PAM and PAM service modules.
           The _priority_ argument is formed by ORing the facility and the
           level values as documented in the syslog(3) manual page.
    
           The **pam_vsyslog** function performs the same task as **pam_syslog()**
           with the difference that it takes a set of arguments which have
           been obtained using the stdarg(3) variable argument list macros.
    


## STANDARDS



           The **pam_syslog** and **pam_vsyslog** functions are Linux-PAM extensions.
    


* * *
# strncpy

## 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



           stpncpy, strncpy — copy fixed length string, returning a pointer
           to the array end
    


## SYNOPSIS



           #include <string.h>
    
           char *stpncpy(char *restrict _s1_ , const char *restrict _s2_ , size_t _n_);
           char *strncpy(char *restrict _s1_ , const char *restrict _s2_ , size_t _n_);
    


## DESCRIPTION



           For _strncpy_(): 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 _stpncpy_() and _strncpy_() functions shall copy not more than _n_
           bytes (bytes that follow a NUL character are not copied) from the
           array pointed to by _s2_ to the array pointed to by _s1_.
    
           If the array pointed to by _s2_ is a string that is shorter than _n_
           bytes, NUL characters shall be appended to the copy in the array
           pointed to by _s1_ , until _n_ bytes in all are written.
    
           If copying takes place between objects that overlap, the behavior
           is undefined.
    


## RETURN VALUE



           If a NUL character is written to the destination, the _stpncpy_()
           function shall return the address of the first such NUL character.
           Otherwise, it shall return _& s1_[_n_].
    
           The _strncpy_() function shall return _s1_.
    
           No return values are reserved to indicate an error.
    


## ERRORS



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


## EXAMPLES



           None.
    


## APPLICATION USAGE



           Applications must provide the space in _s1_ for the _n_ bytes to be
           transferred, as well as ensure that the _s2_ and _s1_ arrays do not
           overlap.
    
           Character movement is performed differently in different
           implementations. Thus, overlapping moves may yield surprises.
    
           If there is no NUL character byte in the first _n_ bytes of the
           array pointed to by _s2_ , the result is not null-terminated.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *
# errno

## 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



           errno — error return value
    


## SYNOPSIS



           #include <errno.h>
    


## DESCRIPTION



           The lvalue _errno_ is used by many functions to return error values.
    
           Many functions provide an error number in _errno_ , which has type
           **int** and is defined in _< errno.h>_.  The value of _errno_ shall be
           defined only after a call to a function for which it is explicitly
           stated to be set and until it is changed by the next function call
           or if the application assigns it a value. The value of _errno_
           should only be examined when it is indicated to be valid by a
           function's return value. Applications shall obtain the definition
           of _errno_ by the inclusion of _< errno.h>_.  No function in this
           volume of POSIX.1‐2017 shall set _errno_ to 0. The setting of _errno_
           after a successful call to a function is unspecified unless the
           description of that function specifies that _errno_ shall not be
           modified.
    
           It is unspecified whether _errno_ is a macro or an identifier
           declared with external linkage. If a macro definition is
           suppressed in order to access an actual object, or a program
           defines an identifier with the name _errno_ , the behavior is
           undefined.
    
           The symbolic values stored in _errno_ are documented in the ERRORS
           sections on all relevant pages.
    


## RETURN VALUE



           None.
    


## ERRORS



           None.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           Previously both POSIX and X/Open documents were more restrictive
           than the ISO C standard in that they required _errno_ to be defined
           as an external variable, whereas the ISO C standard required only
           that _errno_ be defined as a modifiable lvalue with type **int**.
    
           An application that needs to examine the value of _errno_ to
           determine the error should set it to 0 before a function call,
           then inspect it before a subsequent function call.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *
# function::ntohl

## NAME



           function::ntohl - Convert 32-bit long from network to host order
    


## SYNOPSIS



               ntohl:long(x:long)
    


## ARGUMENTS



           _x_
               Value to convert
    


* * *
# wctob

## NAME



           wctob - try to represent a wide character as a single byte
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <wchar.h>**
    
           **int wctob(wint_t** _c_**);**
    


## DESCRIPTION



           The **wctob**() function tests whether the multibyte representation of
           the wide character _c_ , starting in the initial state, consists of a
           single byte.  If so, it is returned as an _unsigned char_.
    
           Never use this function.  It cannot help you in writing
           internationalized programs.  Internationalized programs must never
           distinguish single-byte and multibyte characters.
    


## RETURN VALUE



           The **wctob**() function returns the single-byte representation of _c_ ,
           if it exists, or **EOF** otherwise.
    


## ATTRIBUTES



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


## STANDARDS



           C11, POSIX.1-2008.
    


## NOTES



           The behavior of **wctob**() depends on the **LC_CTYPE** category of the
           current locale.
    
           This function should never be used.  Internationalized programs
           must never distinguish single-byte and multibyte characters.  Use
           either wctomb(3) or the thread-safe wcrtomb(3) instead.
    


* * *
# sincos

## NAME



           sincos, sincosf, sincosl - calculate sin and cos simultaneously
    


## LIBRARY



           Math library (_libm_ , _-lm_)
    


## SYNOPSIS



           **#define _GNU_SOURCE** /* See feature_test_macros(7) */
           **#include <math.h>**
    
           **void sincos(double** _x_**, double ***_sin_**, double ***_cos_**);**
           **void sincosf(float** _x_**, float ***_sin_**, float ***_cos_**);**
           **void sincosl(long double** _x_**, long double ***_sin_**, long double ***_cos_**);**
    


## DESCRIPTION



           Several applications need sine and cosine of the same angle _x_.
           These functions compute both at the same time, and store the
           results in _*sin_ and _*cos_.  Using this function can be more
           efficient than two separate calls to sin(3) and cos(3).
    
           If _x_ is a NaN, a NaN is returned in _*sin_ and _*cos_.
    
           If _x_ is positive infinity or negative infinity, a domain error
           occurs, and a NaN is returned in _*sin_ and _*cos_.
    


## RETURN VALUE



           These functions return _void_.
    


## ERRORS



           See math_error(7) for information on how to determine whether an
           error has occurred when calling these functions.
    
           The following errors can occur:
    
           Domain error: _x_ is an infinity
                  _errno_ is set to **EDOM**(but see BUGS).  An invalid floating-
                  point exception (**FE_INVALID**) is raised.
    


## ATTRIBUTES



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


## STANDARDS



           GNU.
    


## NOTES



           To see the performance advantage of **sincos**(), it may be necessary
           to disable gcc(1) built-in optimizations, using flags such as:
    
               cc -O -lm -fno-builtin prog.c
    


## BUGS



           Before glibc 2.22, the glibc implementation did not set _errno_ to
           **EDOM** when a domain error occurred.
    


* * *
# posix_spawn_file_actions_destroy

## 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



           posix_spawn_file_actions_destroy, posix_spawn_file_actions_init —
           destroy and initialize spawn file actions object (**ADVANCED**
           **REALTIME**)
    


## SYNOPSIS



           #include <spawn.h>
    
           int posix_spawn_file_actions_destroy(posix_spawn_file_actions_t
               *_file_actions_);
           int posix_spawn_file_actions_init(posix_spawn_file_actions_t
               *_file_actions_);
    


## DESCRIPTION



           The _posix_spawn_file_actions_destroy_() function shall destroy the
           object referenced by _file_actions_ ; the object becomes, in effect,
           uninitialized. An implementation may cause
           _posix_spawn_file_actions_destroy_() to set the object referenced by
           _file_actions_ to an invalid value. A destroyed spawn file actions
           object can be reinitialized using _posix_spawn_file_actions_init_();
           the results of otherwise referencing the object after it has been
           destroyed are undefined.
    
           The _posix_spawn_file_actions_init_() function shall initialize the
           object referenced by _file_actions_ to contain no file actions for
           _posix_spawn_() or _posix_spawnp_() to perform.
    
           A spawn file actions object is as defined in
           posix_spawn_file_actions_addclose(3p).
    
           The effect of initializing an already initialized spawn file
           actions object is undefined.
    


## RETURN VALUE



           Upon successful completion, these functions shall return zero;
           otherwise, an error number shall be returned to indicate the
           error.
    


## ERRORS



           The _posix_spawn_file_actions_init_() function shall fail if:
    
           **ENOMEM** Insufficient memory exists to initialize the spawn file
                  actions object.
    
           The _posix_spawn_file_actions_destroy_() function may fail if:
    
           **EINVAL** The value specified by _file_actions_ is invalid.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           These functions are part of the Spawn option and need not be
           provided on all implementations.
    


## RATIONALE



           Refer to the RATIONALE section in
           posix_spawn_file_actions_addclose(3p).
    


## FUTURE DIRECTIONS



           None.
    


* * *
# pthread_equal

## 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



           pthread_equal — compare thread IDs
    


## SYNOPSIS



           #include <pthread.h>
    
           int pthread_equal(pthread_t _t1_ , pthread_t _t2_);
    


## DESCRIPTION



           This function shall compare the thread IDs _t1_ and _t2_.
    


## RETURN VALUE



           The _pthread_equal_() function shall return a non-zero value if _t1_
           and _t2_ are equal; otherwise, zero shall be returned.
    
           If either _t1_ or _t2_ are not valid thread IDs, the behavior is
           undefined.
    


## ERRORS



           No errors are defined.
    
           The _pthread_equal_() function shall not return an error code of
           **[EINTR]**.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           None.
    


## RATIONALE



           Implementations may choose to define a thread ID as a structure.
           This allows additional flexibility and robustness over using an
           **int**.  For example, a thread ID could include a sequence number
           that allows detection of ``dangling IDs'' (copies of a thread ID
           that has been detached). Since the C language does not support
           comparison on structure types, the _pthread_equal_() function is
           provided to compare thread IDs.
    


## FUTURE DIRECTIONS



           None.
    


* * *
# mempcpy

## NAME



           mempcpy, wmempcpy  - copy memory area
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#define _GNU_SOURCE** /* See feature_test_macros(7) */
           **#include <string.h>**
    
           **void *mempcpy(** size_t n;
                         **void** _dest_**[restrict** _n_**], const void** _src_**[restrict** _n_**],**
                         **size_t** _n_**);**
    
           **#define _GNU_SOURCE** /* See feature_test_macros(7) */
           **#include <wchar.h>**
    
           **wchar_t *wmempcpy(** size_t n;
                         **wchar_t** _dest_**[restrict** _n_**], const wchar_t** _src_**[restrict** _n_**],**
                         **size_t** _n_**);**
    


## DESCRIPTION



           The **mempcpy**() function is nearly identical to the memcpy(3)
           function.  It copies _n_ bytes from the object beginning at _src_ into
           the object pointed to by _dest_.  But instead of returning the value
           of _dest_ it returns a pointer to the byte following the last
           written byte.
    
           This function is useful in situations where a number of objects
           shall be copied to consecutive memory positions.
    
           The **wmempcpy**() function is identical but takes _wchar_t_ type
           arguments and copies _n_ wide characters.
    


## RETURN VALUE



           _dest_ + _n_.
    


## ATTRIBUTES



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


## STANDARDS



           GNU.
    


## EXAMPLES



           void *
           combine(void *o1, size_t s1, void *o2, size_t s2)
           {
               void *result = malloc(s1 + s2);
               if (result != NULL)
                   mempcpy(mempcpy(result, o1, s1), o2, s2);
               return result;
           }
    


* * *
# gnutls_compression_get_name

## NAME



           gnutls_compression_get_name - API function
    


## SYNOPSIS



           **#include <gnutls/compat.h>**
    
           **const char ***
           **gnutls_compression_get_name(gnutls_compression_method_t**
           _algorithm_**);**
    


## ARGUMENTS



           gnutls_compression_method_t algorithm
                       is a Compression algorithm
    


## DESCRIPTION



           Convert a **gnutls_compression_method_t** value to a string.
    


## RETURNS



           a pointer to a string that contains the name of the specified
           compression algorithm, or **NULL**.
    


* * *
# pmnumberstr

## NAME



           **pmNumberStr** , **pmNumberStr_r** - fixed width output format for numbers
    


## C SYNOPSIS



           **#include <pcp/pmapi.h>**
    
           **const char *pmNumberStr(double** _value_**);**
           **char *pmNumberStr_r(double** _value_**, char ***_buf_**, int** _buflen_**);**
    
           **cc ... -lpcp**
    


## DESCRIPTION



           **pmNumberStr** returns  the  address of a 8-byte buffer that holds a
           null-byte terminated representation of _value_ suitable  for  output
           with  fixed  width  fields.   The  **pmNumberStr_r** function does the
           same, but stores the result  in  a  user-supplied  buffer  _buf_  of
           length _buflen_ , which should have room for at least 8 bytes.
    
           The  value  is  scaled  using multipliers in powers of ``one thou‐
           sand'' (the decimal ``kilo'') and has a bias that provides greater
           precision for positive numbers as opposed to negative numbers.
    
           The format depends on the sign and magnitude of _value_  as  follows
           (d represents a decimal digit):
                    ┌───────────────────────────────────┬─────────┐
                    │            _value_ range            │ format  │
                    ├───────────────────────────────────┼─────────┤
                    │         > 999995000000000         │  **inf?** │
                    │ 999995000000000 - 999995000000    │ ddd.dd**T** │
                    │    999995000000 - 999995000       │ ddd.dd**G** │
                    │       999995000 - 999995          │ ddd.dd**M** │
                    │          999995 - 999.995         │ ddd.dd**K** │
                    │         999.995 - 0.005           │ ddd.dd  │
                    │           0.005 - -0.005          │   **0.00** │
                    │          -0.005 - -99.95          │ -dd.dd  │
                    │         -99.995 - -99995          │ -dd.dd**K** │
                    │          -99995 - -99995000       │ -dd.dd**M** │
                    │       -99995000 - -99995000000    │ -dd.dd**G** │
                    │    -99995000000 - -99995000000000 │ -dd.dd**T** │
                    │        < -99995000000000          │ **-inf?** │
                    └───────────────────────────────────┴─────────┘
    
           At  the  boundary points of the ranges, the chosen format will re‐
           tain the maximum number of significant digits.
    


## NOTES



           **pmNumberStr** returns a pointer to a static buffer and hence is  not
           thread-safe.  Multi-threaded applications should use **pmNumberStr_r**
           instead.
    


* * *
# gnutls_prf_hash_get

## NAME



           gnutls_prf_hash_get - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **gnutls_digest_algorithm_t gnutls_prf_hash_get(const**
           **gnutls_session_t** _session_**);**
    


## ARGUMENTS



           const gnutls_session_t session
                       is a **gnutls_session_t** type.
    


## DESCRIPTION



           Get the currently used hash algorithm. In TLS 1.3, the hash
           algorithm is used for both the key derivation function and
           handshake message authentication code. In TLS 1.2, it matches the
           hash algorithm used for PRF.
    


## RETURNS



           the currently used hash algorithm, a **gnutls_digest_algorithm_t**
           value.
    


## SINCE



           3.6.13
    


* * *
# pthread_setschedprio

## NAME



           pthread_setschedprio - set scheduling priority of a thread
    


## LIBRARY



           POSIX threads library (_libpthread_ , _-lpthread_)
    


## SYNOPSIS



           **#include <pthread.h>**
    
           **int pthread_setschedprio(pthread_t** _thread_**, int** _prio_**);**
    


## DESCRIPTION



           The **pthread_setschedprio**() function sets the scheduling priority
           of the thread _thread_ to the value specified in _prio_.  (By contrast
           pthread_setschedparam(3) changes both the scheduling policy and
           priority of a thread.)
    


## RETURN VALUE



           On success, this function returns 0; on error, it returns a
           nonzero error number.  If **pthread_setschedprio**() fails, the
           scheduling priority of _thread_ is not changed.
    


## ERRORS



           **EINVAL** _prio_ is not valid for the scheduling policy of the
                  specified thread.
    
           **EPERM** The caller does not have appropriate privileges to set the
                  specified priority.
    
           **ESRCH** No thread with the ID _thread_ could be found.
    
           POSIX.1 also documents an **ENOTSUP**("attempt was made to set the
           priority to an unsupported value") error for
           pthread_setschedparam(3).
    


## ATTRIBUTES



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


## STANDARDS



           POSIX.1-2008.
    


## NOTES



           For a description of the permissions required to, and the effect
           of, changing a thread's scheduling priority, and details of the
           permitted ranges for priorities in each scheduling policy, see
           sched(7).
    


* * *
# posix_trace_attr_setlogsize

## 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



           posix_trace_attr_setlogsize, posix_trace_attr_setmaxdatasize —
           retrieve and set trace stream size attributes (**TRACING**)
    


## SYNOPSIS



           #include <sys/types.h>
           #include <trace.h>
    
           int posix_trace_attr_setlogsize(trace_attr_t *_attr_ ,
               size_t _logsize_);
           int posix_trace_attr_setmaxdatasize(trace_attr_t *_attr_ ,
               size_t _maxdatasize_);
    


## DESCRIPTION



           Refer to posix_trace_attr_getlogsize(3p).
    


* * *
# gnutls_x509_crq_get_dn

## NAME



           gnutls_x509_crq_get_dn - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **int gnutls_x509_crq_get_dn(gnutls_x509_crq_t** _crq_**, char ***_buf_**,**
           **size_t ***_buf_size_**);**
    


## ARGUMENTS



           gnutls_x509_crq_t crq
                       should contain a **gnutls_x509_crq_t** type
    
           char * buf  a pointer to a structure to hold the name (may be
                       **NULL**)
    
           size_t * buf_size
                       initially holds the size of  _buf_
    


## DESCRIPTION



           This function will copy the name of the Certificate request
           subject to the provided buffer.  The name will be in the form
           "C=xxxx,O=yyyy,CN=zzzz" as described in RFC 2253. The output
           string
            _buf_ will be ASCII or UTF-8 encoded, depending on the certificate
           data.
    
           This function does not output a fully RFC4514 compliant string, if
           that is required see **gnutls_x509_crq_get_dn3()**.
    


## RETURNS



           **GNUTLS_E_SHORT_MEMORY_BUFFER** if the provided buffer is not long
           enough, and in that case the * _buf_size_ will be updated with the
           required size.  On success 0 is returned.
    


* * *
# menu_new

## NAME



           **new_menu** , **free_menu** - create and destroy menus
    


## SYNOPSIS



           **#include <menu.h>**
    
           **MENU *new_menu(ITEM ****_items_**);**
           **int free_menu(MENU ***_menu_**);**
    


## DESCRIPTION



           The function **new_menu** creates a new menu connected to a specified
           item pointer array (which must be **NULL** -terminated).
    
           The function **free_menu** disconnects _menu_ from its item array and
           frees the storage allocated for the menu.
    


## RETURN VALUE



           The function **new_menu** returns **NULL** on error.  It sets **errno**
           according to the function's failure:
    
           **E_NOT_CONNECTED**
                No items are connected to the menu.
    
           **E_SYSTEM_ERROR**
                System error occurred, e.g., malloc failure.
    
           The function **free_menu** returns one of the following:
    
           **E_OK** The routine succeeded.
    
           **E_SYSTEM_ERROR**
                System error occurred (see errno(3)).
    
           **E_BAD_ARGUMENT**
                Routine detected an incorrect or out-of-range argument.
    
           **E_POSTED**
                The menu has already been posted.
    


## NOTES



           The header file **< menu.h> **automatically includes the header file
           **< curses.h>**.
    


## PORTABILITY



           These routines emulate the System V menu library.  They were not
           supported on Version 7 or BSD versions.
    


* * *
# capng_set_rootid

## NAME



           capng_set_rootid - set namespace root id
    


## SYNOPSIS



           **#include <cap-ng.h>**
    
           int capng_set_rootid(int rootid);
    


## DESCRIPTION



           capng_set_rootid sets the rootid for capabilities operations. This
           is only applicable for file system operations.
    


## RETURN VALUE



           On success, it returns 0. It returns -1 if there is an internal
           error or the kernel does not suppor V3 filesystem capabilities.
    


* * *
# pmiaddinstance

## NAME



           **pmiAddInstance** - add an element to an instance domain in a
           LOGIMPORT context
    


## C SYNOPSIS



           **#include <pcp/pmapi.h>**
           **#include <pcp/import.h>**
    
           **int pmiAddInstance(pmInDom** _indom_**, const char ***_instance_**, int** _inst_**);**
    
           **cc ... -lpcp_import -lpcp**
    


## Perl SYNOPSIS



           **use PCP::LogImport;**
    
           **pmiAddInstance($**_indom_**, $**_instance_**, $**_inst_**);**
    


## DESCRIPTION



           As   part   of  the  Performance  Co-Pilot  Log  Import  API  (see
           LOGIMPORT(3)), **pmiAddInstance** adds a new element to  the  instance
           domain identified by _indom_.
    
           _indom_ would normally be constructed using the **pmInDom_build** macro,
           e.g.  pmInDom_build(PMI_DOMAIN,0) for the first instance domain in
           the Performance Metrics Domain PMI_DOMAIN (which  is  the  default
           for all meta data created by the LOGIMPORT library).
    
           The new instance must have both an external name (_instance_) and an
           internal  instance identifier (_inst_) that is unique across all in‐
           stances  in  the  _indom_  instance  domain.   There  is  a  special
           ``uniqueness    rule''   for   _instance_   that   is   imposed   by
           pmLookupInDom(3), namely that the external instance name  must  be
           unique  in  the  leading  non-space  characters, e.g. the instance
           names ``foo'' and ``foo bar'' are considered the same by this rule
           and not allowed in the  same  instance  domain,  but  ``foo''  and
           ``foobar'' would be allowed.
    
           Once  defined,  the external instance name can be used in calls to
           pmiGetHandle(3) and/or pmiPutValue(3) with the name  of  a  metric
           defined over the same instance domain.
    


## DIAGNOSTICS



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


* * *
# sigaddset

## 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



           sigaddset — add a signal to a signal set
    


## SYNOPSIS



           #include <signal.h>
    
           int sigaddset(sigset_t *_set_ , int _signo_);
    


## DESCRIPTION



           The _sigaddset_() function adds the individual signal specified by
           the _signo_ to the signal set pointed to by _set_.
    
           Applications shall call either _sigemptyset_() or _sigfillset_() at
           least once for each object of type **sigset_t** prior to any other use
           of that object. If such an object is not initialized in this way,
           but is nonetheless supplied as an argument to any of
           _pthread_sigmask_(), _sigaction_(), _sigaddset_(), _sigdelset_(),
           _sigismember_(), _sigpending_(), _sigprocmask_(), _sigsuspend_(),
           _sigtimedwait_(), _sigwait_(), or _sigwaitinfo_(), the results are
           undefined.
    


## RETURN VALUE



           Upon successful completion, _sigaddset_() shall return 0; otherwise,
           it shall return -1 and set _errno_ to indicate the error.
    


## ERRORS



           The _sigaddset_() function may fail if:
    
           **EINVAL** The value of the _signo_ argument is an invalid or
                  unsupported signal number.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           None.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *
# gnutls_x509_crl_get_crt_count

## NAME



           gnutls_x509_crl_get_crt_count - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **int gnutls_x509_crl_get_crt_count(gnutls_x509_crl_t** _crl_**);**
    


## ARGUMENTS



           gnutls_x509_crl_t crl
                       should contain a **gnutls_x509_crl_t** type
    


## DESCRIPTION



           This function will return the number of revoked certificates in
           the given CRL.
    


## RETURNS



           number of certificates, a negative error code on failure.
    


* * *
# sd_bus_get_current_handler

## NAME



           sd_bus_get_current_handler, sd_bus_get_current_message,
           sd_bus_get_current_slot, sd_bus_get_current_userdata - Query
           information of the callback a bus object is currently running
    


## SYNOPSIS



           **#include <systemd/sd-bus.h>**
    
           **typedef int (*sd_bus_message_handler_t)(sd_bus_message ***_m_**,**
                                                   **void ***_userdata_**,**
                                                   **sd_bus_error ***_ret_error_**);**
    
           **sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus ***_bus_**);**
    
           **sd_bus_message* sd_bus_get_current_message(sd_bus ***_bus_**);**
    
           **sd_bus_slot* sd_bus_get_current_slot(sd_bus ***_bus_**);**
    
           **void* sd_bus_get_current_userdata(sd_bus ***_bus_**);**
    


## DESCRIPTION



           Whenever sd-bus is about to invoke a user-supplied callback
           function, it stores the current callback, D-Bus message, slot and
           userdata pointer and allows these to be queried via
           **sd_bus_get_current_handler()** , **sd_bus_get_current_message()** ,
           **sd_bus_get_current_slot()** and **sd_bus_get_current_userdata()** ,
           respectively. If _bus_ cannot be resolved or if execution does not
           reside in a user-supplied callback of _bus_ , these functions return
           **NULL**.
    


## RETURN VALUE



           On success, these functions return the requested object. On
           failure, they return **NULL**.
    


## NOTES



           Functions described here are available as a shared library, which
           can be compiled against and linked to with the
           **libsystemd pkg-config**(1) file.
    
           The code described here uses getenv(3), which is declared to be
           not multi-thread-safe. This means that the code calling the
           functions described here must not call setenv(3) from a parallel
           thread. It is recommended to only do calls to **setenv()** from an
           early phase of the program when no other threads have been
           started.
    


* * *
# io_uring_prep_msg_ring_fd_alloc

## NAME



           io_uring_prep_msg_ring_fd - send a direct descriptor to another
           ring
    


## SYNOPSIS



           **#include <liburing.h>**
    
           **void io_uring_prep_msg_ring_fd(struct io_uring_sqe ***_sqe_**,**
                                   **int** _fd_**,**
                                   **int** _source_fd_**,**
                                   **int** _target_fd_**,**
                                   **__u64** _data_**,**
                                   **unsigned int** _flags_**);**
    
           **void io_uring_prep_msg_ring_fd_alloc(struct io_uring_sqe ***_sqe_**,**
                                   **int** _fd_**,**
                                   **int** _source_fd_**,**
                                   **__u64** _data_**,**
                                   **unsigned int** _flags_**);**
    


## DESCRIPTION



           io_uring_prep_msg_ring_fd(3) prepares an SQE to send a direct file
           descriptor to another ring. The submission queue entry _sqe_ is
           setup to use the file descriptor _fd_ , which must identify a target
           io_uring context, to send the locally registered file descriptor
           with value _source_fd_ to the destination ring into index _target_fd_
           and passing _data_ as the user data in the target CQE with the
           request modifier flags set by _flags_.  Currently there are no valid
           flag modifiers, this field must contain **0**.
    
           io_uring_prep_msg_ring_fd_alloc(3) is similar to
           io_uring_prep_msg_ring_fd(3), but doesn't specify a target index
           for the direct descriptor. Instead, this index is allocated in the
           target ring and returned in the CQE _res_ field.
    


## RETURN VALUE



           None
    


## ERRORS



           These are the errors that are reported in the CQE _res_ field.
    
           **-ENOMEM**
                  The kernel was unable to allocate memory for the request.
    
           **-EINVAL**
                  One of the fields set in the SQE was invalid.
    
           **-EINVAL**
                  Target ring is identical to the source ring.
    
           **-EBADFD**
                  The descriptor passed in _fd_ does not refer to an io_uring
                  file descriptor, or the ring is in a disabled state.
    
           **-EOVERFLOW**
                  The kernel was unable to fill a CQE on the target ring.
                  This can happen if the target CQ ring is in an overflow
                  state and the kernel wasn't able to allocate memory for a
                  new CQE entry.
    
           **-ENFILE**
                  The direct descriptor table in the target ring was full, no
                  new descriptors could be successfully allocated.
    


* * *
# scanf

## 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



           scanf — convert formatted input
    


## SYNOPSIS



           #include <stdio.h>
    
           int scanf(const char *restrict _format_ , ...);
    


## DESCRIPTION



           Refer to fscanf(3p).
    


* * *
# profil

## NAME



           profil - execution time profile
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <unistd.h>**
    
           **int profil(unsigned short ***_buf_**, size_t** _bufsiz_**,**
                      **size_t** _offset_**, unsigned int** _scale_**);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           **profil**():
               Since glibc 2.21:
                   _DEFAULT_SOURCE
               In glibc 2.19 and 2.20:
                   _DEFAULT_SOURCE || (_XOPEN_SOURCE && _XOPEN_SOURCE < 500)
               Up to and including glibc 2.19:
                   _BSD_SOURCE || (_XOPEN_SOURCE && _XOPEN_SOURCE < 500)
    


## DESCRIPTION



           This routine provides a means to find out in what areas your
           program spends most of its time.  The argument _buf_ points to
           _bufsiz_ bytes of core.  Every virtual 10 milliseconds, the user's
           program counter (PC) is examined: _offset_ is subtracted and the
           result is multiplied by _scale_ and divided by 65536.  If the
           resulting value is less than _bufsiz_ , then the corresponding entry
           in _buf_ is incremented.  If _buf_ is NULL, profiling is disabled.
    


## RETURN VALUE



           Zero is always returned.
    


## ATTRIBUTES



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


## STANDARDS



           None.
    


## BUGS



           **profil**() cannot be used on a program that also uses **ITIMER_PROF**
           interval timers (see setitimer(2)).
    
           True kernel profiling provides more accurate results.
    


* * *