Return to lib509.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / tests / libtest

Annotation of embedaddon/curl/tests/libtest/lib509.c, revision 1.1

1.1     ! misho       1: /***************************************************************************
        !             2:  *                                  _   _ ____  _
        !             3:  *  Project                     ___| | | |  _ \| |
        !             4:  *                             / __| | | | |_) | |
        !             5:  *                            | (__| |_| |  _ <| |___
        !             6:  *                             \___|\___/|_| \_\_____|
        !             7:  *
        !             8:  * Copyright (C) 1998 - 2019, Daniel Stenberg, <daniel@haxx.se>, et al.
        !             9:  *
        !            10:  * This software is licensed as described in the file COPYING, which
        !            11:  * you should have received as part of this distribution. The terms
        !            12:  * are also available at https://curl.haxx.se/docs/copyright.html.
        !            13:  *
        !            14:  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
        !            15:  * copies of the Software, and permit persons to whom the Software is
        !            16:  * furnished to do so, under the terms of the COPYING file.
        !            17:  *
        !            18:  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
        !            19:  * KIND, either express or implied.
        !            20:  *
        !            21:  ***************************************************************************/
        !            22: #include "test.h"
        !            23: 
        !            24: #include <string.h>
        !            25: 
        !            26: /*
        !            27:  * This test uses these funny custom memory callbacks for the only purpose
        !            28:  * of verifying that curl_global_init_mem() functionality is present in
        !            29:  * libcurl and that it works unconditionally no matter how libcurl is built,
        !            30:  * nothing more.
        !            31:  *
        !            32:  * Do not include memdebug.h in this source file, and do not use directly
        !            33:  * memory related functions in this file except those used inside custom
        !            34:  * memory callbacks which should be calling 'the real thing'.
        !            35:  */
        !            36: 
        !            37: /*
        !            38: #include "memdebug.h"
        !            39: */
        !            40: 
        !            41: static int seen_malloc = 0;
        !            42: static int seen_free = 0;
        !            43: static int seen_realloc = 0;
        !            44: static int seen_strdup = 0;
        !            45: static int seen_calloc = 0;
        !            46: 
        !            47: void *custom_malloc(size_t size);
        !            48: void custom_free(void *ptr);
        !            49: void *custom_realloc(void *ptr, size_t size);
        !            50: char *custom_strdup(const char *ptr);
        !            51: void *custom_calloc(size_t nmemb, size_t size);
        !            52: 
        !            53: 
        !            54: void *custom_calloc(size_t nmemb, size_t size)
        !            55: {
        !            56:   if(!seen_calloc) {
        !            57:     printf("seen custom_calloc()\n");
        !            58:     seen_calloc = 1;
        !            59:   }
        !            60:   return (calloc)(nmemb, size);
        !            61: }
        !            62: 
        !            63: void *custom_malloc(size_t size)
        !            64: {
        !            65:   if(!seen_malloc && seen_calloc) {
        !            66:     printf("seen custom_malloc()\n");
        !            67:     seen_malloc = 1;
        !            68:   }
        !            69:   return (malloc)(size);
        !            70: }
        !            71: 
        !            72: char *custom_strdup(const char *ptr)
        !            73: {
        !            74:   if(!seen_strdup && seen_malloc) {
        !            75:     /* currently (2013.03.13), memory tracking enabled builds do not call
        !            76:        the strdup callback, in this case malloc callback and memcpy are used
        !            77:        instead. If some day this is changed the following printf() should be
        !            78:        uncommented, and a line added to test definition.
        !            79:     printf("seen custom_strdup()\n");
        !            80:     */
        !            81:     seen_strdup = 1;
        !            82:   }
        !            83:   return (strdup)(ptr);
        !            84: }
        !            85: 
        !            86: void *custom_realloc(void *ptr, size_t size)
        !            87: {
        !            88:   if(!seen_realloc && seen_malloc) {
        !            89:     printf("seen custom_realloc()\n");
        !            90:     seen_realloc = 1;
        !            91:   }
        !            92:   return (realloc)(ptr, size);
        !            93: }
        !            94: 
        !            95: void custom_free(void *ptr)
        !            96: {
        !            97:   if(!seen_free && seen_realloc) {
        !            98:     printf("seen custom_free()\n");
        !            99:     seen_free = 1;
        !           100:   }
        !           101:   (free)(ptr);
        !           102: }
        !           103: 
        !           104: 
        !           105: int test(char *URL)
        !           106: {
        !           107:   unsigned char a[] = {0x2f, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
        !           108:                        0x91, 0xa2, 0xb3, 0xc4, 0xd5, 0xe6, 0xf7};
        !           109:   CURLcode res;
        !           110:   CURL *curl;
        !           111:   int asize;
        !           112:   char *str = NULL;
        !           113: 
        !           114:   (void)URL;
        !           115: 
        !           116:   res = curl_global_init_mem(CURL_GLOBAL_ALL,
        !           117:                              custom_malloc,
        !           118:                              custom_free,
        !           119:                              custom_realloc,
        !           120:                              custom_strdup,
        !           121:                              custom_calloc);
        !           122:   if(res != CURLE_OK) {
        !           123:     fprintf(stderr, "curl_global_init_mem() failed\n");
        !           124:     return TEST_ERR_MAJOR_BAD;
        !           125:   }
        !           126: 
        !           127:   curl = curl_easy_init();
        !           128:   if(!curl) {
        !           129:     fprintf(stderr, "curl_easy_init() failed\n");
        !           130:     curl_global_cleanup();
        !           131:     return TEST_ERR_MAJOR_BAD;
        !           132:   }
        !           133: 
        !           134:   test_setopt(curl, CURLOPT_USERAGENT, "test509"); /* uses strdup() */
        !           135: 
        !           136:   asize = (int)sizeof(a);
        !           137:   str = curl_easy_escape(curl, (char *)a, asize); /* uses realloc() */
        !           138: 
        !           139: test_cleanup:
        !           140: 
        !           141:   if(str)
        !           142:     curl_free(str);
        !           143: 
        !           144:   curl_easy_cleanup(curl);
        !           145:   curl_global_cleanup();
        !           146: 
        !           147:   return (int)res;
        !           148: }