misc.c

   1 #include <windows.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <assert.h>
   5 #include "putty.h"
   6
   7 /* ----------------------------------------------------------------------
   8  * String handling routines.
   9  */
  10
  11 char *dupstr(char *s)
  12 {
  13     int len = strlen(s);
  14     char *p = smalloc(len + 1);
  15     strcpy(p, s);
  16     return p;
  17 }
  18
  19 /* Allocate the concatenation of N strings. Terminate arg list with NULL. */
  20 char *dupcat(char *s1, ...)
  21 {
  22     int len;
  23     char *p, *q, *sn;
  24     va_list ap;
  25
  26     len = strlen(s1);
  27     va_start(ap, s1);
  28     while (1) {
  29         sn = va_arg(ap, char *);
  30         if (!sn)
  31             break;
  32         len += strlen(sn);
  33     }
  34     va_end(ap);
  35
  36     p = smalloc(len + 1);
  37     strcpy(p, s1);
  38     q = p + strlen(p);
  39
  40     va_start(ap, s1);
  41     while (1) {
  42         sn = va_arg(ap, char *);
  43         if (!sn)
  44             break;
  45         strcpy(q, sn);
  46         q += strlen(q);
  47     }
  48     va_end(ap);
  49
  50     return p;
  51 }
  52
  53 /* ----------------------------------------------------------------------
  54  * Generic routines to deal with send buffers: a linked list of
  55  * smallish blocks, with the operations
  56  *
  57  *  - add an arbitrary amount of data to the end of the list
  58  *  - remove the first N bytes from the list
  59  *  - return a (pointer,length) pair giving some initial data in
  60  *    the list, suitable for passing to a send or write system
  61  *    call
  62  *  - return the current size of the buffer chain in bytes
  63  */
  64
  65 #define BUFFER_GRANULE  512
  66
  67 struct bufchain_granule {
  68     struct bufchain_granule *next;
  69     int buflen, bufpos;
  70     char buf[BUFFER_GRANULE];
  71 };
  72
  73 void bufchain_init(bufchain *ch)
  74 {
  75     ch->head = ch->tail = NULL;
  76     ch->buffersize = 0;
  77 }
  78
  79 void bufchain_clear(bufchain *ch)
  80 {
  81     struct bufchain_granule *b;
  82     while (ch->head) {
  83         b = ch->head;
  84         ch->head = ch->head->next;
  85         sfree(b);
  86     }
  87     ch->tail = NULL;
  88     ch->buffersize = 0;
  89 }
  90
  91 int bufchain_size(bufchain *ch)
  92 {
  93     return ch->buffersize;
  94 }
  95
  96 void bufchain_add(bufchain *ch, void *data, int len)
  97 {
  98     char *buf = (char *)data;
  99
 100     ch->buffersize += len;
 101
 102     if (ch->tail && ch->tail->buflen < BUFFER_GRANULE) {
 103         int copylen = min(len, BUFFER_GRANULE - ch->tail->buflen);
 104         memcpy(ch->tail->buf + ch->tail->buflen, buf, copylen);
 105         buf += copylen;
 106         len -= copylen;
 107         ch->tail->buflen += copylen;
 108     }
 109     while (len > 0) {
 110         int grainlen = min(len, BUFFER_GRANULE);
 111         struct bufchain_granule *newbuf;
 112         newbuf = smalloc(sizeof(struct bufchain_granule));
 113         newbuf->bufpos = 0;
 114         newbuf->buflen = grainlen;
 115         memcpy(newbuf->buf, buf, grainlen);
 116         buf += grainlen;
 117         len -= grainlen;
 118         if (ch->tail)
 119             ch->tail->next = newbuf;
 120         else
 121             ch->head = ch->tail = newbuf;
 122         newbuf->next = NULL;
 123         ch->tail = newbuf;
 124     }
 125 }
 126
 127 void bufchain_consume(bufchain *ch, int len)
 128 {
 129     assert(ch->buffersize >= len);
 130     assert(ch->head != NULL && ch->head->bufpos + len <= ch->head->buflen);
 131     ch->head->bufpos += len;
 132     ch->buffersize -= len;
 133     if (ch->head->bufpos >= ch->head->buflen) {
 134         struct bufchain_granule *tmp = ch->head;
 135         ch->head = tmp->next;
 136         sfree(tmp);
 137         if (!ch->head)
 138             ch->tail = NULL;
 139     }
 140 }
 141
 142 void bufchain_prefix(bufchain *ch, void **data, int *len)
 143 {
 144     *len = ch->head->buflen - ch->head->bufpos;
 145     *data = ch->head->buf + ch->head->bufpos;
 146 }
 147
 148 /* ----------------------------------------------------------------------
 149  * My own versions of malloc, realloc and free. Because I want
 150  * malloc and realloc to bomb out and exit the program if they run
 151  * out of memory, realloc to reliably call malloc if passed a NULL
 152  * pointer, and free to reliably do nothing if passed a NULL
 153  * pointer. We can also put trace printouts in, if we need to; and
 154  * we can also replace the allocator with an ElectricFence-like
 155  * one.
 156  */
 157
 158 #ifdef MINEFIELD
 159 /*
 160  * Minefield - a Windows equivalent for Electric Fence
 161  */
 162
 163 #define PAGESIZE 4096
 164
 165 /*
 166  * Design:
 167  *
 168  * We start by reserving as much virtual address space as Windows
 169  * will sensibly (or not sensibly) let us have. We flag it all as
 170  * invalid memory.
 171  *
 172  * Any allocation attempt is satisfied by committing one or more
 173  * pages, with an uncommitted page on either side. The returned
 174  * memory region is jammed up against the _end_ of the pages.
 175  *
 176  * Freeing anything causes instantaneous decommitment of the pages
 177  * involved, so stale pointers are caught as soon as possible.
 178  */
 179
 180 static int minefield_initialised = 0;
 181 static void *minefield_region = NULL;
 182 static long minefield_size = 0;
 183 static long minefield_npages = 0;
 184 static long minefield_curpos = 0;
 185 static unsigned short *minefield_admin = NULL;
 186 static void *minefield_pages = NULL;
 187
 188 static void minefield_admin_hide(int hide)
 189 {
 190     int access = hide ? PAGE_NOACCESS : PAGE_READWRITE;
 191     VirtualProtect(minefield_admin, minefield_npages * 2, access, NULL);
 192 }
 193
 194 static void minefield_init(void)
 195 {
 196     int size;
 197     int admin_size;
 198     int i;
 199
 200     for (size = 0x40000000; size > 0; size = ((size >> 3) * 7) & ~0xFFF) {
 201         minefield_region = VirtualAlloc(NULL, size,
 202                                         MEM_RESERVE, PAGE_NOACCESS);
 203         if (minefield_region)
 204             break;
 205     }
 206     minefield_size = size;
 207
 208     /*
 209      * Firstly, allocate a section of that to be the admin block.
 210      * We'll need a two-byte field for each page.
 211      */
 212     minefield_admin = minefield_region;
 213     minefield_npages = minefield_size / PAGESIZE;
 214     admin_size = (minefield_npages * 2 + PAGESIZE - 1) & ~(PAGESIZE - 1);
 215     minefield_npages = (minefield_size - admin_size) / PAGESIZE;
 216     minefield_pages = (char *) minefield_region + admin_size;
 217
 218     /*
 219      * Commit the admin region.
 220      */
 221     VirtualAlloc(minefield_admin, minefield_npages * 2,
 222                  MEM_COMMIT, PAGE_READWRITE);
 223
 224     /*
 225      * Mark all pages as unused (0xFFFF).
 226      */
 227     for (i = 0; i < minefield_npages; i++)
 228         minefield_admin[i] = 0xFFFF;
 229
 230     /*
 231      * Hide the admin region.
 232      */
 233     minefield_admin_hide(1);
 234
 235     minefield_initialised = 1;
 236 }
 237
 238 static void minefield_bomb(void)
 239 {
 240     div(1, *(int *) minefield_pages);
 241 }
 242
 243 static void *minefield_alloc(int size)
 244 {
 245     int npages;
 246     int pos, lim, region_end, region_start;
 247     int start;
 248     int i;
 249
 250     npages = (size + PAGESIZE - 1) / PAGESIZE;
 251
 252     minefield_admin_hide(0);
 253
 254     /*
 255      * Search from current position until we find a contiguous
 256      * bunch of npages+2 unused pages.
 257      */
 258     pos = minefield_curpos;
 259     lim = minefield_npages;
 260     while (1) {
 261         /* Skip over used pages. */
 262         while (pos < lim && minefield_admin[pos] != 0xFFFF)
 263             pos++;
 264         /* Count unused pages. */
 265         start = pos;
 266         while (pos < lim && pos - start < npages + 2 &&
 267                minefield_admin[pos] == 0xFFFF)
 268             pos++;
 269         if (pos - start == npages + 2)
 270             break;
 271         /* If we've reached the limit, reset the limit or stop. */
 272         if (pos >= lim) {
 273             if (lim == minefield_npages) {
 274                 /* go round and start again at zero */
 275                 lim = minefield_curpos;
 276                 pos = 0;
 277             } else {
 278                 minefield_admin_hide(1);
 279                 return NULL;
 280             }
 281         }
 282     }
 283
 284     minefield_curpos = pos - 1;
 285
 286     /*
 287      * We have npages+2 unused pages starting at start. We leave
 288      * the first and last of these alone and use the rest.
 289      */
 290     region_end = (start + npages + 1) * PAGESIZE;
 291     region_start = region_end - size;
 292     /* FIXME: could align here if we wanted */
 293
 294     /*
 295      * Update the admin region.
 296      */
 297     for (i = start + 2; i < start + npages - 1; i++)
 298         minefield_admin[i] = 0xFFFE;   /* used but no region starts here */
 299     minefield_admin[start + 1] = region_start % PAGESIZE;
 300
 301     minefield_admin_hide(1);
 302
 303     VirtualAlloc((char *) minefield_pages + region_start, size,
 304                  MEM_COMMIT, PAGE_READWRITE);
 305     return (char *) minefield_pages + region_start;
 306 }
 307
 308 static void minefield_free(void *ptr)
 309 {
 310     int region_start, i, j;
 311
 312     minefield_admin_hide(0);
 313
 314     region_start = (char *) ptr - (char *) minefield_pages;
 315     i = region_start / PAGESIZE;
 316     if (i < 0 || i >= minefield_npages ||
 317         minefield_admin[i] != region_start % PAGESIZE)
 318         minefield_bomb();
 319     for (j = i; j < minefield_npages && minefield_admin[j] != 0xFFFF; j++) {
 320         minefield_admin[j] = 0xFFFF;
 321     }
 322
 323     VirtualFree(ptr, j * PAGESIZE - region_start, MEM_DECOMMIT);
 324
 325     minefield_admin_hide(1);
 326 }
 327
 328 static int minefield_get_size(void *ptr)
 329 {
 330     int region_start, i, j;
 331
 332     minefield_admin_hide(0);
 333
 334     region_start = (char *) ptr - (char *) minefield_pages;
 335     i = region_start / PAGESIZE;
 336     if (i < 0 || i >= minefield_npages ||
 337         minefield_admin[i] != region_start % PAGESIZE)
 338         minefield_bomb();
 339     for (j = i; j < minefield_npages && minefield_admin[j] != 0xFFFF; j++);
 340
 341     minefield_admin_hide(1);
 342
 343     return j * PAGESIZE - region_start;
 344 }
 345
 346 static void *minefield_c_malloc(size_t size)
 347 {
 348     if (!minefield_initialised)
 349         minefield_init();
 350     return minefield_alloc(size);
 351 }
 352
 353 static void minefield_c_free(void *p)
 354 {
 355     if (!minefield_initialised)
 356         minefield_init();
 357     minefield_free(p);
 358 }
 359
 360 /*
 361  * realloc _always_ moves the chunk, for rapid detection of code
 362  * that assumes it won't.
 363  */
 364 static void *minefield_c_realloc(void *p, size_t size)
 365 {
 366     size_t oldsize;
 367     void *q;
 368     if (!minefield_initialised)
 369         minefield_init();
 370     q = minefield_alloc(size);
 371     oldsize = minefield_get_size(p);
 372     memcpy(q, p, (oldsize < size ? oldsize : size));
 373     minefield_free(p);
 374     return q;
 375 }
 376
 377 #endif                          /* MINEFIELD */
 378
 379 #ifdef MALLOC_LOG
 380 static FILE *fp = NULL;
 381
 382 void mlog(char *file, int line)
 383 {
 384     if (!fp) {
 385         fp = fopen("putty_mem.log", "w");
 386         setvbuf(fp, NULL, _IONBF, BUFSIZ);
 387     }
 388     if (fp)
 389         fprintf(fp, "%s:%d: ", file, line);
 390 }
 391 #endif
 392
 393 void *safemalloc(size_t size)
 394 {
 395     void *p;
 396 #ifdef MINEFIELD
 397     p = minefield_c_malloc(size);
 398 #else
 399     p = malloc(size);
 400 #endif
 401     if (!p) {
 402         MessageBox(NULL, "Out of memory!", "PuTTY Fatal Error",
 403                    MB_SYSTEMMODAL | MB_ICONERROR | MB_OK);
 404         exit(1);
 405     }
 406 #ifdef MALLOC_LOG
 407     if (fp)
 408         fprintf(fp, "malloc(%d) returns %p\n", size, p);
 409 #endif
 410     return p;
 411 }
 412
 413 void *saferealloc(void *ptr, size_t size)
 414 {
 415     void *p;
 416     if (!ptr) {
 417 #ifdef MINEFIELD
 418         p = minefield_c_malloc(size);
 419 #else
 420         p = malloc(size);
 421 #endif
 422     } else {
 423 #ifdef MINEFIELD
 424         p = minefield_c_realloc(ptr, size);
 425 #else
 426         p = realloc(ptr, size);
 427 #endif
 428     }
 429     if (!p) {
 430         MessageBox(NULL, "Out of memory!", "PuTTY Fatal Error",
 431                    MB_SYSTEMMODAL | MB_ICONERROR | MB_OK);
 432         exit(1);
 433     }
 434 #ifdef MALLOC_LOG
 435     if (fp)
 436         fprintf(fp, "realloc(%p,%d) returns %p\n", ptr, size, p);
 437 #endif
 438     return p;
 439 }
 440
 441 void safefree(void *ptr)
 442 {
 443     if (ptr) {
 444 #ifdef MALLOC_LOG
 445         if (fp)
 446             fprintf(fp, "free(%p)\n", ptr);
 447 #endif
 448 #ifdef MINEFIELD
 449         minefield_c_free(ptr);
 450 #else
 451         free(ptr);
 452 #endif
 453     }
 454 #ifdef MALLOC_LOG
 455     else if (fp)
 456         fprintf(fp, "freeing null pointer - no action taken\n");
 457 #endif
 458 }
 459
 460 /* ----------------------------------------------------------------------
 461  * Debugging routines.
 462  */
 463
 464 #ifdef DEBUG
 465 static FILE *debug_fp = NULL;
 466 static int debug_got_console = 0;
 467
 468 static void dputs(char *buf)
 469 {
 470     DWORD dw;
 471
 472     if (!debug_got_console) {
 473         AllocConsole();
 474         debug_got_console = 1;
 475     }
 476     if (!debug_fp) {
 477         debug_fp = fopen("debug.log", "w");
 478     }
 479
 480     WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buf, strlen(buf), &dw,
 481               NULL);
 482     fputs(buf, debug_fp);
 483     fflush(debug_fp);
 484 }
 485
 486
 487 void dprintf(char *fmt, ...)
 488 {
 489     char buf[2048];
 490     va_list ap;
 491
 492     va_start(ap, fmt);
 493     vsprintf(buf, fmt, ap);
 494     dputs(buf);
 495     va_end(ap);
 496 }
 497
 498
 499 void debug_memdump(void *buf, int len, int L)
 500 {
 501     int i;
 502     unsigned char *p = buf;
 503     char foo[17];
 504     if (L) {
 505         int delta;
 506         dprintf("\t%d (0x%x) bytes:\n", len, len);
 507         delta = 15 & (int) p;
 508         p -= delta;
 509         len += delta;
 510     }
 511     for (; 0 < len; p += 16, len -= 16) {
 512         dputs("  ");
 513         if (L)
 514             dprintf("%p: ", p);
 515         strcpy(foo, "................");        /* sixteen dots */
 516         for (i = 0; i < 16 && i < len; ++i) {
 517             if (&p[i] < (unsigned char *) buf) {
 518                 dputs("   ");          /* 3 spaces */
 519                 foo[i] = ' ';
 520             } else {
 521                 dprintf("%c%02.2x",
 522                         &p[i] != (unsigned char *) buf
 523                         && i % 4 ? '.' : ' ', p[i]
 524                     );
 525                 if (p[i] >= ' ' && p[i] <= '~')
 526                     foo[i] = (char) p[i];
 527             }
 528         }
 529         foo[i] = '\0';
 530         dprintf("%*s%s\n", (16 - i) * 3 + 2, "", foo);
 531     }
 532 }
 533
 534 #endif                          /* def DEBUG */