misc.c

   1 #include <windows.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include "putty.h"
   5
   6 /*
   7  * My own versions of malloc, realloc and free. Because I want
   8  * malloc and realloc to bomb out and exit the program if they run
   9  * out of memory, realloc to reliably call malloc if passed a NULL
  10  * pointer, and free to reliably do nothing if passed a NULL
  11  * pointer. We can also put trace printouts in, if we need to; and
  12  * we can also replace the allocator with an ElectricFence-like
  13  * one.
  14  */
  15
  16 #ifdef MINEFIELD
  17 /*
  18  * Minefield - a Windows equivalent for Electric Fence
  19  */
  20
  21 #define PAGESIZE 4096
  22
  23 /*
  24  * Design:
  25  *
  26  * We start by reserving as much virtual address space as Windows
  27  * will sensibly (or not sensibly) let us have. We flag it all as
  28  * invalid memory.
  29  *
  30  * Any allocation attempt is satisfied by committing one or more
  31  * pages, with an uncommitted page on either side. The returned
  32  * memory region is jammed up against the _end_ of the pages.
  33  *
  34  * Freeing anything causes instantaneous decommitment of the pages
  35  * involved, so stale pointers are caught as soon as possible.
  36  */
  37
  38 static int minefield_initialised = 0;
  39 static void *minefield_region = NULL;
  40 static long minefield_size = 0;
  41 static long minefield_npages = 0;
  42 static long minefield_curpos = 0;
  43 static unsigned short *minefield_admin = NULL;
  44 static void *minefield_pages = NULL;
  45
  46 static void minefield_admin_hide(int hide)
  47 {
  48     int access = hide ? PAGE_NOACCESS : PAGE_READWRITE;
  49     VirtualProtect(minefield_admin, minefield_npages * 2, access, NULL);
  50 }
  51
  52 static void minefield_init(void)
  53 {
  54     int size;
  55     int admin_size;
  56     int i;
  57
  58     for (size = 0x40000000; size > 0; size = ((size >> 3) * 7) & ~0xFFF) {
  59         minefield_region = VirtualAlloc(NULL, size,
  60                                         MEM_RESERVE, PAGE_NOACCESS);
  61         if (minefield_region)
  62             break;
  63     }
  64     minefield_size = size;
  65
  66     /*
  67      * Firstly, allocate a section of that to be the admin block.
  68      * We'll need a two-byte field for each page.
  69      */
  70     minefield_admin = minefield_region;
  71     minefield_npages = minefield_size / PAGESIZE;
  72     admin_size = (minefield_npages * 2 + PAGESIZE - 1) & ~(PAGESIZE - 1);
  73     minefield_npages = (minefield_size - admin_size) / PAGESIZE;
  74     minefield_pages = (char *) minefield_region + admin_size;
  75
  76     /*
  77      * Commit the admin region.
  78      */
  79     VirtualAlloc(minefield_admin, minefield_npages * 2,
  80                  MEM_COMMIT, PAGE_READWRITE);
  81
  82     /*
  83      * Mark all pages as unused (0xFFFF).
  84      */
  85     for (i = 0; i < minefield_npages; i++)
  86         minefield_admin[i] = 0xFFFF;
  87
  88     /*
  89      * Hide the admin region.
  90      */
  91     minefield_admin_hide(1);
  92
  93     minefield_initialised = 1;
  94 }
  95
  96 static void minefield_bomb(void)
  97 {
  98     div(1, *(int *) minefield_pages);
  99 }
 100
 101 static void *minefield_alloc(int size)
 102 {
 103     int npages;
 104     int pos, lim, region_end, region_start;
 105     int start;
 106     int i;
 107
 108     npages = (size + PAGESIZE - 1) / PAGESIZE;
 109
 110     minefield_admin_hide(0);
 111
 112     /*
 113      * Search from current position until we find a contiguous
 114      * bunch of npages+2 unused pages.
 115      */
 116     pos = minefield_curpos;
 117     lim = minefield_npages;
 118     while (1) {
 119         /* Skip over used pages. */
 120         while (pos < lim && minefield_admin[pos] != 0xFFFF)
 121             pos++;
 122         /* Count unused pages. */
 123         start = pos;
 124         while (pos < lim && pos - start < npages + 2 &&
 125                minefield_admin[pos] == 0xFFFF)
 126             pos++;
 127         if (pos - start == npages + 2)
 128             break;
 129         /* If we've reached the limit, reset the limit or stop. */
 130         if (pos >= lim) {
 131             if (lim == minefield_npages) {
 132                 /* go round and start again at zero */
 133                 lim = minefield_curpos;
 134                 pos = 0;
 135             } else {
 136                 minefield_admin_hide(1);
 137                 return NULL;
 138             }
 139         }
 140     }
 141
 142     minefield_curpos = pos - 1;
 143
 144     /*
 145      * We have npages+2 unused pages starting at start. We leave
 146      * the first and last of these alone and use the rest.
 147      */
 148     region_end = (start + npages + 1) * PAGESIZE;
 149     region_start = region_end - size;
 150     /* FIXME: could align here if we wanted */
 151
 152     /*
 153      * Update the admin region.
 154      */
 155     for (i = start + 2; i < start + npages - 1; i++)
 156         minefield_admin[i] = 0xFFFE;   /* used but no region starts here */
 157     minefield_admin[start + 1] = region_start % PAGESIZE;
 158
 159     minefield_admin_hide(1);
 160
 161     VirtualAlloc((char *) minefield_pages + region_start, size,
 162                  MEM_COMMIT, PAGE_READWRITE);
 163     return (char *) minefield_pages + region_start;
 164 }
 165
 166 static void minefield_free(void *ptr)
 167 {
 168     int region_start, i, j;
 169
 170     minefield_admin_hide(0);
 171
 172     region_start = (char *) ptr - (char *) minefield_pages;
 173     i = region_start / PAGESIZE;
 174     if (i < 0 || i >= minefield_npages ||
 175         minefield_admin[i] != region_start % PAGESIZE)
 176         minefield_bomb();
 177     for (j = i; j < minefield_npages && minefield_admin[j] != 0xFFFF; j++) {
 178         minefield_admin[j] = 0xFFFF;
 179     }
 180
 181     VirtualFree(ptr, j * PAGESIZE - region_start, MEM_DECOMMIT);
 182
 183     minefield_admin_hide(1);
 184 }
 185
 186 static int minefield_get_size(void *ptr)
 187 {
 188     int region_start, i, j;
 189
 190     minefield_admin_hide(0);
 191
 192     region_start = (char *) ptr - (char *) minefield_pages;
 193     i = region_start / PAGESIZE;
 194     if (i < 0 || i >= minefield_npages ||
 195         minefield_admin[i] != region_start % PAGESIZE)
 196         minefield_bomb();
 197     for (j = i; j < minefield_npages && minefield_admin[j] != 0xFFFF; j++);
 198
 199     minefield_admin_hide(1);
 200
 201     return j * PAGESIZE - region_start;
 202 }
 203
 204 static void *minefield_c_malloc(size_t size)
 205 {
 206     if (!minefield_initialised)
 207         minefield_init();
 208     return minefield_alloc(size);
 209 }
 210
 211 static void minefield_c_free(void *p)
 212 {
 213     if (!minefield_initialised)
 214         minefield_init();
 215     minefield_free(p);
 216 }
 217
 218 /*
 219  * realloc _always_ moves the chunk, for rapid detection of code
 220  * that assumes it won't.
 221  */
 222 static void *minefield_c_realloc(void *p, size_t size)
 223 {
 224     size_t oldsize;
 225     void *q;
 226     if (!minefield_initialised)
 227         minefield_init();
 228     q = minefield_alloc(size);
 229     oldsize = minefield_get_size(p);
 230     memcpy(q, p, (oldsize < size ? oldsize : size));
 231     minefield_free(p);
 232     return q;
 233 }
 234
 235 #endif                          /* MINEFIELD */
 236
 237 #ifdef MALLOC_LOG
 238 static FILE *fp = NULL;
 239
 240 void mlog(char *file, int line)
 241 {
 242     if (!fp) {
 243         fp = fopen("putty_mem.log", "w");
 244         setvbuf(fp, NULL, _IONBF, BUFSIZ);
 245     }
 246     if (fp)
 247         fprintf(fp, "%s:%d: ", file, line);
 248 }
 249 #endif
 250
 251 void *safemalloc(size_t size)
 252 {
 253     void *p;
 254 #ifdef MINEFIELD
 255     p = minefield_c_malloc(size);
 256 #else
 257     p = malloc(size);
 258 #endif
 259     if (!p) {
 260         MessageBox(NULL, "Out of memory!", "PuTTY Fatal Error",
 261                    MB_SYSTEMMODAL | MB_ICONERROR | MB_OK);
 262         exit(1);
 263     }
 264 #ifdef MALLOC_LOG
 265     if (fp)
 266         fprintf(fp, "malloc(%d) returns %p\n", size, p);
 267 #endif
 268     return p;
 269 }
 270
 271 void *saferealloc(void *ptr, size_t size)
 272 {
 273     void *p;
 274     if (!ptr) {
 275 #ifdef MINEFIELD
 276         p = minefield_c_malloc(size);
 277 #else
 278         p = malloc(size);
 279 #endif
 280     } else {
 281 #ifdef MINEFIELD
 282         p = minefield_c_realloc(ptr, size);
 283 #else
 284         p = realloc(ptr, size);
 285 #endif
 286     }
 287     if (!p) {
 288         MessageBox(NULL, "Out of memory!", "PuTTY Fatal Error",
 289                    MB_SYSTEMMODAL | MB_ICONERROR | MB_OK);
 290         exit(1);
 291     }
 292 #ifdef MALLOC_LOG
 293     if (fp)
 294         fprintf(fp, "realloc(%p,%d) returns %p\n", ptr, size, p);
 295 #endif
 296     return p;
 297 }
 298
 299 void safefree(void *ptr)
 300 {
 301     if (ptr) {
 302 #ifdef MALLOC_LOG
 303         if (fp)
 304             fprintf(fp, "free(%p)\n", ptr);
 305 #endif
 306 #ifdef MINEFIELD
 307         minefield_c_free(ptr);
 308 #else
 309         free(ptr);
 310 #endif
 311     }
 312 #ifdef MALLOC_LOG
 313     else if (fp)
 314         fprintf(fp, "freeing null pointer - no action taken\n");
 315 #endif
 316 }
 317
 318 #ifdef DEBUG
 319 static FILE *debug_fp = NULL;
 320 static int debug_got_console = 0;
 321
 322 static void dputs(char *buf)
 323 {
 324     DWORD dw;
 325
 326     if (!debug_got_console) {
 327         AllocConsole();
 328         debug_got_console = 1;
 329     }
 330     if (!debug_fp) {
 331         debug_fp = fopen("debug.log", "w");
 332     }
 333
 334     WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buf, strlen(buf), &dw,
 335               NULL);
 336     fputs(buf, debug_fp);
 337     fflush(debug_fp);
 338 }
 339
 340
 341 void dprintf(char *fmt, ...)
 342 {
 343     char buf[2048];
 344     va_list ap;
 345
 346     va_start(ap, fmt);
 347     vsprintf(buf, fmt, ap);
 348     dputs(buf);
 349     va_end(ap);
 350 }
 351
 352
 353 void debug_memdump(void *buf, int len, int L)
 354 {
 355     int i;
 356     unsigned char *p = buf;
 357     char foo[17];
 358     if (L) {
 359         int delta;
 360         dprintf("\t%d (0x%x) bytes:\n", len, len);
 361         delta = 15 & (int) p;
 362         p -= delta;
 363         len += delta;
 364     }
 365     for (; 0 < len; p += 16, len -= 16) {
 366         dputs("  ");
 367         if (L)
 368             dprintf("%p: ", p);
 369         strcpy(foo, "................");        /* sixteen dots */
 370         for (i = 0; i < 16 && i < len; ++i) {
 371             if (&p[i] < (unsigned char *) buf) {
 372                 dputs("   ");          /* 3 spaces */
 373                 foo[i] = ' ';
 374             } else {
 375                 dprintf("%c%02.2x",
 376                         &p[i] != (unsigned char *) buf
 377                         && i % 4 ? '.' : ' ', p[i]
 378                     );
 379                 if (p[i] >= ' ' && p[i] <= '~')
 380                     foo[i] = (char) p[i];
 381             }
 382         }
 383         foo[i] = '\0';
 384         dprintf("%*s%s\n", (16 - i) * 3 + 2, "", foo);
 385     }
 386 }
 387
 388 #endif                          /* def DEBUG */