[u/mdw/putty] / misc.c

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "putty.h"

/* ----------------------------------------------------------------------
 * String handling routines.
 */

char *dupstr(char *s)
{
    int len = strlen(s);
    char *p = smalloc(len + 1);
    strcpy(p, s);
    return p;
}

/* Allocate the concatenation of N strings. Terminate arg list with NULL. */
char *dupcat(char *s1, ...)
{
    int len;
    char *p, *q, *sn;
    va_list ap;

    len = strlen(s1);
    va_start(ap, s1);
    while (1) {
	sn = va_arg(ap, char *);
	if (!sn)
	    break;
	len += strlen(sn);
    }
    va_end(ap);

    p = smalloc(len + 1);
    strcpy(p, s1);
    q = p + strlen(p);

    va_start(ap, s1);
    while (1) {
	sn = va_arg(ap, char *);
	if (!sn)
	    break;
	strcpy(q, sn);
	q += strlen(q);
    }
    va_end(ap);

    return p;
}

/* ----------------------------------------------------------------------
 * Generic routines to deal with send buffers: a linked list of
 * smallish blocks, with the operations
 * 
 *  - add an arbitrary amount of data to the end of the list
 *  - remove the first N bytes from the list
 *  - return a (pointer,length) pair giving some initial data in
 *    the list, suitable for passing to a send or write system
 *    call
 *  - return the current size of the buffer chain in bytes
 */

#define BUFFER_GRANULE  512

struct bufchain_granule {
    struct bufchain_granule *next;
    int buflen, bufpos;
    char buf[BUFFER_GRANULE];
};

void bufchain_init(bufchain *ch)
{
    ch->head = ch->tail = NULL;
    ch->buffersize = 0;
}

void bufchain_clear(bufchain *ch)
{
    struct bufchain_granule *b;
    while (ch->head) {
	b = ch->head;
	ch->head = ch->head->next;
	sfree(b);
    }
    ch->tail = NULL;
    ch->buffersize = 0;
}

int bufchain_size(bufchain *ch)
{
    return ch->buffersize;
}

void bufchain_add(bufchain *ch, void *data, int len)
{
    char *buf = (char *)data;

    ch->buffersize += len;

    if (ch->tail && ch->tail->buflen < BUFFER_GRANULE) {
	int copylen = min(len, BUFFER_GRANULE - ch->tail->buflen);
	memcpy(ch->tail->buf + ch->tail->buflen, buf, copylen);
	buf += copylen;
	len -= copylen;
	ch->tail->buflen += copylen;
    }
    while (len > 0) {
	int grainlen = min(len, BUFFER_GRANULE);
	struct bufchain_granule *newbuf;
	newbuf = smalloc(sizeof(struct bufchain_granule));
	newbuf->bufpos = 0;
	newbuf->buflen = grainlen;
	memcpy(newbuf->buf, buf, grainlen);
	buf += grainlen;
	len -= grainlen;
	if (ch->tail)
	    ch->tail->next = newbuf;
	else
	    ch->head = ch->tail = newbuf;
	newbuf->next = NULL;
	ch->tail = newbuf;
    }
}

void bufchain_consume(bufchain *ch, int len)
{
    assert(ch->buffersize >= len);
    assert(ch->head != NULL && ch->head->bufpos + len <= ch->head->buflen);
    ch->head->bufpos += len;
    ch->buffersize -= len;
    if (ch->head->bufpos >= ch->head->buflen) {
	struct bufchain_granule *tmp = ch->head;
	ch->head = tmp->next;
	sfree(tmp);
	if (!ch->head)
	    ch->tail = NULL;
    }
}

void bufchain_prefix(bufchain *ch, void **data, int *len)
{
    *len = ch->head->buflen - ch->head->bufpos;
    *data = ch->head->buf + ch->head->bufpos;
}

/* ----------------------------------------------------------------------
 * My own versions of malloc, realloc and free. Because I want
 * malloc and realloc to bomb out and exit the program if they run
 * out of memory, realloc to reliably call malloc if passed a NULL
 * pointer, and free to reliably do nothing if passed a NULL
 * pointer. We can also put trace printouts in, if we need to; and
 * we can also replace the allocator with an ElectricFence-like
 * one.
 */

#ifdef MINEFIELD
/*
 * Minefield - a Windows equivalent for Electric Fence
 */

#define PAGESIZE 4096

/*
 * Design:
 * 
 * We start by reserving as much virtual address space as Windows
 * will sensibly (or not sensibly) let us have. We flag it all as
 * invalid memory.
 * 
 * Any allocation attempt is satisfied by committing one or more
 * pages, with an uncommitted page on either side. The returned
 * memory region is jammed up against the _end_ of the pages.
 * 
 * Freeing anything causes instantaneous decommitment of the pages
 * involved, so stale pointers are caught as soon as possible.
 */

static int minefield_initialised = 0;
static void *minefield_region = NULL;
static long minefield_size = 0;
static long minefield_npages = 0;
static long minefield_curpos = 0;
static unsigned short *minefield_admin = NULL;
static void *minefield_pages = NULL;

static void minefield_admin_hide(int hide)
{
    int access = hide ? PAGE_NOACCESS : PAGE_READWRITE;
    VirtualProtect(minefield_admin, minefield_npages * 2, access, NULL);
}

static void minefield_init(void)
{
    int size;
    int admin_size;
    int i;

    for (size = 0x40000000; size > 0; size = ((size >> 3) * 7) & ~0xFFF) {
	minefield_region = VirtualAlloc(NULL, size,
					MEM_RESERVE, PAGE_NOACCESS);
	if (minefield_region)
	    break;
    }
    minefield_size = size;

    /*
     * Firstly, allocate a section of that to be the admin block.
     * We'll need a two-byte field for each page.
     */
    minefield_admin = minefield_region;
    minefield_npages = minefield_size / PAGESIZE;
    admin_size = (minefield_npages * 2 + PAGESIZE - 1) & ~(PAGESIZE - 1);
    minefield_npages = (minefield_size - admin_size) / PAGESIZE;
    minefield_pages = (char *) minefield_region + admin_size;

    /*
     * Commit the admin region.
     */
    VirtualAlloc(minefield_admin, minefield_npages * 2,
		 MEM_COMMIT, PAGE_READWRITE);

    /*
     * Mark all pages as unused (0xFFFF).
     */
    for (i = 0; i < minefield_npages; i++)
	minefield_admin[i] = 0xFFFF;

    /*
     * Hide the admin region.
     */
    minefield_admin_hide(1);

    minefield_initialised = 1;
}

static void minefield_bomb(void)
{
    div(1, *(int *) minefield_pages);
}

static void *minefield_alloc(int size)
{
    int npages;
    int pos, lim, region_end, region_start;
    int start;
    int i;

    npages = (size + PAGESIZE - 1) / PAGESIZE;

    minefield_admin_hide(0);

    /*
     * Search from current position until we find a contiguous
     * bunch of npages+2 unused pages.
     */
    pos = minefield_curpos;
    lim = minefield_npages;
    while (1) {
	/* Skip over used pages. */
	while (pos < lim && minefield_admin[pos] != 0xFFFF)
	    pos++;
	/* Count unused pages. */
	start = pos;
	while (pos < lim && pos - start < npages + 2 &&
	       minefield_admin[pos] == 0xFFFF)
	    pos++;
	if (pos - start == npages + 2)
	    break;
	/* If we've reached the limit, reset the limit or stop. */
	if (pos >= lim) {
	    if (lim == minefield_npages) {
		/* go round and start again at zero */
		lim = minefield_curpos;
		pos = 0;
	    } else {
		minefield_admin_hide(1);
		return NULL;
	    }
	}
    }

    minefield_curpos = pos - 1;

    /*
     * We have npages+2 unused pages starting at start. We leave
     * the first and last of these alone and use the rest.
     */
    region_end = (start + npages + 1) * PAGESIZE;
    region_start = region_end - size;
    /* FIXME: could align here if we wanted */

    /*
     * Update the admin region.
     */
    for (i = start + 2; i < start + npages - 1; i++)
	minefield_admin[i] = 0xFFFE;   /* used but no region starts here */
    minefield_admin[start + 1] = region_start % PAGESIZE;

    minefield_admin_hide(1);

    VirtualAlloc((char *) minefield_pages + region_start, size,
		 MEM_COMMIT, PAGE_READWRITE);
    return (char *) minefield_pages + region_start;
}

static void minefield_free(void *ptr)
{
    int region_start, i, j;

    minefield_admin_hide(0);

    region_start = (char *) ptr - (char *) minefield_pages;
    i = region_start / PAGESIZE;
    if (i < 0 || i >= minefield_npages ||
	minefield_admin[i] != region_start % PAGESIZE)
	minefield_bomb();
    for (j = i; j < minefield_npages && minefield_admin[j] != 0xFFFF; j++) {
	minefield_admin[j] = 0xFFFF;
    }

    VirtualFree(ptr, j * PAGESIZE - region_start, MEM_DECOMMIT);

    minefield_admin_hide(1);
}

static int minefield_get_size(void *ptr)
{
    int region_start, i, j;

    minefield_admin_hide(0);

    region_start = (char *) ptr - (char *) minefield_pages;
    i = region_start / PAGESIZE;
    if (i < 0 || i >= minefield_npages ||
	minefield_admin[i] != region_start % PAGESIZE)
	minefield_bomb();
    for (j = i; j < minefield_npages && minefield_admin[j] != 0xFFFF; j++);

    minefield_admin_hide(1);

    return j * PAGESIZE - region_start;
}

static void *minefield_c_malloc(size_t size)
{
    if (!minefield_initialised)
	minefield_init();
    return minefield_alloc(size);
}

static void minefield_c_free(void *p)
{
    if (!minefield_initialised)
	minefield_init();
    minefield_free(p);
}

/*
 * realloc _always_ moves the chunk, for rapid detection of code
 * that assumes it won't.
 */
static void *minefield_c_realloc(void *p, size_t size)
{
    size_t oldsize;
    void *q;
    if (!minefield_initialised)
	minefield_init();
    q = minefield_alloc(size);
    oldsize = minefield_get_size(p);
    memcpy(q, p, (oldsize < size ? oldsize : size));
    minefield_free(p);
    return q;
}

#endif				/* MINEFIELD */

#ifdef MALLOC_LOG
static FILE *fp = NULL;

void mlog(char *file, int line)
{
    if (!fp) {
	fp = fopen("putty_mem.log", "w");
	setvbuf(fp, NULL, _IONBF, BUFSIZ);
    }
    if (fp)
	fprintf(fp, "%s:%d: ", file, line);
}
#endif

void *safemalloc(size_t size)
{
    void *p;
#ifdef MINEFIELD
    p = minefield_c_malloc(size);
#else
    p = malloc(size);
#endif
    if (!p) {
	MessageBox(NULL, "Out of memory!", "PuTTY Fatal Error",
		   MB_SYSTEMMODAL | MB_ICONERROR | MB_OK);
	exit(1);
    }
#ifdef MALLOC_LOG
    if (fp)
	fprintf(fp, "malloc(%d) returns %p\n", size, p);
#endif
    return p;
}

void *saferealloc(void *ptr, size_t size)
{
    void *p;
    if (!ptr) {
#ifdef MINEFIELD
	p = minefield_c_malloc(size);
#else
	p = malloc(size);
#endif
    } else {
#ifdef MINEFIELD
	p = minefield_c_realloc(ptr, size);
#else
	p = realloc(ptr, size);
#endif
    }
    if (!p) {
	MessageBox(NULL, "Out of memory!", "PuTTY Fatal Error",
		   MB_SYSTEMMODAL | MB_ICONERROR | MB_OK);
	exit(1);
    }
#ifdef MALLOC_LOG
    if (fp)
	fprintf(fp, "realloc(%p,%d) returns %p\n", ptr, size, p);
#endif
    return p;
}

void safefree(void *ptr)
{
    if (ptr) {
#ifdef MALLOC_LOG
	if (fp)
	    fprintf(fp, "free(%p)\n", ptr);
#endif
#ifdef MINEFIELD
	minefield_c_free(ptr);
#else
	free(ptr);
#endif
    }
#ifdef MALLOC_LOG
    else if (fp)
	fprintf(fp, "freeing null pointer - no action taken\n");
#endif
}

/* ----------------------------------------------------------------------
 * Debugging routines.
 */

#ifdef DEBUG
static FILE *debug_fp = NULL;
static int debug_got_console = 0;

static void dputs(char *buf)
{
    DWORD dw;

    if (!debug_got_console) {
	AllocConsole();
	debug_got_console = 1;
    }
    if (!debug_fp) {
	debug_fp = fopen("debug.log", "w");
    }

    WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buf, strlen(buf), &dw,
	      NULL);
    fputs(buf, debug_fp);
    fflush(debug_fp);
}


void dprintf(char *fmt, ...)
{
    char buf[2048];
    va_list ap;

    va_start(ap, fmt);
    vsprintf(buf, fmt, ap);
    dputs(buf);
    va_end(ap);
}


void debug_memdump(void *buf, int len, int L)
{
    int i;
    unsigned char *p = buf;
    char foo[17];
    if (L) {
	int delta;
	dprintf("\t%d (0x%x) bytes:\n", len, len);
	delta = 15 & (int) p;
	p -= delta;
	len += delta;
    }
    for (; 0 < len; p += 16, len -= 16) {
	dputs("  ");
	if (L)
	    dprintf("%p: ", p);
	strcpy(foo, "................");	/* sixteen dots */
	for (i = 0; i < 16 && i < len; ++i) {
	    if (&p[i] < (unsigned char *) buf) {
		dputs("   ");	       /* 3 spaces */
		foo[i] = ' ';
	    } else {
		dprintf("%c%02.2x",
			&p[i] != (unsigned char *) buf
			&& i % 4 ? '.' : ' ', p[i]
		    );
		if (p[i] >= ' ' && p[i] <= '~')
		    foo[i] = (char) p[i];
	    }
	}
	foo[i] = '\0';
	dprintf("%*s%s\n", (16 - i) * 3 + 2, "", foo);
    }
}

#endif				/* def DEBUG */
Commit	Line	Data
374330e2	1	#include <windows.h>
	2	#include <stdio.h>
	3	#include <stdlib.h>
5471d09a	4	#include <assert.h>
374330e2	5	#include "putty.h"
374330e2	6
03f64569	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	/* ----------------------------------------------------------------------
5471d09a	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
03f64569	148	/* ----------------------------------------------------------------------
b191636d	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
32874aea	188	static void minefield_admin_hide(int hide)
32874aea	189	{
b191636d	190	int access = hide ? PAGE_NOACCESS : PAGE_READWRITE;
32874aea	191	VirtualProtect(minefield_admin, minefield_npages * 2, access, NULL);
b191636d	192	}
b191636d	193
32874aea	194	static void minefield_init(void)
32874aea	195	{
b191636d	196	int size;
	197	int admin_size;
	198	int i;
	199
32874aea	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;
b191636d	205	}
b191636d	206	minefield_size = size;
b191636d	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;
32874aea	214	admin_size = (minefield_npages * 2 + PAGESIZE - 1) & ~(PAGESIZE - 1);
b191636d	215	minefield_npages = (minefield_size - admin_size) / PAGESIZE;
32874aea	216	minefield_pages = (char *) minefield_region + admin_size;
b191636d	217
	218	/*
	219	* Commit the admin region.
	220	*/
	221	VirtualAlloc(minefield_admin, minefield_npages * 2,
32874aea	222	MEM_COMMIT, PAGE_READWRITE);
b191636d	223
	224	/*
	225	* Mark all pages as unused (0xFFFF).
	226	*/
	227	for (i = 0; i < minefield_npages; i++)
32874aea	228	minefield_admin[i] = 0xFFFF;
b191636d	229
	230	/*
	231	* Hide the admin region.
	232	*/
	233	minefield_admin_hide(1);
	234
	235	minefield_initialised = 1;
	236	}
	237
32874aea	238	static void minefield_bomb(void)
	239	{
	240	div(1, (int ) minefield_pages);
b191636d	241	}
b191636d	242
32874aea	243	static void *minefield_alloc(int size)
32874aea	244	{
b191636d	245	int npages;
	246	int pos, lim, region_end, region_start;
	247	int start;
	248	int i;
	249
32874aea	250	npages = (size + PAGESIZE - 1) / PAGESIZE;
b191636d	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) {
32874aea	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	}
b191636d	282	}
b191636d	283
32874aea	284	minefield_curpos = pos - 1;
b191636d	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	*/
32874aea	290	region_end = (start + npages + 1) * PAGESIZE;
b191636d	291	region_start = region_end - size;
	292	/* FIXME: could align here if we wanted */
	293
	294	/*
	295	* Update the admin region.
	296	*/
32874aea	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;
b191636d	300
	301	minefield_admin_hide(1);
	302
32874aea	303	VirtualAlloc((char *) minefield_pages + region_start, size,
	304	MEM_COMMIT, PAGE_READWRITE);
	305	return (char *) minefield_pages + region_start;
b191636d	306	}
b191636d	307
32874aea	308	static void minefield_free(void *ptr)
32874aea	309	{
b191636d	310	int region_start, i, j;
	311
	312	minefield_admin_hide(0);
	313
32874aea	314	region_start = (char ) ptr - (char ) minefield_pages;
b191636d	315	i = region_start / PAGESIZE;
b191636d	316	if (i < 0 \|\| i >= minefield_npages \|\|
32874aea	317	minefield_admin[i] != region_start % PAGESIZE)
32874aea	318	minefield_bomb();
b191636d	319	for (j = i; j < minefield_npages && minefield_admin[j] != 0xFFFF; j++) {
32874aea	320	minefield_admin[j] = 0xFFFF;
b191636d	321	}
b191636d	322
32874aea	323	VirtualFree(ptr, j * PAGESIZE - region_start, MEM_DECOMMIT);
b191636d	324
	325	minefield_admin_hide(1);
	326	}
	327
32874aea	328	static int minefield_get_size(void *ptr)
32874aea	329	{
b191636d	330	int region_start, i, j;
	331
	332	minefield_admin_hide(0);
	333
32874aea	334	region_start = (char ) ptr - (char ) minefield_pages;
b191636d	335	i = region_start / PAGESIZE;
b191636d	336	if (i < 0 \|\| i >= minefield_npages \|\|
32874aea	337	minefield_admin[i] != region_start % PAGESIZE)
32874aea	338	minefield_bomb();
b191636d	339	for (j = i; j < minefield_npages && minefield_admin[j] != 0xFFFF; j++);
	340
	341	minefield_admin_hide(1);
	342
32874aea	343	return j * PAGESIZE - region_start;
b191636d	344	}
b191636d	345
32874aea	346	static void *minefield_c_malloc(size_t size)
	347	{
	348	if (!minefield_initialised)
	349	minefield_init();
b191636d	350	return minefield_alloc(size);
	351	}
	352
32874aea	353	static void minefield_c_free(void *p)
	354	{
	355	if (!minefield_initialised)
	356	minefield_init();
b191636d	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	*/
32874aea	364	static void minefield_c_realloc(void p, size_t size)
32874aea	365	{
b191636d	366	size_t oldsize;
b191636d	367	void *q;
32874aea	368	if (!minefield_initialised)
32874aea	369	minefield_init();
b191636d	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
32874aea	377	#endif /* MINEFIELD */
374330e2	378
	379	#ifdef MALLOC_LOG
	380	static FILE *fp = NULL;
	381
32874aea	382	void mlog(char *file, int line)
32874aea	383	{
c662dbc0	384	if (!fp) {
374330e2	385	fp = fopen("putty_mem.log", "w");
c662dbc0	386	setvbuf(fp, NULL, _IONBF, BUFSIZ);
c662dbc0	387	}
374330e2	388	if (fp)
32874aea	389	fprintf(fp, "%s:%d: ", file, line);
374330e2	390	}
	391	#endif
	392
32874aea	393	void *safemalloc(size_t size)
32874aea	394	{
b191636d	395	void *p;
b191636d	396	#ifdef MINEFIELD
32874aea	397	p = minefield_c_malloc(size);
b191636d	398	#else
32874aea	399	p = malloc(size);
b191636d	400	#endif
374330e2	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
32874aea	413	void saferealloc(void ptr, size_t size)
32874aea	414	{
374330e2	415	void *p;
b191636d	416	if (!ptr) {
b191636d	417	#ifdef MINEFIELD
32874aea	418	p = minefield_c_malloc(size);
b191636d	419	#else
32874aea	420	p = malloc(size);
b191636d	421	#endif
	422	} else {
	423	#ifdef MINEFIELD
32874aea	424	p = minefield_c_realloc(ptr, size);
b191636d	425	#else
32874aea	426	p = realloc(ptr, size);
b191636d	427	#endif
b191636d	428	}
374330e2	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
32874aea	441	void safefree(void *ptr)
32874aea	442	{
374330e2	443	if (ptr) {
	444	#ifdef MALLOC_LOG
	445	if (fp)
	446	fprintf(fp, "free(%p)\n", ptr);
	447	#endif
b191636d	448	#ifdef MINEFIELD
32874aea	449	minefield_c_free(ptr);
b191636d	450	#else
32874aea	451	free(ptr);
b191636d	452	#endif
374330e2	453	}
	454	#ifdef MALLOC_LOG
	455	else if (fp)
	456	fprintf(fp, "freeing null pointer - no action taken\n");
	457	#endif
	458	}
c82bda52	459
03f64569	460	/* ----------------------------------------------------------------------
	461	* Debugging routines.
	462	*/
	463
c82bda52	464	#ifdef DEBUG
	465	static FILE *debug_fp = NULL;
	466	static int debug_got_console = 0;
	467
32874aea	468	static void dputs(char *buf)
32874aea	469	{
c82bda52	470	DWORD dw;
c82bda52	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
32874aea	480	WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buf, strlen(buf), &dw,
32874aea	481	NULL);
c82bda52	482	fputs(buf, debug_fp);
c82bda52	483	fflush(debug_fp);
db9c0f86	484	}
	485
	486
32874aea	487	void dprintf(char *fmt, ...)
32874aea	488	{
db9c0f86	489	char buf[2048];
	490	va_list ap;
	491
	492	va_start(ap, fmt);
	493	vsprintf(buf, fmt, ap);
32874aea	494	dputs(buf);
c82bda52	495	va_end(ap);
c82bda52	496	}
db9c0f86	497
db9c0f86	498
32874aea	499	void debug_memdump(void *buf, int len, int L)
32874aea	500	{
db9c0f86	501	int i;
db9c0f86	502	unsigned char *p = buf;
765c4200	503	char foo[17];
db9c0f86	504	if (L) {
db9c0f86	505	int delta;
32874aea	506	dprintf("\t%d (0x%x) bytes:\n", len, len);
db9c0f86	507	delta = 15 & (int) p;
	508	p -= delta;
	509	len += delta;
	510	}
	511	for (; 0 < len; p += 16, len -= 16) {
32874aea	512	dputs(" ");
	513	if (L)
	514	dprintf("%p: ", p);
	515	strcpy(foo, "................"); /* sixteen dots */
db9c0f86	516	for (i = 0; i < 16 && i < len; ++i) {
db9c0f86	517	if (&p[i] < (unsigned char *) buf) {
32874aea	518	dputs(" "); /* 3 spaces */
765c4200	519	foo[i] = ' ';
db9c0f86	520	} else {
32874aea	521	dprintf("%c%02.2x",
	522	&p[i] != (unsigned char *) buf
	523	&& i % 4 ? '.' : ' ', p[i]
	524	);
765c4200	525	if (p[i] >= ' ' && p[i] <= '~')
32874aea	526	foo[i] = (char) p[i];
db9c0f86	527	}
db9c0f86	528	}
765c4200	529	foo[i] = '\0';
32874aea	530	dprintf("%s%s\n", (16 - i) 3 + 2, "", foo);
db9c0f86	531	}
	532	}
	533
32874aea	534	#endif /* def DEBUG */