VirtualBox

Ignore:
Timestamp:
Mar 3, 2022 7:17:34 PM (3 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
150325
Message:

libs/openssl-3.0.1: started applying and adjusting our OpenSSL changes to 3.0.1. bugref:10128

Location:
trunk/src/libs/openssl-3.0.1
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/libs/openssl-3.0.1

    • Property svn:mergeinfo

      •  

        old new  
        1212/vendor/openssl/1.1.1c:131722-131725
        1313/vendor/openssl/1.1.1k:145841-145843
         14/vendor/openssl/3.0.1:150323-150324
         15/vendor/openssl/current:147554-150322

  • trunk/src/libs/openssl-3.0.1/doc/man3/OPENSSL_malloc.pod

    r91772 r94082  
    99OPENSSL_strdup, OPENSSL_strndup,
    1010OPENSSL_memdup, OPENSSL_strlcpy, OPENSSL_strlcat,
    11 OPENSSL_hexstr2buf, OPENSSL_buf2hexstr, OPENSSL_hexchar2int,
    1211CRYPTO_strdup, CRYPTO_strndup,
    1312OPENSSL_mem_debug_push, OPENSSL_mem_debug_pop,
    1413CRYPTO_mem_debug_push, CRYPTO_mem_debug_pop,
    1514CRYPTO_clear_realloc, CRYPTO_clear_free,
     15CRYPTO_malloc_fn, CRYPTO_realloc_fn, CRYPTO_free_fn,
    1616CRYPTO_get_mem_functions, CRYPTO_set_mem_functions,
    1717CRYPTO_get_alloc_counts,
    … …  
    2626 #include <openssl/crypto.h>
    2727
    28  int OPENSSL_malloc_init(void)
    29 
    30  void *OPENSSL_malloc(size_t num)
    31  void *OPENSSL_zalloc(size_t num)
    32  void *OPENSSL_realloc(void *addr, size_t num)
    33  void OPENSSL_free(void *addr)
    34  char *OPENSSL_strdup(const char *str)
    35  char *OPENSSL_strndup(const char *str, size_t s)
     28 int OPENSSL_malloc_init(void);
     29
     30 void *OPENSSL_malloc(size_t num);
     31 void *OPENSSL_zalloc(size_t num);
     32 void *OPENSSL_realloc(void *addr, size_t num);
     33 void OPENSSL_free(void *addr);
     34 char *OPENSSL_strdup(const char *str);
     35 char *OPENSSL_strndup(const char *str, size_t s);
    3636 size_t OPENSSL_strlcat(char *dst, const char *src, size_t size);
    3737 size_t OPENSSL_strlcpy(char *dst, const char *src, size_t size);
    38  void *OPENSSL_memdup(void *data, size_t s)
    39  void *OPENSSL_clear_realloc(void *p, size_t old_len, size_t num)
    40  void OPENSSL_clear_free(void *str, size_t num)
     38 void *OPENSSL_memdup(void *data, size_t s);
     39 void *OPENSSL_clear_realloc(void *p, size_t old_len, size_t num);
     40 void OPENSSL_clear_free(void *str, size_t num);
    4141 void OPENSSL_cleanse(void *ptr, size_t len);
    4242
    43  unsigned char *OPENSSL_hexstr2buf(const char *str, long *len);
    44  char *OPENSSL_buf2hexstr(const unsigned char *buffer, long len);
    45  int OPENSSL_hexchar2int(unsigned char c);
    46 
    47  void *CRYPTO_malloc(size_t num, const char *file, int line)
    48  void *CRYPTO_zalloc(size_t num, const char *file, int line)
    49  void *CRYPTO_realloc(void *p, size_t num, const char *file, int line)
    50  void CRYPTO_free(void *str, const char *, int)
    51  char *CRYPTO_strdup(const char *p, const char *file, int line)
    52  char *CRYPTO_strndup(const char *p, size_t num, const char *file, int line)
     43 void *CRYPTO_malloc(size_t num, const char *file, int line);
     44 void *CRYPTO_zalloc(size_t num, const char *file, int line);
     45 void *CRYPTO_realloc(void *p, size_t num, const char *file, int line);
     46 void CRYPTO_free(void *str, const char *, int);
     47 char *CRYPTO_strdup(const char *p, const char *file, int line);
     48 char *CRYPTO_strndup(const char *p, size_t num, const char *file, int line);
    5349 void *CRYPTO_clear_realloc(void *p, size_t old_len, size_t num,
    54                             const char *file, int line)
    55  void CRYPTO_clear_free(void *str, size_t num, const char *, int)
    56 
    57  void CRYPTO_get_mem_functions(
    58          void *(**m)(size_t, const char *, int),
    59          void *(**r)(void *, size_t, const char *, int),
    60          void (**f)(void *, const char *, int))
    61  int CRYPTO_set_mem_functions(
    62          void *(*m)(size_t, const char *, int),
    63          void *(*r)(void *, size_t, const char *, int),
    64          void (*f)(void *, const char *, int))
    65 
    66  void CRYPTO_get_alloc_counts(int *m, int *r, int *f)
    67 
    68  int CRYPTO_set_mem_debug(int onoff)
     50                            const char *file, int line);
     51 void CRYPTO_clear_free(void *str, size_t num, const char *, int);
     52
     53 typedef void *(*CRYPTO_malloc_fn)(size_t num, const char *file, int line);
     54 typedef void *(*CRYPTO_realloc_fn)(void *addr, size_t num, const char *file,
     55                                    int line);
     56 typedef void (*CRYPTO_free_fn)(void *addr, const char *file, int line);
     57 void CRYPTO_get_mem_functions(CRYPTO_malloc_fn *malloc_fn,
     58                               CRYPTO_realloc_fn *realloc_fn,
     59                               CRYPTO_free_fn *free_fn);
     60 int CRYPTO_set_mem_functions(CRYPTO_malloc_fn malloc_fn,
     61                              CRYPTO_realloc_fn realloc_fn,
     62                              CRYPTO_free_fn free_fn);
     63
     64 void CRYPTO_get_alloc_counts(int *mcount, int *rcount, int *fcount);
    6965
    7066 env OPENSSL_MALLOC_FAILURES=... <application>
    7167 env OPENSSL_MALLOC_FD=... <application>
    7268
    73  int CRYPTO_mem_ctrl(int mode);
    74 
    75  int OPENSSL_mem_debug_push(const char *info)
    76  int OPENSSL_mem_debug_pop(void);
    77 
    78  int CRYPTO_mem_debug_push(const char *info, const char *file, int line);
    79  int CRYPTO_mem_debug_pop(void);
     69The following functions have been deprecated since OpenSSL 3.0, and can be
     70hidden entirely by defining B<OPENSSL_API_COMPAT> with a suitable version value,
     71see L<openssl_user_macros(7)>:
    8072
    8173 int CRYPTO_mem_leaks(BIO *b);
    … …  
    8375 int CRYPTO_mem_leaks_cb(int (*cb)(const char *str, size_t len, void *u),
    8476                         void *u);
     77
     78 int CRYPTO_set_mem_debug(int onoff);
     79 int CRYPTO_mem_ctrl(int mode);
     80 int OPENSSL_mem_debug_push(const char *info);
     81 int OPENSSL_mem_debug_pop(void);
     82 int CRYPTO_mem_debug_push(const char *info, const char *file, int line);
     83 int CRYPTO_mem_debug_pop(void);
    8584
    8685=head1 DESCRIPTION
    … …  
    119118library functions and are provided for portability.
    120119
    121 OPENSSL_hexstr2buf() parses B<str> as a hex string and returns a
    122 pointer to the parsed value. The memory is allocated by calling
    123 OPENSSL_malloc() and should be released by calling OPENSSL_free().
    124 If B<len> is not NULL, it is filled in with the output length.
    125 Colons between two-character hex "bytes" are ignored.
    126 An odd number of hex digits is an error.
    127 
    128 OPENSSL_buf2hexstr() takes the specified buffer and length, and returns
    129 a hex string for value, or NULL on error.
    130 B<Buffer> cannot be NULL; if B<len> is 0 an empty string is returned.
    131 
    132 OPENSSL_hexchar2int() converts a character to the hexadecimal equivalent,
    133 or returns -1 on error.
    134 
    135120If no allocations have been done, it is possible to "swap out" the default
    136 implementations for OPENSSL_malloc(), OPENSSL_realloc and OPENSSL_free()
    137 and replace them with alternate versions (hooks).
     121implementations for OPENSSL_malloc(), OPENSSL_realloc() and OPENSSL_free()
     122and replace them with alternate versions.
    138123CRYPTO_get_mem_functions() function fills in the given arguments with the
    139124function pointers for the current implementations.
    140125With CRYPTO_set_mem_functions(), you can specify a different set of functions.
    141 If any of B<m>, B<r>, or B<f> are NULL, then the function is not changed.
    142 
    143 The default implementation can include some debugging capability (if enabled
    144 at build-time).
    145 This adds some overhead by keeping a list of all memory allocations, and
    146 removes items from the list when they are free'd.
    147 This is most useful for identifying memory leaks.
    148 CRYPTO_set_mem_debug() turns this tracking on and off.  In order to have
    149 any effect, is must be called before any of the allocation functions
    150 (e.g., CRYPTO_malloc()) are called, and is therefore normally one of the
    151 first lines of main() in an application.
    152 CRYPTO_mem_ctrl() provides fine-grained control of memory leak tracking.
    153 To enable tracking call CRYPTO_mem_ctrl() with a B<mode> argument of
    154 the B<CRYPTO_MEM_CHECK_ON>.
    155 To disable tracking call CRYPTO_mem_ctrl() with a B<mode> argument of
    156 the B<CRYPTO_MEM_CHECK_OFF>.
    157 
    158 While checking memory, it can be useful to store additional context
    159 about what is being done.
    160 For example, identifying the field names when parsing a complicated
    161 data structure.
    162 OPENSSL_mem_debug_push() (which calls CRYPTO_mem_debug_push())
    163 attaches an identifying string to the allocation stack.
    164 This must be a global or other static string; it is not copied.
    165 OPENSSL_mem_debug_pop() removes identifying state from the stack.
    166 
    167 At the end of the program, calling CRYPTO_mem_leaks() or
    168 CRYPTO_mem_leaks_fp() will report all "leaked" memory, writing it
    169 to the specified BIO B<b> or FILE B<fp>. These functions return 1 if
    170 there are no leaks, 0 if there are leaks and -1 if an error occurred.
    171 
    172 CRYPTO_mem_leaks_cb() does the same as CRYPTO_mem_leaks(), but instead
    173 of writing to a given BIO, the callback function is called for each
    174 output string with the string, length, and userdata B<u> as the callback
    175 parameters.
     126If any of B<malloc_fn>, B<realloc_fn>, or B<free_fn> are NULL, then
     127the function is not changed.
     128While it's permitted to swap out only a few and not all the functions
     129with CRYPTO_set_mem_functions(), it's recommended to swap them all out
     130at once.
    176131
    177132If the library is built with the C<crypto-mdebug> option, then one
    … …  
    208163  ...app invocation... 3>/tmp/log$$
    209164
    210 
    211165=head1 RETURN VALUES
    212166
    … …  
    214168CRYPTO_free(), CRYPTO_clear_free() and CRYPTO_get_mem_functions()
    215169return no value.
    216 
    217 CRYPTO_mem_leaks(), CRYPTO_mem_leaks_fp() and CRYPTO_mem_leaks_cb() return 1 if
    218 there are no leaks, 0 if there are leaks and -1 if an error occurred.
    219170
    220171OPENSSL_malloc(), OPENSSL_zalloc(), OPENSSL_realloc(),
    … …  
    222173CRYPTO_malloc(), CRYPTO_zalloc(), CRYPTO_realloc(),
    223174CRYPTO_clear_realloc(),
    224 OPENSSL_buf2hexstr(), OPENSSL_hexstr2buf(),
    225175OPENSSL_strdup(), and OPENSSL_strndup()
    226176return a pointer to allocated memory or NULL on error.
    227177
    228 CRYPTO_set_mem_functions() and CRYPTO_set_mem_debug()
    229 return 1 on success or 0 on failure (almost
     178CRYPTO_set_mem_functions() returns 1 on success or 0 on failure (almost
    230179always because allocations have already happened).
    231180
    232 CRYPTO_mem_ctrl() returns -1 if an error occurred, otherwise the
    233 previous value of the mode.
    234 
    235 OPENSSL_mem_debug_push() and OPENSSL_mem_debug_pop()
    236 return 1 on success or 0 on failure.
    237 
    238 =head1 NOTES
    239 
    240 While it's permitted to swap out only a few and not all the functions
    241 with CRYPTO_set_mem_functions(), it's recommended to swap them all out
    242 at once.  I<This applies specially if OpenSSL was built with the
    243 configuration option> C<crypto-mdebug> I<enabled.  In case, swapping out
    244 only, say, the malloc() implementation is outright dangerous.>
     181CRYPTO_mem_leaks(), CRYPTO_mem_leaks_fp(), CRYPTO_mem_leaks_cb(),
     182CRYPTO_set_mem_debug(), and CRYPTO_mem_ctrl() are deprecated and return -1.
     183OPENSSL_mem_debug_push(), OPENSSL_mem_debug_pop(),
     184CRYPTO_mem_debug_push(), and CRYPTO_mem_debug_pop()
     185are deprecated and return 0.
     186
     187=head1 HISTORY
     188
     189OPENSSL_mem_debug_push(), OPENSSL_mem_debug_pop(),
     190CRYPTO_mem_debug_push(), CRYPTO_mem_debug_pop(),
     191CRYPTO_mem_leaks(), CRYPTO_mem_leaks_fp(),
     192CRYPTO_mem_leaks_cb(), CRYPTO_set_mem_debug(), CRYPTO_mem_ctrl()
     193were deprecated in OpenSSL 3.0.
     194The memory-leak checking has been deprecated in OpenSSL 3.0 in favor of
     195clang's memory and leak sanitizer.
     196
    245197
    246198=head1 COPYRIGHT
    247199
    248 Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved.
    249 
    250 Licensed under the OpenSSL license (the "License").  You may not use
     200Copyright 2016-2021 The OpenSSL Project Authors. All Rights Reserved.
     201
     202Licensed under the Apache License 2.0 (the "License").  You may not use
    251203this file except in compliance with the License.  You can obtain a copy
    252204in the file LICENSE in the source distribution or at
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette