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