1/*************************************************************************** 2 * _ _ ____ _ 3 * Project ___| | | | _ \| | 4 * / __| | | | |_) | | 5 * | (__| |_| | _ <| |___ 6 * \___|\___/|_| \_\_____| 7 * 8 * Copyright (C) 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.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 * SPDX-License-Identifier: curl 22 * 23 ***************************************************************************/ 24 25#include "curl_setup.h" 26 27#ifdef CURLDEBUG 28 29#include <curl/curl.h> 30 31#include "urldata.h" 32 33#define MEMDEBUG_NODEFINES /* don't redefine the standard functions */ 34 35/* The last 3 #include files should be in this order */ 36#include "curl_printf.h" 37#include "curl_memory.h" 38#include "memdebug.h" 39 40struct memdebug { 41 size_t size; 42 union { 43 curl_off_t o; 44 double d; 45 void *p; 46 } mem[1]; 47 /* I'm hoping this is the thing with the strictest alignment 48 * requirements. That also means we waste some space :-( */ 49}; 50 51/* 52 * Note that these debug functions are very simple and they are meant to 53 * remain so. For advanced analysis, record a log file and write perl scripts 54 * to analyze them! 55 * 56 * Don't use these with multithreaded test programs! 57 */ 58 59FILE *curl_dbg_logfile = NULL; 60static bool registered_cleanup = FALSE; /* atexit registered cleanup */ 61static bool memlimit = FALSE; /* enable memory limit */ 62static long memsize = 0; /* set number of mallocs allowed */ 63 64/* LeakSantizier (LSAN) calls _exit() instead of exit() when a leak is detected 65 on exit so the logfile must be closed explicitly or data could be lost. 66 Though _exit() does not call atexit handlers such as this, LSAN's call to 67 _exit() comes after the atexit handlers are called. curl/curl#6620 */ 68static void curl_dbg_cleanup(void) 69{ 70 if(curl_dbg_logfile && 71 curl_dbg_logfile != stderr && 72 curl_dbg_logfile != stdout) { 73 fclose(curl_dbg_logfile); 74 } 75 curl_dbg_logfile = NULL; 76} 77 78/* this sets the log file name */ 79void curl_dbg_memdebug(const char *logname) 80{ 81 if(!curl_dbg_logfile) { 82 if(logname && *logname) 83 curl_dbg_logfile = fopen(logname, FOPEN_WRITETEXT); 84 else 85 curl_dbg_logfile = stderr; 86#ifdef MEMDEBUG_LOG_SYNC 87 /* Flush the log file after every line so the log isn't lost in a crash */ 88 if(curl_dbg_logfile) 89 setbuf(curl_dbg_logfile, (char *)NULL); 90#endif 91 } 92 if(!registered_cleanup) 93 registered_cleanup = !atexit(curl_dbg_cleanup); 94} 95 96/* This function sets the number of malloc() calls that should return 97 successfully! */ 98void curl_dbg_memlimit(long limit) 99{ 100 if(!memlimit) { 101 memlimit = TRUE; 102 memsize = limit; 103 } 104} 105 106/* returns TRUE if this isn't allowed! */ 107static bool countcheck(const char *func, int line, const char *source) 108{ 109 /* if source is NULL, then the call is made internally and this check 110 should not be made */ 111 if(memlimit && source) { 112 if(!memsize) { 113 /* log to file */ 114 curl_dbg_log("LIMIT %s:%d %s reached memlimit\n", 115 source, line, func); 116 /* log to stderr also */ 117 fprintf(stderr, "LIMIT %s:%d %s reached memlimit\n", 118 source, line, func); 119 fflush(curl_dbg_logfile); /* because it might crash now */ 120 errno = ENOMEM; 121 return TRUE; /* RETURN ERROR! */ 122 } 123 else 124 memsize--; /* countdown */ 125 126 127 } 128 129 return FALSE; /* allow this */ 130} 131 132ALLOC_FUNC void *curl_dbg_malloc(size_t wantedsize, 133 int line, const char *source) 134{ 135 struct memdebug *mem; 136 size_t size; 137 138 DEBUGASSERT(wantedsize != 0); 139 140 if(countcheck("malloc", line, source)) 141 return NULL; 142 143 /* alloc at least 64 bytes */ 144 size = sizeof(struct memdebug) + wantedsize; 145 146 mem = (Curl_cmalloc)(size); 147 if(mem) { 148 mem->size = wantedsize; 149 } 150 151 if(source) 152 curl_dbg_log("MEM %s:%d malloc(%zu) = %p\n", 153 source, line, wantedsize, 154 mem ? (void *)mem->mem : (void *)0); 155 156 return (mem ? mem->mem : NULL); 157} 158 159ALLOC_FUNC void *curl_dbg_calloc(size_t wanted_elements, size_t wanted_size, 160 int line, const char *source) 161{ 162 struct memdebug *mem; 163 size_t size, user_size; 164 165 DEBUGASSERT(wanted_elements != 0); 166 DEBUGASSERT(wanted_size != 0); 167 168 if(countcheck("calloc", line, source)) 169 return NULL; 170 171 /* alloc at least 64 bytes */ 172 user_size = wanted_size * wanted_elements; 173 size = sizeof(struct memdebug) + user_size; 174 175 mem = (Curl_ccalloc)(1, size); 176 if(mem) 177 mem->size = user_size; 178 179 if(source) 180 curl_dbg_log("MEM %s:%d calloc(%zu,%zu) = %p\n", 181 source, line, wanted_elements, wanted_size, 182 mem ? (void *)mem->mem : (void *)0); 183 184 return (mem ? mem->mem : NULL); 185} 186 187ALLOC_FUNC char *curl_dbg_strdup(const char *str, 188 int line, const char *source) 189{ 190 char *mem; 191 size_t len; 192 193 DEBUGASSERT(str != NULL); 194 195 if(countcheck("strdup", line, source)) 196 return NULL; 197 198 len = strlen(str) + 1; 199 200 mem = curl_dbg_malloc(len, 0, NULL); /* NULL prevents logging */ 201 if(mem) 202 memcpy(mem, str, len); 203 204 if(source) 205 curl_dbg_log("MEM %s:%d strdup(%p) (%zu) = %p\n", 206 source, line, (const void *)str, len, (const void *)mem); 207 208 return mem; 209} 210 211#if defined(_WIN32) && defined(UNICODE) 212ALLOC_FUNC wchar_t *curl_dbg_wcsdup(const wchar_t *str, 213 int line, const char *source) 214{ 215 wchar_t *mem; 216 size_t wsiz, bsiz; 217 218 DEBUGASSERT(str != NULL); 219 220 if(countcheck("wcsdup", line, source)) 221 return NULL; 222 223 wsiz = wcslen(str) + 1; 224 bsiz = wsiz * sizeof(wchar_t); 225 226 mem = curl_dbg_malloc(bsiz, 0, NULL); /* NULL prevents logging */ 227 if(mem) 228 memcpy(mem, str, bsiz); 229 230 if(source) 231 curl_dbg_log("MEM %s:%d wcsdup(%p) (%zu) = %p\n", 232 source, line, (void *)str, bsiz, (void *)mem); 233 234 return mem; 235} 236#endif 237 238/* We provide a realloc() that accepts a NULL as pointer, which then 239 performs a malloc(). In order to work with ares. */ 240void *curl_dbg_realloc(void *ptr, size_t wantedsize, 241 int line, const char *source) 242{ 243 struct memdebug *mem = NULL; 244 245 size_t size = sizeof(struct memdebug) + wantedsize; 246 247 DEBUGASSERT(wantedsize != 0); 248 249 if(countcheck("realloc", line, source)) 250 return NULL; 251 252#ifdef __INTEL_COMPILER 253# pragma warning(push) 254# pragma warning(disable:1684) 255 /* 1684: conversion from pointer to same-sized integral type */ 256#endif 257 258 if(ptr) 259 mem = (void *)((char *)ptr - offsetof(struct memdebug, mem)); 260 261#ifdef __INTEL_COMPILER 262# pragma warning(pop) 263#endif 264 265 mem = (Curl_crealloc)(mem, size); 266 if(source) 267 curl_dbg_log("MEM %s:%d realloc(%p, %zu) = %p\n", 268 source, line, (void *)ptr, wantedsize, 269 mem ? (void *)mem->mem : (void *)0); 270 271 if(mem) { 272 mem->size = wantedsize; 273 return mem->mem; 274 } 275 276 return NULL; 277} 278 279void curl_dbg_free(void *ptr, int line, const char *source) 280{ 281 if(ptr) { 282 struct memdebug *mem; 283 284#ifdef __INTEL_COMPILER 285# pragma warning(push) 286# pragma warning(disable:1684) 287 /* 1684: conversion from pointer to same-sized integral type */ 288#endif 289 290 mem = (void *)((char *)ptr - offsetof(struct memdebug, mem)); 291 292#ifdef __INTEL_COMPILER 293# pragma warning(pop) 294#endif 295 296 /* free for real */ 297 (Curl_cfree)(mem); 298 } 299 300 if(source && ptr) 301 curl_dbg_log("MEM %s:%d free(%p)\n", source, line, (void *)ptr); 302} 303 304curl_socket_t curl_dbg_socket(int domain, int type, int protocol, 305 int line, const char *source) 306{ 307 curl_socket_t sockfd; 308 309 if(countcheck("socket", line, source)) 310 return CURL_SOCKET_BAD; 311 312 sockfd = socket(domain, type, protocol); 313 314 if(source && (sockfd != CURL_SOCKET_BAD)) 315 curl_dbg_log("FD %s:%d socket() = %" CURL_FORMAT_SOCKET_T "\n", 316 source, line, sockfd); 317 318 return sockfd; 319} 320 321SEND_TYPE_RETV curl_dbg_send(SEND_TYPE_ARG1 sockfd, 322 SEND_QUAL_ARG2 SEND_TYPE_ARG2 buf, 323 SEND_TYPE_ARG3 len, SEND_TYPE_ARG4 flags, int line, 324 const char *source) 325{ 326 SEND_TYPE_RETV rc; 327 if(countcheck("send", line, source)) 328 return -1; 329 rc = send(sockfd, buf, len, flags); 330 if(source) 331 curl_dbg_log("SEND %s:%d send(%lu) = %ld\n", 332 source, line, (unsigned long)len, (long)rc); 333 return rc; 334} 335 336RECV_TYPE_RETV curl_dbg_recv(RECV_TYPE_ARG1 sockfd, RECV_TYPE_ARG2 buf, 337 RECV_TYPE_ARG3 len, RECV_TYPE_ARG4 flags, int line, 338 const char *source) 339{ 340 RECV_TYPE_RETV rc; 341 if(countcheck("recv", line, source)) 342 return -1; 343 rc = recv(sockfd, buf, len, flags); 344 if(source) 345 curl_dbg_log("RECV %s:%d recv(%lu) = %ld\n", 346 source, line, (unsigned long)len, (long)rc); 347 return rc; 348} 349 350#ifdef HAVE_SOCKETPAIR 351int curl_dbg_socketpair(int domain, int type, int protocol, 352 curl_socket_t socket_vector[2], 353 int line, const char *source) 354{ 355 int res = socketpair(domain, type, protocol, socket_vector); 356 357 if(source && (0 == res)) 358 curl_dbg_log("FD %s:%d socketpair() = " 359 "%" CURL_FORMAT_SOCKET_T " %" CURL_FORMAT_SOCKET_T "\n", 360 source, line, socket_vector[0], socket_vector[1]); 361 362 return res; 363} 364#endif 365 366curl_socket_t curl_dbg_accept(curl_socket_t s, void *saddr, void *saddrlen, 367 int line, const char *source) 368{ 369 struct sockaddr *addr = (struct sockaddr *)saddr; 370 curl_socklen_t *addrlen = (curl_socklen_t *)saddrlen; 371 372 curl_socket_t sockfd = accept(s, addr, addrlen); 373 374 if(source && (sockfd != CURL_SOCKET_BAD)) 375 curl_dbg_log("FD %s:%d accept() = %" CURL_FORMAT_SOCKET_T "\n", 376 source, line, sockfd); 377 378 return sockfd; 379} 380 381/* separate function to allow libcurl to mark a "faked" close */ 382void curl_dbg_mark_sclose(curl_socket_t sockfd, int line, const char *source) 383{ 384 if(source) 385 curl_dbg_log("FD %s:%d sclose(%" CURL_FORMAT_SOCKET_T ")\n", 386 source, line, sockfd); 387} 388 389/* this is our own defined way to close sockets on *ALL* platforms */ 390int curl_dbg_sclose(curl_socket_t sockfd, int line, const char *source) 391{ 392 int res = sclose(sockfd); 393 curl_dbg_mark_sclose(sockfd, line, source); 394 return res; 395} 396 397ALLOC_FUNC FILE *curl_dbg_fopen(const char *file, const char *mode, 398 int line, const char *source) 399{ 400 FILE *res = fopen(file, mode); 401 402 if(source) 403 curl_dbg_log("FILE %s:%d fopen(\"%s\",\"%s\") = %p\n", 404 source, line, file, mode, (void *)res); 405 406 return res; 407} 408 409ALLOC_FUNC FILE *curl_dbg_fdopen(int filedes, const char *mode, 410 int line, const char *source) 411{ 412 FILE *res = fdopen(filedes, mode); 413 if(source) 414 curl_dbg_log("FILE %s:%d fdopen(\"%d\",\"%s\") = %p\n", 415 source, line, filedes, mode, (void *)res); 416 return res; 417} 418 419int curl_dbg_fclose(FILE *file, int line, const char *source) 420{ 421 int res; 422 423 DEBUGASSERT(file != NULL); 424 425 if(source) 426 curl_dbg_log("FILE %s:%d fclose(%p)\n", 427 source, line, (void *)file); 428 429 res = fclose(file); 430 431 return res; 432} 433 434#define LOGLINE_BUFSIZE 1024 435 436/* this does the writing to the memory tracking log file */ 437void curl_dbg_log(const char *format, ...) 438{ 439 char *buf; 440 int nchars; 441 va_list ap; 442 443 if(!curl_dbg_logfile) 444 return; 445 446 buf = (Curl_cmalloc)(LOGLINE_BUFSIZE); 447 if(!buf) 448 return; 449 450 va_start(ap, format); 451 nchars = mvsnprintf(buf, LOGLINE_BUFSIZE, format, ap); 452 va_end(ap); 453 454 if(nchars > LOGLINE_BUFSIZE - 1) 455 nchars = LOGLINE_BUFSIZE - 1; 456 457 if(nchars > 0) 458 fwrite(buf, 1, (size_t)nchars, curl_dbg_logfile); 459 460 (Curl_cfree)(buf); 461} 462 463#endif /* CURLDEBUG */ 464