tripathysagar/man_text huggingface dataset:
# umad_get_port

## NAME



           umad_get_port, umad_release_port - open and close an InfiniBand
           port
    


## SYNOPSIS



           **#include <infiniband/umad.h>**
    
           **int umad_get_port(char** _*ca_name_**, int** _portnum_**, umad_port_t** _*port_**);**
    
           **int umad_release_port(umad_port_t** _*port_**);**
    


## DESCRIPTION



           **umad_get_port()** fills the _port_ structure with the IB port
           attributes specified by _ca_name_ and _portnum_ , or the default port
           if _ca_name_ is NULL and _portnum_ is zero. If only one of _ca_name_ and
           _portnum_ are specified, the other is used as a filter.  For
           example, passing a NULL _ca_name_ and 2 for the _portnum_ means get a
           port from any of the local IB devices, as long as it is the second
           port.  Note that the library may use some reference scheme to
           support port caching therefore **umad_release_port()** should be
           called before the _port_ structure can be deallocated.  The argument
           _port_ is an **umad_port_t** struct, as specified in
           <infiniband/umad.h>.
    
           typedef struct umad_port {
                   char ca_name[UMAD_CA_NAME_LEN];                 /* Name of the device */
                   int portnum;                                    /* Physical port number */
                   uint base_lid;                                  /* Base port LID */
                   uint lmc;                                       /* LMC of LID */
                   uint sm_lid;                                    /* SM LID */
                   uint sm_sl;                                     /* SM service level */
                   uint state;                                     /* Logical port state */
                   uint phys_state;                                /* Physical port state */
                   uint rate;                                      /* Port link bit rate */
                   uint64_t capmask;                               /* Port capabilities */
                   uint64_t gid_prefix;                            /* Gid prefix of this port */
                   uint64_t port_guid;                             /* GUID of this port */
           } umad_port_t;
    
           **umad_release_port()** releases the resources that were allocated by
           the **umad_get_port()** function for the specified IB _port_.
    


## RETURN VALUE



           **umad_get_port()** and **umad_release_port()** return 0 on success, and a
           negative value on error.
    


* * *
# gnutls_x509_privkey_export_pkcs8

## NAME



           gnutls_x509_privkey_export_pkcs8 - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **int gnutls_x509_privkey_export_pkcs8(gnutls_x509_privkey_t** _key_**,**
           **gnutls_x509_crt_fmt_t** _format_**, const char ***_password_**, unsigned int**
           _flags_**, void ***_output_data_**, size_t ***_output_data_size_**);**
    


## ARGUMENTS



           gnutls_x509_privkey_t key
                       Holds the key
    
           gnutls_x509_crt_fmt_t format
                       the format of output params. One of PEM or DER.
    
           const char * password
                       the password that will be used to encrypt the key.
    
           unsigned int flags
                       an ORed sequence of gnutls_pkcs_encrypt_flags_t
    
           void * output_data
                       will contain a private key PEM or DER encoded
    
           size_t * output_data_size
                       holds the size of output_data (and will be replaced by
                       the actual size of parameters)
    


## DESCRIPTION



           This function will export the private key to a PKCS8 structure.
           Both RSA and DSA keys can be exported. For DSA keys we use PKCS **11**
           definitions. If the flags do not specify the encryption cipher,
           then the default 3DES (PBES2) will be used.
    
           The  _password_ can be either ASCII or UTF-8 in the default PBES2
           encryption schemas, or ASCII for the PKCS12 schemas.
    
           If the buffer provided is not long enough to hold the output, then
           *output_data_size is updated and GNUTLS_E_SHORT_MEMORY_BUFFER will
           be returned.
    
           If the structure is PEM encoded, it will have a header of "BEGIN
           ENCRYPTED PRIVATE KEY" or "BEGIN PRIVATE KEY" if encryption is not
           used.
    


## RETURNS



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


* * *
# function::user_string_utf16

## NAME



           function::user_string_utf16 - Retrieves UTF-16 string from user
           memory
    


## SYNOPSIS



           1) user_string_utf16:string(addr:long)
    
           2) user_string_utf16:string(addr:long,err_msg:string)
    


## ARGUMENTS



           _addr_
               The user address to retrieve the string from
    
           _err_msg_
               The error message to return when data isn't available
    


## DESCRIPTION



           1) This function returns a null terminated UTF-8 string converted
           from the UTF-16 string at a given user memory address. Reports an
           error on string copy fault or conversion error.
    
           2) This function returns a null terminated UTF-8 string converted
           from the UTF-16 string at a given user memory address. Reports the
           given error message on string copy fault or conversion error.
    


* * *
# gnutls_group_get_name

## NAME



           gnutls_group_get_name - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **const char * gnutls_group_get_name(gnutls_group_t** _group_**);**
    


## ARGUMENTS



           gnutls_group_t group
                       is an element from **gnutls_group_t**
    


## DESCRIPTION



           Convert a **gnutls_group_t** value to a string.
    


## RETURNS



           a string that contains the name of the specified group or **NULL**.
    


## SINCE



           3.6.0
    


* * *
# pthread_attr_setscope

## 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_attr_setscope — set the contentionscope attribute
           (**REALTIME THREADS**)
    


## SYNOPSIS



           #include <pthread.h>
    
           int pthread_attr_setscope(pthread_attr_t *_attr_ , int _contentionscope_);
    


## DESCRIPTION



           Refer to pthread_attr_getscope(3p).
    


* * *
# pcap_setnonblock

## NAME



           pcap_setnonblock, pcap_getnonblock - set or get the state of non-
           blocking mode on a capture device
    


## SYNOPSIS



           **#include <pcap/pcap.h>**
    
           **char errbuf[PCAP_ERRBUF_SIZE];**
    
           **int pcap_setnonblock(pcap_t *p, int nonblock, char *errbuf);**
           **int pcap_getnonblock(pcap_t *p, char *errbuf);**
    


## DESCRIPTION



           **pcap_setnonblock**() puts a capture handle into ``non-blocking''
           mode, or takes it out of ``non-blocking'' mode, depending on
           whether the _nonblock_ argument is non-zero or zero.  It has no
           effect on ``savefiles''.  _errbuf_ is a buffer large enough to hold
           at least **PCAP_ERRBUF_SIZE** chars.
    
           In ``non-blocking'' mode, an attempt to read from the capture
           descriptor with **pcap_dispatch**(3PCAP) and **pcap_next_ex**(3PCAP) will,
           if no packets are currently available to be read, return **0**
           immediately rather than blocking waiting for packets to arrive.
    
           **pcap_loop**(3PCAP) will loop forever, consuming CPU time when no
           packets are currently available; **pcap_dispatch**() should be used
           instead.  **pcap_next**(3PCAP) will return **NULL** if there are no
           packets currently available to read; this is indistinguishable
           from an error, so **pcap_next_ex**() should be used instead.
    
           When first activated with **pcap_activate**(3PCAP) or opened with
           **pcap_open_live**(3PCAP), a capture handle is not in ``non-blocking
           mode''; a call to **pcap_setnonblock**() is required in order to put
           it into ``non-blocking'' mode.
    


## RETURN VALUE



           **pcap_setnonblock()** return 0 on success, **PCAP_ERROR_NOT_ACTIVATED**
           if called on a capture handle that has been created but not
           activated, and **PCAP_ERROR** for other errors.  **pcap_getnonblock**()
           returns the current ``non-blocking'' state of the capture
           descriptor on success; it always returns **0** on ``savefiles''.  It
           returns **PCAP_ERROR_NOT_ACTIVATED** if called on a capture handle
           that has been created but not activated, and **PCAP_ERROR** for other
           errors.  If **PCAP_ERROR** is returned, _errbuf_ is filled in with an
           appropriate error message.
    


* * *
# wctob

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



           wctob — wide-character to single-byte conversion
    


## SYNOPSIS



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


## 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 _wctob_() function shall determine whether _c_ corresponds to a
           member of the extended character set whose character
           representation is a single byte when in the initial shift state.
    
           The behavior of this function shall be affected by the _LC_CTYPE_
           category of the current locale.
    


## RETURN VALUE



           The _wctob_() function shall return EOF if _c_ does not correspond to
           a character with length one in the initial shift state. Otherwise,
           it shall return the single-byte representation of that character
           as an **unsigned char** converted to **int**.
    


## ERRORS



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


## EXAMPLES



           None.
    


## APPLICATION USAGE



           None.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *
# gnutls_oid_to_digest

## NAME



           gnutls_oid_to_digest - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **gnutls_digest_algorithm_t gnutls_oid_to_digest(const char ***_oid_**);**
    


## ARGUMENTS



           const char * oid
                       is an object identifier
    


## DESCRIPTION



           Converts a textual object identifier to a
           **gnutls_digest_algorithm_t** value.
    


## RETURNS



           a **gnutls_digest_algorithm_t** id of the specified digest algorithm,
           or **GNUTLS_DIG_UNKNOWN** on failure.
    


## SINCE



           3.4.3
    


* * *
# gnutls_pcert_import_openpgp_raw

## NAME



           gnutls_pcert_import_openpgp_raw - API function
    


## SYNOPSIS



           **#include <gnutls/abstract.h>**
    
           **int gnutls_pcert_import_openpgp_raw(gnutls_pcert_st ***_pcert_**, const**
           **gnutls_datum_t ***_cert_**, gnutls_openpgp_crt_fmt_t** _format_**,**
           **gnutls_openpgp_keyid_t** _keyid_**, unsigned int** _flags_**);**
    


## ARGUMENTS



           gnutls_pcert_st * pcert
                       The pcert structure
    
           const gnutls_datum_t * cert
                       The raw certificate to be imported
    
           gnutls_openpgp_crt_fmt_t format
                       The format of the certificate
    
           gnutls_openpgp_keyid_t keyid
                       The key ID to use (NULL for the master key)
    
           unsigned int flags
                       zero for now
    


## DESCRIPTION



           This function is no-op.
    


## RETURNS



           **GNUTLS_E_UNIMPLEMENTED_FEATURE**.
    


## SINCE



           3.0
    


* * *
# auparse_get_serial

## NAME



           auparse_get_serial - get the event's serial number
    


## SYNOPSIS



           **#include <auparse.h>**
    
           **unsigned long auparse_get_serial(const auparse_state_t ***_au);"_
    


## DESCRIPTION



           auparse_get_serial gets the serial number value from the current
           event's timestamp data structure.
    


## RETURN VALUE



           Returns 0 if an error occurs; otherwise, the serial number for the
           event.
    


* * *
# probe::signal.handle.return

## NAME



           probe::signal.handle.return - Signal handler invocation completed
    


## SYNOPSIS



           signal.handle.return
    


## VALUES



           _retstr_
               Return value as a string
    
           _name_
               Name of the probe point
    


## DESCRIPTION



           (deprecated in SystemTap 2.1)
    


* * *
# itimerspec

## NAME



           itimerspec - interval for a timer with nanosecond precision
    


## LIBRARY



           Standard C library (_libc_)
    


## SYNOPSIS



           **#include <time.h>**
    
           **struct itimerspec {**
               **struct timespec  it_interval;** /* Interval for periodic timer */
               **struct timespec  it_value;** /* Initial expiration */
           **};**
    


## DESCRIPTION



           Describes the initial expiration of a timer, and its interval, in
           seconds and nanoseconds.
    


## STANDARDS



           POSIX.1-2008.
    


* * *
# gnutls_x509_policies_init

## NAME



           gnutls_x509_policies_init - API function
    


## SYNOPSIS



           **#include <gnutls/x509-ext.h>**
    
           **int gnutls_x509_policies_init(gnutls_x509_policies_t ***_policies_**);**
    


## ARGUMENTS



           gnutls_x509_policies_t * policies
                       The authority key ID
    


## DESCRIPTION



           This function will initialize an authority key ID type.
    


## RETURNS



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


## SINCE



           3.3.0
    


* * *
# strnlen

## NAME



           strnlen - determine the length of a fixed-size string
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <string.h>**
    
           **size_t strnlen(** size_t maxlen;
                          **const char** _s_**[**_maxlen_**], size_t** _maxlen_**);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           **strnlen**():
               Since glibc 2.10:
                   _POSIX_C_SOURCE >= 200809L
               Before glibc 2.10:
                   _GNU_SOURCE
    


## DESCRIPTION



           The **strnlen**() function returns the number of bytes in the string
           pointed to by _s_ , excluding the terminating null byte ('\0'), but
           at most _maxlen_.  In doing this, **strnlen**() looks only at the first
           _maxlen_ characters in the string pointed to by _s_ and never beyond
           _s[maxlen-1]_.
    


## RETURN VALUE



           The **strnlen**() function returns _strlen(s)_ , if that is less than
           _maxlen_ , or _maxlen_ if there is no null terminating ('\0') among the
           first _maxlen_ characters pointed to by _s_.
    


## ATTRIBUTES



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


## STANDARDS



           POSIX.1-2008.
    


* * *
# gnutls_fips140_mode_enabled

## NAME



           gnutls_fips140_mode_enabled - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **unsigned gnutls_fips140_mode_enabled(**_void_**);**
    


## ARGUMENTS



            void
    


## DESCRIPTION



           Checks whether this library is in FIPS140 mode. The returned value
           corresponds to the library mode as set with
           **gnutls_fips140_set_mode()**.
    
           If **gnutls_fips140_set_mode()** was called with
           **GNUTLS_FIPS140_SET_MODE_THREAD** then this function will return the
           current thread's FIPS140 mode, otherwise the global value is
           returned.
    


## RETURNS



           return non-zero if true or zero if false.
    


## SINCE



           3.3.0
    


* * *
# gnutls_srp_base64_encode

## NAME



           gnutls_srp_base64_encode - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **int gnutls_srp_base64_encode(const gnutls_datum_t ***_data_**, char ***
           _result_**, size_t ***_result_size_**);**
    


## ARGUMENTS



           const gnutls_datum_t * data
                       contain the raw data
    
           char * result
                       the place where base64 data will be copied
    
           size_t * result_size
                       holds the size of the result
    


## DESCRIPTION



           This function will convert the given data to printable data, using
           the base64 encoding, as used in the libsrp.  This is the encoding
           used in SRP password files.  If the provided buffer is not long
           enough GNUTLS_E_SHORT_MEMORY_BUFFER is returned.
    
           Warning!  This base64 encoding is not the "standard" encoding, so
           do not use it for non-SRP purposes.
    


## RETURNS



           **GNUTLS_E_SHORT_MEMORY_BUFFER** if the buffer given is not long
           enough, or 0 on success.
    


* * *
# probe::nfsd.proc.write

## NAME



           probe::nfsd.proc.write - NFS server writing data to file for
           client
    


## SYNOPSIS



           nfsd.proc.write
    


## VALUES



           _version_
               nfs version
    
           _client_ip_
               the ip address of client
    
           _proto_
               transfer protocol
    
           _uid_
               requester's user id
    
           _vlen_
               read blocks
    
           _gid_
               requester's group id
    
           _count_
               read bytes
    
           _size_
               read bytes
    
           _vec_
               struct kvec, includes buf address in kernel address and length
               of each buffer
    
           _stable_
               argp->stable
    
           _offset_
               the offset of file
    
           _fh_
               file handle (the first part is the length of the file handle)
    


* * *
# libpfm_amd64_k8

## NAME



           libpfm_amd64_k8 - support for AMD64 K8 processors
    


## SYNOPSIS



           **#include <perfmon/pfmlib.h>**
    
           **PMU name: amd64_k8_revb, amd64_k8_revc, amd64_k8_revd, amd64_k8_reve, amd64_k8_revf, amd64_k8_revg**
           **PMU desc: AMD64 K8 RevB, AMD64 K8 RevC, AMD64 K8 RevD, AMD64 K8 RevE, AMD64 K8 RevF, AMD64 K8 RevG**
    


## DESCRIPTION



           The library supports AMD K8 processors in both 32 and 64-bit
           modes. They correspond to processor family 15.
    


## MODIFIERS



           The following modifiers are supported on AMD64 K8 processors:
    
           **u** Measure at user level which includes privilege levels 1, 2,
                  3. This corresponds to **PFM_PLM3**.  This is a boolean
                  modifier.
    
           **k** Measure at kernel level which includes privilege level 0.
                  This corresponds to **PFM_PLM0**.  This is a boolean modifier.
    
           **i** Invert the meaning of the event. The counter will now count
                  cycles in which the event is **not** occurring. This is a
                  boolean modifier
    
           **e** Enable edge detection, i.e., count only when there is a
                  state transition. This is a boolean modifier.
    
           **c** Set the counter mask value. The mask acts as a threshold.
                  The counter will count the number of cycles in which the
                  number of occurrences of the event is greater or equal to
                  the threshold. This is an integer modifier with values in
                  the range [0:255].
    


* * *
# gnutls_pkcs11_set_pin_function

## NAME



           gnutls_pkcs11_set_pin_function - API function
    


## SYNOPSIS



           **#include <gnutls/pkcs11.h>**
    
           **void gnutls_pkcs11_set_pin_function(gnutls_pin_callback_t** _fn_**, void**
           *****_userdata_**);**
    


## ARGUMENTS



           gnutls_pin_callback_t fn
                       The PIN callback, a **gnutls_pin_callback_t()** function.
    
           void * userdata
                       data to be supplied to callback
    


## DESCRIPTION



           This function will set a callback function to be used when a PIN
           is required for PKCS 11 operations.  See **gnutls_pin_callback_t()**
           on how the callback should behave.
    


## SINCE



           2.12.0
    


* * *
# gnutls_anti_replay_deinit

## NAME



           gnutls_anti_replay_deinit - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **void gnutls_anti_replay_deinit(gnutls_anti_replay_t** _anti_replay_**);**
    


## ARGUMENTS



           gnutls_anti_replay_t anti_replay
                       is a **gnutls_anti_replay** type
    


## DESCRIPTION



           This function will deinitialize all resources occupied by the
           given anti-replay context.
    


## SINCE



           3.6.5
    


* * *
# pcap_set_snaplen

## NAME



           pcap_set_snaplen - set the snapshot length for a not-yet-activated
           capture handle
    


## SYNOPSIS



           **#include <pcap/pcap.h>**
    
           **int pcap_set_snaplen(pcap_t *p, int snaplen);**
    


## DESCRIPTION



           **pcap_set_snaplen**() sets the snapshot length to be used on a
           capture handle when the handle is activated to _snaplen_.
    


## RETURN VALUE



           **pcap_set_snaplen**() returns **0** on success or **PCAP_ERROR_ACTIVATED** if
           called on a capture handle that has been activated.
    


* * *
# gnutls_x509_ext_import_private_key_usage_period

## NAME



           gnutls_x509_ext_import_private_key_usage_period - API function
    


## SYNOPSIS



           **#include <gnutls/x509-ext.h>**
    
           **int gnutls_x509_ext_import_private_key_usage_period(const**
           **gnutls_datum_t ***_ext_**, time_t ***_activation_**, time_t ***_expiration_**);**
    


## ARGUMENTS



           const gnutls_datum_t * ext
                       the DER encoded extension data
    
           time_t * activation
                       Will hold the activation time
    
           time_t * expiration
                       Will hold the expiration time
    


## DESCRIPTION



           This function will return the expiration and activation times of
           the private key as written in the PKIX extension 2.5.29.16.
    


## RETURNS



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


## SINCE



           3.3.0
    


* * *
# mq_setattr

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



           mq_setattr — set message queue attributes (**REALTIME**)
    


## SYNOPSIS



           #include <mqueue.h>
    
           int mq_setattr(mqd_t _mqdes_ , const struct mq_attr *restrict _mqstat_ ,
               struct mq_attr *restrict _omqstat_);
    


## DESCRIPTION



           The _mq_setattr_() function shall set attributes associated with the
           open message queue description referenced by the message queue
           descriptor specified by _mqdes_.
    
           The message queue attributes corresponding to the following
           members defined in the **mq_attr** structure shall be set to the
           specified values upon successful completion of _mq_setattr_():
    
           _mq_flags_    The value of this member is the bitwise-logical OR of
                       zero or more of O_NONBLOCK and any implementation-
                       defined flags.
    
           The values of the _mq_maxmsg_ , _mq_msgsize_ , and _mq_curmsgs_ members of
           the **mq_attr** structure shall be ignored by _mq_setattr_().
    
           If _omqstat_ is non-NULL, the _mq_setattr_() function shall store, in
           the location referenced by _omqstat_ , the previous message queue
           attributes and the current queue status.  These values shall be
           the same as would be returned by a call to _mq_getattr_() at that
           point.
    


## RETURN VALUE



           Upon successful completion, the function shall return a value of
           zero and the attributes of the message queue shall have been
           changed as specified.
    
           Otherwise, the message queue attributes shall be unchanged, and
           the function shall return a value of -1 and set _errno_ to indicate
           the error.
    


## ERRORS



           The _mq_setattr_() function shall fail if:
    
           **EBADF** The _mqdes_ argument is not a valid message queue descriptor.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           None.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *
# gnutls_heartbeat_enable

## NAME



           gnutls_heartbeat_enable - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **void gnutls_heartbeat_enable(gnutls_session_t** _session_**, unsigned**
           **int** _type_**);**
    


## ARGUMENTS



           gnutls_session_t session
                       is a **gnutls_session_t** type.
    
           unsigned int type
                       one of the GNUTLS_HB_* flags
    


## DESCRIPTION



           If this function is called with the **GNUTLS_HB_PEER_ALLOWED_TO_SEND**
            _type_ , GnuTLS will allow heartbeat messages to be received.
           Moreover it also request the peer to accept heartbeat messages.
           This function must be called prior to TLS handshake.
    
           If the  _type_ used is **GNUTLS_HB_LOCAL_ALLOWED_TO_SEND** , then the
           peer will be asked to accept heartbeat messages but not send ones.
    
           The function **gnutls_heartbeat_allowed()** can be used to test
           Whether locally generated heartbeat messages can be accepted by
           the peer.
    


## SINCE



           3.1.2
    


* * *
# function::randint

## NAME



           function::randint - Return a random number between [0,n)
    


## SYNOPSIS



               randint:long(n:long)
    


## ARGUMENTS



           _n_
               Number past upper limit of range, not larger than 2**20.
    


* * *
# gnutls_sec_param_to_pk_bits

## NAME



           gnutls_sec_param_to_pk_bits - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **unsigned int gnutls_sec_param_to_pk_bits(gnutls_pk_algorithm_t**
           _algo_**, gnutls_sec_param_t** _param_**);**
    


## ARGUMENTS



           gnutls_pk_algorithm_t algo
                       is a public key algorithm
    
           gnutls_sec_param_t param
                       is a security parameter
    


## DESCRIPTION



           When generating private and public key pairs a difficult question
           is which size of "bits" the modulus will be in RSA and the group
           size in DSA. The easy answer is 1024, which is also wrong. This
           function will convert a human understandable security parameter to
           an appropriate size for the specific algorithm.
    


## RETURNS



           The number of bits, or (0).
    


## SINCE



           2.12.0
    


* * *
# gnutls_ciphersuite_get

## NAME



           gnutls_ciphersuite_get - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **const char * gnutls_ciphersuite_get(gnutls_session_t** _session_**);**
    


## ARGUMENTS



           gnutls_session_t session
                       is a **gnutls_session_t** type.
    


## DESCRIPTION



           Get the canonical name of negotiated TLS ciphersuite.  The names
           returned by this function match the IANA registry, with one
           exception:
    
           TLS_DHE_DSS_RC4_128_SHA { 0x00, 0x66 }
    
           which is reserved for compatibility.
    
           To get a detailed description of the current ciphersuite, it is
           recommended to use **gnutls_session_get_desc()**.
    


## RETURNS



           a string that contains the canonical name of a TLS ciphersuite, or
           **NULL** if the handshake is not completed.
    


## SINCE



           3.7.4
    


* * *
# casinl

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



           casinl — complex arc sine functions
    


## SYNOPSIS



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


## DESCRIPTION



           Refer to casin(3p).
    


* * *
# dlerror

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



           dlerror — get diagnostic information
    


## SYNOPSIS



           #include <dlfcn.h>
    
           char *dlerror(void);
    


## DESCRIPTION



           The _dlerror_() function shall return a null-terminated character
           string (with no trailing <newline>) that describes the last error
           that occurred during dynamic linking processing. If no dynamic
           linking errors have occurred since the last invocation of
           _dlerror_(), _dlerror_() shall return NULL.  Thus, invoking _dlerror_()
           a second time, immediately following a prior invocation, shall
           result in NULL being returned.
    
           It is implementation-defined whether or not the _dlerror_() function
           is thread-safe. A thread-safe implementation shall return only
           errors that occur on the current thread.
    


## RETURN VALUE



           If successful, _dlerror_() shall return a null-terminated character
           string; otherwise, NULL shall be returned.
    
           The application shall not modify the string returned. The returned
           pointer might be invalidated or the string content might be
           overwritten by a subsequent call to _dlerror_() in the same thread
           (if _dlerror_() is thread-safe) or in any thread (if _dlerror_() is
           not thread-safe). The returned pointer might also be invalidated
           if the calling thread is terminated.
    


## ERRORS



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


## EXAMPLES



           The following example prints out the last dynamic linking error:
    
               ...
               #include <dlfcn.h>
    
               char *errstr;
    
               errstr = dlerror();
               if (errstr != NULL)
                   printf ("A dynamic linking error occurred: (%s)\n", errstr);
               ...
    


## APPLICATION USAGE



           Depending on the application environment with respect to
           asynchronous execution events, such as signals or other
           asynchronous computation sharing the address space, conforming
           applications should use a critical section to retrieve the error
           pointer and buffer.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *
# gnutls_pubkey_deinit

## NAME



           gnutls_pubkey_deinit - API function
    


## SYNOPSIS



           **#include <gnutls/abstract.h>**
    
           **void gnutls_pubkey_deinit(gnutls_pubkey_t** _key_**);**
    


## ARGUMENTS



           gnutls_pubkey_t key
                       The key to be deinitialized
    


## DESCRIPTION



           This function will deinitialize a public key structure.
    


## SINCE



           2.12.0
    


* * *
# gnutls_x509_crq_get_pk_algorithm

## NAME



           gnutls_x509_crq_get_pk_algorithm - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **int gnutls_x509_crq_get_pk_algorithm(gnutls_x509_crq_t** _crq_**,**
           **unsigned int ***_bits_**);**
    


## ARGUMENTS



           gnutls_x509_crq_t crq
                       should contain a **gnutls_x509_crq_t** type
    
           unsigned int * bits
                       if bits is non-**NULL** it will hold the size of the
                       parameters' in bits
    


## DESCRIPTION



           This function will return the public key algorithm of a PKCS**10**
           certificate request.
    
           If bits is non-**NULL** , it should have enough size to hold the
           parameters size in bits.  For RSA the bits returned is the
           modulus.  For DSA the bits returned are of the public exponent.
    


## RETURNS



           a member of the **gnutls_pk_algorithm_t** enumeration on success, or a
           negative error code on error.
    


* * *
# probe::udp.recvmsg.return

## NAME



           probe::udp.recvmsg.return - Fires whenever an attempt to receive a
           UDP message received is completed
    


## SYNOPSIS



           udp.recvmsg.return
    


## VALUES



           _sport_
               UDP source port
    
           _dport_
               UDP destination port
    
           _daddr_
               A string representing the destination IP address
    
           _size_
               Number of bytes received by the process
    
           _name_
               The name of this probe
    
           _saddr_
               A string representing the source IP address
    
           _family_
               IP address family
    


## CONTEXT



           The process which received a UDP message
    


* * *
# ibv_modify_cq

## NAME



           ibv_modify_cq - modify a completion queue (CQ)
    


## SYNOPSIS



           **#include <infiniband/verbs.h>**
    
           **int ibv_modify_cq(struct ibv_cq** _*cq_**, struct ibv_modify_cq_attr** _*cq_attr_**);**
    


## DESCRIPTION



           **ibv_modify_cq()** modify a CQ _cq_.  The argument _cq_attr_ is an
           ibv_modify_cq_attr struct, as defined in <infiniband/verbs.h>.
    
           struct ibv_moderate_cq {
                   uint16_t cq_count;  /* number of completions per event */
                   uint16_t cq_period; /* in micro seconds */
           };
    
           struct ibv_modify_cq_attr {
                        uint32_t attr_mask;
                        struct ibv_moderate_cq moderate;
           };
    
           The function **ibv_modify_cq()** will modify the CQ, based on the
           given _cq_attr_ ->attr_mask
    


## RETURN VALUE



           returns 0 on success, or the value of errno on failure (which
           indicates the failure reason).
    


* * *
# probe::vm.mmap

## NAME



           probe::vm.mmap - Fires when an mmap is requested
    


## SYNOPSIS



           vm.mmap
    


## VALUES



           _length_
               the length of the memory segment
    
           _address_
               the requested address
    
           _name_
               name of the probe point
    


## CONTEXT



           The process calling mmap.
    


* * *
# pcap_getnonblock

## NAME



           pcap_setnonblock, pcap_getnonblock - set or get the state of non-
           blocking mode on a capture device
    


## SYNOPSIS



           **#include <pcap/pcap.h>**
    
           **char errbuf[PCAP_ERRBUF_SIZE];**
    
           **int pcap_setnonblock(pcap_t *p, int nonblock, char *errbuf);**
           **int pcap_getnonblock(pcap_t *p, char *errbuf);**
    


## DESCRIPTION



           **pcap_setnonblock**() puts a capture handle into ``non-blocking''
           mode, or takes it out of ``non-blocking'' mode, depending on
           whether the _nonblock_ argument is non-zero or zero.  It has no
           effect on ``savefiles''.  _errbuf_ is a buffer large enough to hold
           at least **PCAP_ERRBUF_SIZE** chars.
    
           In ``non-blocking'' mode, an attempt to read from the capture
           descriptor with **pcap_dispatch**(3PCAP) and **pcap_next_ex**(3PCAP) will,
           if no packets are currently available to be read, return **0**
           immediately rather than blocking waiting for packets to arrive.
    
           **pcap_loop**(3PCAP) will loop forever, consuming CPU time when no
           packets are currently available; **pcap_dispatch**() should be used
           instead.  **pcap_next**(3PCAP) will return **NULL** if there are no
           packets currently available to read; this is indistinguishable
           from an error, so **pcap_next_ex**() should be used instead.
    
           When first activated with **pcap_activate**(3PCAP) or opened with
           **pcap_open_live**(3PCAP), a capture handle is not in ``non-blocking
           mode''; a call to **pcap_setnonblock**() is required in order to put
           it into ``non-blocking'' mode.
    


## RETURN VALUE



           **pcap_setnonblock()** return 0 on success, **PCAP_ERROR_NOT_ACTIVATED**
           if called on a capture handle that has been created but not
           activated, and **PCAP_ERROR** for other errors.  **pcap_getnonblock**()
           returns the current ``non-blocking'' state of the capture
           descriptor on success; it always returns **0** on ``savefiles''.  It
           returns **PCAP_ERROR_NOT_ACTIVATED** if called on a capture handle
           that has been created but not activated, and **PCAP_ERROR** for other
           errors.  If **PCAP_ERROR** is returned, _errbuf_ is filled in with an
           appropriate error message.
    


* * *
# capng_restore_state

## NAME



           capng_restore_state - set the internal library state
    


## SYNOPSIS



           **#include <cap-ng.h>**
    
           void capng_restore_state(void **state);
    


## DESCRIPTION



           capng_restore_state is a function that takes the state information
           previously saved by capng_save_state and restores the libraries
           internal state. This function is not available in the python
           bindings.
    


## RETURN VALUE



           None.
    


## NOTES



           capng_restore_state free's the previously malloc'd state, thus the
           state can't be restored multiple times.
    
           The working pid is part of the restored state, if restoring the
           state to a different thread, capng_setpid can be used to update
           it.
    


* * *
# ntp_gettime

## NAME



           ntp_gettime, ntp_gettimex  - get time parameters (NTP daemon
           interface)
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <sys/timex.h>**
    
           **int ntp_gettime(struct ntptimeval ***_ntv_**);**
           **int ntp_gettimex(struct ntptimeval ***_ntv_**);**
    


## DESCRIPTION



           Both of these APIs return information to the caller via the _ntv_
           argument, a structure of the following type:
    
               struct ntptimeval {
                   struct timeval time;    /* Current time */
                   long maxerror;          /* Maximum error */
                   long esterror;          /* Estimated error */
                   long tai;               /* TAI offset */
    
                   /* Further padding bytes allowing for future expansion */
               };
    
           The fields of this structure are as follows:
    
           _time_   The current time, expressed as a _timeval_ structure:
    
                      struct timeval {
                          time_t      tv_sec;   /* Seconds since the Epoch */
                          suseconds_t tv_usec;  /* Microseconds */
                      };
    
           _maxerror_
                  Maximum error, in microseconds.  This value can be
                  initialized by ntp_adjtime(3), and is increased
                  periodically (on Linux: each second), but is clamped to an
                  upper limit (the kernel constant **NTP_PHASE_MAX** , with a
                  value of 16,000).
    
           _esterror_
                  Estimated error, in microseconds.  This value can be set
                  via ntp_adjtime(3) to contain an estimate of the difference
                  between the system clock and the true time.  This value is
                  not used inside the kernel.
    
           _tai_    TAI (Atomic International Time) offset.
    
           **ntp_gettime**() returns an _ntptimeval_ structure in which the _time_ ,
           _maxerror_ , and _esterror_ fields are filled in.
    
           **ntp_gettimex**() performs the same task as **ntp_gettime**(), but also
           returns information in the _tai_ field.
    


## RETURN VALUE



           The return values for **ntp_gettime**() and **ntp_gettimex**() are as for
           adjtimex(2).  Given a correct pointer argument, these functions
           always succeed.
    


## ATTRIBUTES



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


## STANDARDS



           **ntp_gettime**()
                  NTP Kernel Application Program Interface.
    
           **ntp_gettimex**()
                  GNU.
    


* * *
# dane_raw_tlsa

## NAME



           dane_raw_tlsa - API function
    


## SYNOPSIS



           **#include <gnutls/dane.h>**
    
           **int dane_raw_tlsa(dane_state_t** _s_**, dane_query_t ***_r_**, char *const ***
           _dane_data_**, const int ***_dane_data_len_**, int** _secure_**, int** _bogus_**);**
    


## ARGUMENTS



           dane_state_t s
                       The DANE state structure
    
           dane_query_t * r
                       A structure to place the result
    
           char *const * dane_data
                       array of DNS rdata items, terminated with a NULL
                       pointer; caller must guarantee that the referenced
                       data remains valid until **dane_query_deinit()** is
                       called.
    
           const int * dane_data_len
                       the length n bytes of the dane_data items
    
           int secure  true if the result is validated securely, false if
                       validation failed or the domain queried has no
                       security info
    
           int bogus   if the result was not secure (secure = 0) due to a
                       security failure, and the result is due to a security
                       failure, bogus is true.
    


## DESCRIPTION



           This function will fill in the TLSA (DANE) structure from the
           given raw DNS record data. The  _dane_data_ must be valid during the
           lifetime of the query.
    


## RETURNS



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


* * *
# capng_print_caps_text

## NAME



           capng_print_caps_text - print names of values for capabilities set
    


## SYNOPSIS



           **#include <cap-ng.h>**
    
           char *capng_print_caps_text(capng_print_t where, capng_type_t
           which);
    


## DESCRIPTION



           capng_print_caps_text will create a text string representation of
           the internal capability set specified. The representation can be
           sent to either stdout or a buffer by passing CAPNG_PRINT_STDOUT or
           CAPNG_PRINT_BUFFER respectively for the where parameter. If the
           option was for a buffer, this function will malloc a buffer that
           the caller must free.
    
           The legal values for the which parameter is CAPNG_EFFECTIVE,
           CAPNG_PERMITTED, CAPNG_INHERITABLE, CAPNG_BOUNDING_SET, or
           CAPNG_AMBIENT.
    


## RETURN VALUE



           If CAPNG_PRINT_BUFFER was selected for where, this will be the
           text buffer and NULL on failure. If CAPNG_PRINT_STDOUT was
           selected then this value will be NULL no matter what.
    


* * *
# pcap_setdirection

## NAME



           pcap_setdirection - set the direction for which packets will be
           captured
    


## SYNOPSIS



           **#include <pcap/pcap.h>**
    
           **int pcap_setdirection(pcap_t *p, pcap_direction_t d);**
    


## DESCRIPTION



           **pcap_setdirection**() is used to specify a direction that packets
           will be captured.  _d_ is one of the constants **PCAP_D_IN** , **PCAP_D_OUT**
           or **PCAP_D_INOUT**.  **PCAP_D_IN** will only capture packets received by
           the device, **PCAP_D_OUT** will only capture packets sent by the
           device and **PCAP_D_INOUT** will capture packets received by or sent
           by the device.  **PCAP_D_INOUT** is the default setting if this
           function is not called.
    
           **pcap_setdirection**() isn't necessarily fully supported on all
           platforms; some platforms might return an error for all values,
           and some other platforms might not support **PCAP_D_OUT**.
    
           This operation is not supported if a ``savefile'' is being read.
    


## RETURN VALUE



           **pcap_setdirection**() returns **0** on success, **PCAP_ERROR_NOT_ACTIVATED**
           if called on a capture handle that has been created but not
           activated, or **PCAP_ERROR** on other errors. If **PCAP_ERROR** is
           returned, **pcap_geterr**(3PCAP) or **pcap_perror**(3PCAP) may be called
           with _p_ as an argument to fetch or display the error text.
    


* * *