FM / openssl

/usr/include/openssl

Name	Size	Mode	Actions
aes.h	3349	0644	edit dl rm
asn1.h	33627	0644	edit dl rm
asn1err.h	14687	0644	edit dl rm
asn1t.h	32940	0644	edit dl rm
asn1_mac.h	395	0644	edit dl rm
async.h	2398	0644	edit dl rm
asyncerr.h	1326	0644	edit dl rm
bio.h	34907	0644	edit dl rm
bioerr.h	6400	0644	edit dl rm
blowfish.h	1847	0644	edit dl rm
bn.h	22135	0644	edit dl rm
bnerr.h	4969	0644	edit dl rm
buffer.h	1600	0644	edit dl rm
buffererr.h	820	0644	edit dl rm
camellia.h	3179	0644	edit dl rm
cast.h	1674	0644	edit dl rm
cmac.h	1064	0644	edit dl rm
cms.h	16379	0644	edit dl rm
cmserr.h	11160	0644	edit dl rm
comp.h	1328	0644	edit dl rm
comperr.h	1212	0644	edit dl rm
conf.h	5601	0644	edit dl rm
conferr.h	3429	0644	edit dl rm
conf_api.h	1300	0644	edit dl rm
crypto.h	17335	0644	edit dl rm
cryptoerr.h	2261	0644	edit dl rm
ct.h	15872	0644	edit dl rm
cterr.h	3470	0644	edit dl rm
des.h	7627	0644	edit dl rm
dh.h	13738	0644	edit dl rm
dherr.h	4415	0644	edit dl rm
dsa.h	10103	0644	edit dl rm
dsaerr.h	3350	0644	edit dl rm
dtls1.h	1578	0644	edit dl rm
ebcdic.h	924	0644	edit dl rm
ec.h	63657	0644	edit dl rm
ecdh.h	358	0644	edit dl rm
ecdsa.h	358	0644	edit dl rm
ecerr.h	16640	0644	edit dl rm
engine.h	34661	0644	edit dl rm
engineerr.h	5447	0644	edit dl rm
err.h	11269	0644	edit dl rm
evp.h	76938	0644	edit dl rm
evperr.h	12073	0644	edit dl rm
e_os2.h	8887	0644	edit dl rm
fips.h	9975	0644	edit dl rm
fips_rand.h	7169	0644	edit dl rm
hmac.h	1591	0644	edit dl rm
idea.h	2099	0644	edit dl rm
kdf.h	7565	0644	edit dl rm
kdferr.h	4788	0644	edit dl rm
lhash.h	9271	0644	edit dl rm
md2.h	1054	0644	edit dl rm
md4.h	1322	0644	edit dl rm
md5.h	1320	0644	edit dl rm
mdc2.h	1053	0644	edit dl rm
modes.h	10478	0644	edit dl rm
objects.h	6633	0644	edit dl rm
objectserr.h	1316	0644	edit dl rm
obj_mac.h	218486	0644	edit dl rm
ocsp.h	15305	0644	edit dl rm
ocsperr.h	3356	0644	edit dl rm
opensslconf-x86_64.h	4898	0644	edit dl rm
opensslconf.h	1581	0644	edit dl rm
opensslv.h	4107	0644	edit dl rm
ossl_typ.h	6310	0644	edit dl rm
pem.h	15468	0644	edit dl rm
pem2.h	415	0644	edit dl rm
pemerr.h	5222	0644	edit dl rm
pkcs7.h	11590	0644	edit dl rm
pkcs7err.h	5110	0644	edit dl rm
pkcs12.h	9871	0644	edit dl rm
pkcs12err.h	3749	0644	edit dl rm
rand.h	2358	0644	edit dl rm
randerr.h	4695	0644	edit dl rm
rand_drbg.h	4763	0644	edit dl rm
rc2.h	1534	0644	edit dl rm
rc4.h	825	0644	edit dl rm
rc5.h	1988	0644	edit dl rm
ripemd.h	1243	0644	edit dl rm
rsa.h	22348	0644	edit dl rm
rsaerr.h	9819	0644	edit dl rm
safestack.h	8139	0644	edit dl rm
seed.h	3479	0644	edit dl rm
sha.h	3831	0644	edit dl rm
srp.h	3827	0644	edit dl rm
srtp.h	1316	0644	edit dl rm
ssl.h	111160	0644	edit dl rm
ssl2.h	542	0644	edit dl rm
ssl3.h	14705	0644	edit dl rm
sslerr.h	46676	0644	edit dl rm
stack.h	3095	0644	edit dl rm
store.h	11199	0644	edit dl rm
storeerr.h	4399	0644	edit dl rm
symhacks.h	1311	0644	edit dl rm
tls1.h	72490	0644	edit dl rm
ts.h	22429	0644	edit dl rm
tserr.h	6746	0644	edit dl rm
txt_db.h	1666	0644	edit dl rm
ui.h	16052	0644	edit dl rm
uierr.h	2737	0644	edit dl rm
whrlpool.h	1377	0644	edit dl rm
x509.h	43326	0644	edit dl rm
x509err.h	6803	0644	edit dl rm
x509v3.h	33441	0644	edit dl rm
x509v3err.h	8777	0644	edit dl rm
x509_vfy.h	32451	0644	edit dl rm

Edit: /usr/include/openssl/safestack.h (8139B)

/*
 * Copyright 1999-2019 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the OpenSSL license (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#ifndef HEADER_SAFESTACK_H
# define HEADER_SAFESTACK_H

# include <openssl/stack.h>
# include <openssl/e_os2.h>

#ifdef __cplusplus
extern "C" {
#endif

# define STACK_OF(type) struct stack_st_##type

# define SKM_DEFINE_STACK_OF(t1, t2, t3) \
    STACK_OF(t1); \
    typedef int (*sk_##t1##_compfunc)(const t3 * const *a, const t3 *const *b); \
    typedef void (*sk_##t1##_freefunc)(t3 *a); \
    typedef t3 * (*sk_##t1##_copyfunc)(const t3 *a); \
    static ossl_unused ossl_inline int sk_##t1##_num(const STACK_OF(t1) *sk) \
    { \
        return OPENSSL_sk_num((const OPENSSL_STACK *)sk); \
    } \
    static ossl_unused ossl_inline t2 *sk_##t1##_value(const STACK_OF(t1) *sk, int idx) \
    { \
        return (t2 *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); \
    } \
    static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new(sk_##t1##_compfunc compare) \
    { \
        return (STACK_OF(t1) *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); \
    } \
    static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_null(void) \
    { \
        return (STACK_OF(t1) *)OPENSSL_sk_new_null(); \
    } \
    static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_reserve(sk_##t1##_compfunc compare, int n) \
    { \
        return (STACK_OF(t1) *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); \
    } \
    static ossl_unused ossl_inline int sk_##t1##_reserve(STACK_OF(t1) *sk, int n) \
    { \
        return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); \
    } \
    static ossl_unused ossl_inline void sk_##t1##_free(STACK_OF(t1) *sk) \
    { \
        OPENSSL_sk_free((OPENSSL_STACK *)sk); \
    } \
    static ossl_unused ossl_inline void sk_##t1##_zero(STACK_OF(t1) *sk) \
    { \
        OPENSSL_sk_zero((OPENSSL_STACK *)sk); \
    } \
    static ossl_unused ossl_inline t2 *sk_##t1##_delete(STACK_OF(t1) *sk, int i) \
    { \
        return (t2 *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); \
    } \
    static ossl_unused ossl_inline t2 *sk_##t1##_delete_ptr(STACK_OF(t1) *sk, t2 *ptr) \
    { \
        return (t2 *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, \
                                           (const void *)ptr); \
    } \
    static ossl_unused ossl_inline int sk_##t1##_push(STACK_OF(t1) *sk, t2 *ptr) \
    { \
        return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); \
    } \
    static ossl_unused ossl_inline int sk_##t1##_unshift(STACK_OF(t1) *sk, t2 *ptr) \
    { \
        return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); \
    } \
    static ossl_unused ossl_inline t2 *sk_##t1##_pop(STACK_OF(t1) *sk) \
    { \
        return (t2 *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); \
    } \
    static ossl_unused ossl_inline t2 *sk_##t1##_shift(STACK_OF(t1) *sk) \
    { \
        return (t2 *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); \
    } \
    static ossl_unused ossl_inline void sk_##t1##_pop_free(STACK_OF(t1) *sk, sk_##t1##_freefunc freefunc) \
    { \
        OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); \
    } \
    static ossl_unused ossl_inline int sk_##t1##_insert(STACK_OF(t1) *sk, t2 *ptr, int idx) \
    { \
        return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); \
    } \
    static ossl_unused ossl_inline t2 *sk_##t1##_set(STACK_OF(t1) *sk, int idx, t2 *ptr) \
    { \
        return (t2 *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); \
    } \
    static ossl_unused ossl_inline int sk_##t1##_find(STACK_OF(t1) *sk, t2 *ptr) \
    { \
        return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); \
    } \
    static ossl_unused ossl_inline int sk_##t1##_find_ex(STACK_OF(t1) *sk, t2 *ptr) \
    { \
        return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); \
    } \
    static ossl_unused ossl_inline void sk_##t1##_sort(STACK_OF(t1) *sk) \
    { \
        OPENSSL_sk_sort((OPENSSL_STACK *)sk); \
    } \
    static ossl_unused ossl_inline int sk_##t1##_is_sorted(const STACK_OF(t1) *sk) \
    { \
        return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); \
    } \
    static ossl_unused ossl_inline STACK_OF(t1) * sk_##t1##_dup(const STACK_OF(t1) *sk) \
    { \
        return (STACK_OF(t1) *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); \
    } \
    static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_deep_copy(const STACK_OF(t1) *sk, \
                                                    sk_##t1##_copyfunc copyfunc, \
                                                    sk_##t1##_freefunc freefunc) \
    { \
        return (STACK_OF(t1) *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, \
                                            (OPENSSL_sk_copyfunc)copyfunc, \
                                            (OPENSSL_sk_freefunc)freefunc); \
    } \
    static ossl_unused ossl_inline sk_##t1##_compfunc sk_##t1##_set_cmp_func(STACK_OF(t1) *sk, sk_##t1##_compfunc compare) \
    { \
        return (sk_##t1##_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); \
    }

# define DEFINE_SPECIAL_STACK_OF(t1, t2) SKM_DEFINE_STACK_OF(t1, t2, t2)
# define DEFINE_STACK_OF(t) SKM_DEFINE_STACK_OF(t, t, t)
# define DEFINE_SPECIAL_STACK_OF_CONST(t1, t2) \
            SKM_DEFINE_STACK_OF(t1, const t2, t2)
# define DEFINE_STACK_OF_CONST(t) SKM_DEFINE_STACK_OF(t, const t, t)

/*-
 * Strings are special: normally an lhash entry will point to a single
 * (somewhat) mutable object. In the case of strings:
 *
 * a) Instead of a single char, there is an array of chars, NUL-terminated.
 * b) The string may have be immutable.
 *
 * So, they need their own declarations. Especially important for
 * type-checking tools, such as Deputy.
 *
 * In practice, however, it appears to be hard to have a const
 * string. For now, I'm settling for dealing with the fact it is a
 * string at all.
 */
typedef char *OPENSSL_STRING;
typedef const char *OPENSSL_CSTRING;

/*-
 * Confusingly, LHASH_OF(STRING) deals with char ** throughout, but
 * STACK_OF(STRING) is really more like STACK_OF(char), only, as mentioned
 * above, instead of a single char each entry is a NUL-terminated array of
 * chars. So, we have to implement STRING specially for STACK_OF. This is
 * dealt with in the autogenerated macros below.
 */
DEFINE_SPECIAL_STACK_OF(OPENSSL_STRING, char)
DEFINE_SPECIAL_STACK_OF_CONST(OPENSSL_CSTRING, char)

/*
 * Similarly, we sometimes use a block of characters, NOT nul-terminated.
 * These should also be distinguished from "normal" stacks.
 */
typedef void *OPENSSL_BLOCK;
DEFINE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void)

/*
 * If called without higher optimization (min. -xO3) the Oracle Developer
 * Studio compiler generates code for the defined (static inline) functions
 * above.
 * This would later lead to the linker complaining about missing symbols when
 * this header file is included but the resulting object is not linked against
 * the Crypto library (openssl#6912).
 */
# ifdef __SUNPRO_C
#  pragma weak OPENSSL_sk_num
#  pragma weak OPENSSL_sk_value
#  pragma weak OPENSSL_sk_new
#  pragma weak OPENSSL_sk_new_null
#  pragma weak OPENSSL_sk_new_reserve
#  pragma weak OPENSSL_sk_reserve
#  pragma weak OPENSSL_sk_free
#  pragma weak OPENSSL_sk_zero
#  pragma weak OPENSSL_sk_delete
#  pragma weak OPENSSL_sk_delete_ptr
#  pragma weak OPENSSL_sk_push
#  pragma weak OPENSSL_sk_unshift
#  pragma weak OPENSSL_sk_pop
#  pragma weak OPENSSL_sk_shift
#  pragma weak OPENSSL_sk_pop_free
#  pragma weak OPENSSL_sk_insert
#  pragma weak OPENSSL_sk_set
#  pragma weak OPENSSL_sk_find
#  pragma weak OPENSSL_sk_find_ex
#  pragma weak OPENSSL_sk_sort
#  pragma weak OPENSSL_sk_is_sorted
#  pragma weak OPENSSL_sk_dup
#  pragma weak OPENSSL_sk_deep_copy
#  pragma weak OPENSSL_sk_set_cmp_func
# endif /* __SUNPRO_C */

# ifdef  __cplusplus
}
# endif
#endif

cmd: