lib/memdebug.c

   1 #ifdef CURLDEBUG
   2 /***************************************************************************
   3  *                                  _   _ ____  _
   4  *  Project                     ___| | | |  _ \| |
   5  *                             / __| | | | |_) | |
   6  *                            | (__| |_| |  _ <| |___
   7  *                             \___|\___/|_| \_\_____|
   8  *
   9  * Copyright (C) 1998 - 2004, Daniel Stenberg, <daniel@haxx.se>, et al.
  10  *
  11  * This software is licensed as described in the file COPYING, which
  12  * you should have received as part of this distribution. The terms
  13  * are also available at http://curl.haxx.se/docs/copyright.html.
  14  *
  15  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  16  * copies of the Software, and permit persons to whom the Software is
  17  * furnished to do so, under the terms of the COPYING file.
  18  *
  19  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  20  * KIND, either express or implied.
  21  *
  22  * $Id$
  23  ***************************************************************************/
  24
  25 #include "setup.h"
  26
  27 #include <curl/curl.h>
  28
  29 #ifdef HAVE_SYS_SOCKET_H
  30 #include <sys/socket.h>
  31 #endif
  32
  33 #define _MPRINTF_REPLACE
  34 #include <curl/mprintf.h>
  35 #include "urldata.h"
  36 #include <stdio.h>
  37 #include <string.h>
  38 #include <stdlib.h>
  39
  40 #ifdef HAVE_UNISTD_H
  41 #include <unistd.h>
  42 #endif
  43
  44 #define MEMDEBUG_NODEFINES /* don't redefine the standard functions */
  45 #include "memdebug.h"
  46
  47 struct memdebug {
  48   int size;
  49   double mem[1];
  50   /* I'm hoping this is the thing with the strictest alignment
  51    * requirements.  That also means we waste some space :-( */
  52 };
  53
  54 /*
  55  * Note that these debug functions are very simple and they are meant to
  56  * remain so. For advanced analysis, record a log file and write perl scripts
  57  * to analyze them!
  58  *
  59  * Don't use these with multithreaded test programs!
  60  */
  61
  62 #define logfile curl_debuglogfile
  63 FILE *curl_debuglogfile;
  64 static bool memlimit; /* enable memory limit */
  65 static long memsize;  /* set number of mallocs allowed */
  66
  67 /* this sets the log file name */
  68 void curl_memdebug(const char *logname)
  69 {
  70   if(logname)
  71     logfile = fopen(logname, "w");
  72   else
  73     logfile = stderr;
  74 }
  75
  76 /* This function sets the number of malloc() calls that should return
  77    successfully! */
  78 void curl_memlimit(long limit)
  79 {
  80   memlimit = TRUE;
  81   memsize = limit;
  82 }
  83
  84 /* returns TRUE if this isn't allowed! */
  85 static bool countcheck(const char *func, int line, const char *source)
  86 {
  87   /* if source is NULL, then the call is made internally and this check
  88      should not be made */
  89   if(memlimit && source) {
  90     if(!memsize) {
  91       if(logfile && source)
  92         fprintf(logfile, "LIMIT %s:%d %s reached memlimit\n",
  93                 source, line, func);
  94       return TRUE; /* RETURN ERROR! */
  95     }
  96     else
  97       memsize--; /* countdown */
  98
  99     /* log the countdown */
 100     if(logfile && source)
 101       fprintf(logfile, "LIMIT %s:%d %ld ALLOCS left\n",
 102               source, line, memsize);
 103
 104   }
 105
 106   return FALSE; /* allow this */
 107 }
 108
 109 void *curl_domalloc(size_t wantedsize, int line, const char *source)
 110 {
 111   struct memdebug *mem;
 112   size_t size;
 113
 114   if(countcheck("malloc", line, source))
 115     return NULL;
 116
 117   /* alloc at least 64 bytes */
 118   size = sizeof(struct memdebug)+wantedsize;
 119
 120   mem=(struct memdebug *)(malloc)(size);
 121   if(mem) {
 122     /* fill memory with junk */
 123     memset(mem->mem, 0xA5, wantedsize);
 124     mem->size = wantedsize;
 125   }
 126
 127   if(logfile && source)
 128     fprintf(logfile, "MEM %s:%d malloc(%d) = %p\n",
 129             source, line, wantedsize, mem->mem);
 130   return mem->mem;
 131 }
 132
 133 void *curl_docalloc(size_t wanted_elements, size_t wanted_size,
 134                     int line, const char *source)
 135 {
 136   struct memdebug *mem;
 137   size_t size, user_size;
 138
 139   if(countcheck("calloc", line, source))
 140     return NULL;
 141
 142   /* alloc at least 64 bytes */
 143   user_size = wanted_size * wanted_elements;
 144   size = sizeof(struct memdebug) + user_size;
 145
 146   mem = (struct memdebug *)(malloc)(size);
 147   if(mem) {
 148     /* fill memory with zeroes */
 149     memset(mem->mem, 0, user_size);
 150     mem->size = user_size;
 151   }
 152
 153   if(logfile && source)
 154     fprintf(logfile, "MEM %s:%d calloc(%u,%u) = %p\n",
 155             source, line, wanted_elements, wanted_size, mem->mem);
 156   return mem->mem;
 157 }
 158
 159 char *curl_dostrdup(const char *str, int line, const char *source)
 160 {
 161   char *mem;
 162   size_t len;
 163
 164   curlassert(str != NULL);
 165
 166   if(countcheck("strdup", line, source))
 167     return NULL;
 168
 169   len=strlen(str)+1;
 170
 171   mem=curl_domalloc(len, 0, NULL); /* NULL prevents logging */
 172   memcpy(mem, str, len);
 173
 174   if(logfile)
 175     fprintf(logfile, "MEM %s:%d strdup(%p) (%d) = %p\n",
 176             source, line, str, len, mem);
 177
 178   return mem;
 179 }
 180
 181 /* We provide a realloc() that accepts a NULL as pointer, which then
 182    performs a malloc(). In order to work with ares. */
 183 void *curl_dorealloc(void *ptr, size_t wantedsize,
 184                      int line, const char *source)
 185 {
 186   struct memdebug *mem=NULL;
 187
 188   size_t size = sizeof(struct memdebug)+wantedsize;
 189
 190   if(countcheck("realloc", line, source))
 191     return NULL;
 192
 193   if(ptr)
 194     mem = (struct memdebug *)((char *)ptr - offsetof(struct memdebug, mem));
 195
 196   mem=(struct memdebug *)(realloc)(mem, size);
 197   if(logfile)
 198     fprintf(logfile, "MEM %s:%d realloc(0x%x, %d) = %p\n",
 199             source, line, ptr, wantedsize, mem?mem->mem:NULL);
 200
 201   if(mem) {
 202     mem->size = wantedsize;
 203     return mem->mem;
 204   }
 205
 206   return NULL;
 207 }
 208
 209 void curl_dofree(void *ptr, int line, const char *source)
 210 {
 211   struct memdebug *mem;
 212
 213   curlassert(ptr != NULL);
 214
 215   mem = (struct memdebug *)((char *)ptr - offsetof(struct memdebug, mem));
 216
 217   /* destroy  */
 218   memset(mem->mem, 0x13, mem->size);
 219
 220   /* free for real */
 221   (free)(mem);
 222
 223   if(logfile)
 224     fprintf(logfile, "MEM %s:%d free(%p)\n", source, line, ptr);
 225 }
 226
 227 int curl_socket(int domain, int type, int protocol, int line,
 228                 const char *source)
 229 {
 230   int sockfd=(socket)(domain, type, protocol);
 231   if(logfile && (sockfd!=-1))
 232     fprintf(logfile, "FD %s:%d socket() = %d\n",
 233             source, line, sockfd);
 234   return sockfd;
 235 }
 236
 237 int curl_accept(int s, void *saddr, void *saddrlen,
 238                 int line, const char *source)
 239 {
 240   struct sockaddr *addr = (struct sockaddr *)saddr;
 241   socklen_t *addrlen = (socklen_t *)saddrlen;
 242   int sockfd=(accept)(s, addr, addrlen);
 243   if(logfile)
 244     fprintf(logfile, "FD %s:%d accept() = %d\n",
 245             source, line, sockfd);
 246   return sockfd;
 247 }
 248
 249 /* this is our own defined way to close sockets on *ALL* platforms */
 250 int curl_sclose(int sockfd, int line, const char *source)
 251 {
 252   int res=sclose(sockfd);
 253   if(logfile)
 254     fprintf(logfile, "FD %s:%d sclose(%d)\n",
 255             source, line, sockfd);
 256   return res;
 257 }
 258
 259 FILE *curl_fopen(const char *file, const char *mode,
 260                  int line, const char *source)
 261 {
 262   FILE *res=(fopen)(file, mode);
 263   if(logfile)
 264     fprintf(logfile, "FILE %s:%d fopen(\"%s\",\"%s\") = %p\n",
 265             source, line, file, mode, res);
 266   return res;
 267 }
 268
 269 int curl_fclose(FILE *file, int line, const char *source)
 270 {
 271   int res;
 272
 273   curlassert(file != NULL);
 274
 275   res=(fclose)(file);
 276   if(logfile)
 277     fprintf(logfile, "FILE %s:%d fclose(%p)\n",
 278             source, line, file);
 279   return res;
 280 }
 281 #else
 282 #ifdef VMS
 283 int VOID_VAR_MEMDEBUG;
 284 #else
 285 /* we provide a fake do-nothing function here to avoid compiler warnings */
 286 void curl_memdebug(void) {}
 287 #endif /* VMS */
 288 #endif /* CURLDEBUG */