msvcrt: Sync _wtempnam with _tempnam.
[wine] / dlls / msvcrt / heap.c
1 /*
2  * msvcrt.dll heap functions
3  *
4  * Copyright 2000 Jon Griffiths
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  *
20  * Note: Win32 heap operations are MT safe. We only lock the new
21  *       handler and non atomic heap operations
22  */
23
24 #include "msvcrt.h"
25 #include "mtdll.h"
26 #include "wine/debug.h"
27
28 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
29
30 /* MT */
31 #define LOCK_HEAP   _mlock( _HEAP_LOCK )
32 #define UNLOCK_HEAP _munlock( _HEAP_LOCK )
33
34 /* _aligned */
35 #define SAVED_PTR(x) ((void *)((DWORD_PTR)((char *)x - sizeof(void *)) & \
36                                ~(sizeof(void *) - 1)))
37 #define ALIGN_PTR(ptr, alignment, offset) ((void *) \
38     ((((DWORD_PTR)((char *)ptr + alignment + sizeof(void *) + offset)) & \
39       ~(alignment - 1)) - offset))
40
41
42 typedef int (CDECL *MSVCRT_new_handler_func)(MSVCRT_size_t size);
43
44 static MSVCRT_new_handler_func MSVCRT_new_handler;
45 static int MSVCRT_new_mode;
46
47 /* FIXME - According to documentation it should be 8*1024, at runtime it returns 16 */ 
48 static unsigned int MSVCRT_amblksiz = 16;
49 /* FIXME - According to documentation it should be 480 bytes, at runtime default is 0 */
50 static MSVCRT_size_t MSVCRT_sbh_threshold = 0;
51
52 /*********************************************************************
53  *              ??2@YAPAXI@Z (MSVCRT.@)
54  */
55 void* CDECL MSVCRT_operator_new(MSVCRT_size_t size)
56 {
57   void *retval;
58   int freed;
59
60   do
61   {
62     retval = HeapAlloc(GetProcessHeap(), 0, size);
63     if(retval)
64     {
65       TRACE("(%ld) returning %p\n", size, retval);
66       return retval;
67     }
68
69     LOCK_HEAP;
70     if(MSVCRT_new_handler)
71       freed = (*MSVCRT_new_handler)(size);
72     else
73       freed = 0;
74     UNLOCK_HEAP;
75   } while(freed);
76
77   TRACE("(%ld) out of memory\n", size);
78   return NULL;
79 }
80
81
82 /*********************************************************************
83  *              ??2@YAPAXIHPBDH@Z (MSVCRT.@)
84  */
85 void* CDECL MSVCRT_operator_new_dbg(MSVCRT_size_t size, int type, const char *file, int line)
86 {
87     return MSVCRT_operator_new( size );
88 }
89
90
91 /*********************************************************************
92  *              ??3@YAXPAX@Z (MSVCRT.@)
93  */
94 void CDECL MSVCRT_operator_delete(void *mem)
95 {
96   TRACE("(%p)\n", mem);
97   HeapFree(GetProcessHeap(), 0, mem);
98 }
99
100
101 /*********************************************************************
102  *              ?_query_new_handler@@YAP6AHI@ZXZ (MSVCRT.@)
103  */
104 MSVCRT_new_handler_func CDECL MSVCRT__query_new_handler(void)
105 {
106   return MSVCRT_new_handler;
107 }
108
109
110 /*********************************************************************
111  *              ?_query_new_mode@@YAHXZ (MSVCRT.@)
112  */
113 int CDECL MSVCRT__query_new_mode(void)
114 {
115   return MSVCRT_new_mode;
116 }
117
118 /*********************************************************************
119  *              ?_set_new_handler@@YAP6AHI@ZP6AHI@Z@Z (MSVCRT.@)
120  */
121 MSVCRT_new_handler_func CDECL MSVCRT__set_new_handler(MSVCRT_new_handler_func func)
122 {
123   MSVCRT_new_handler_func old_handler;
124   LOCK_HEAP;
125   old_handler = MSVCRT_new_handler;
126   MSVCRT_new_handler = func;
127   UNLOCK_HEAP;
128   return old_handler;
129 }
130
131 /*********************************************************************
132  *              ?set_new_handler@@YAP6AXXZP6AXXZ@Z (MSVCRT.@)
133  */
134 MSVCRT_new_handler_func CDECL MSVCRT_set_new_handler(void *func)
135 {
136   TRACE("(%p)\n",func);
137   MSVCRT__set_new_handler(NULL);
138   return NULL;
139 }
140
141 /*********************************************************************
142  *              ?_set_new_mode@@YAHH@Z (MSVCRT.@)
143  */
144 int CDECL MSVCRT__set_new_mode(int mode)
145 {
146   int old_mode;
147   LOCK_HEAP;
148   old_mode = MSVCRT_new_mode;
149   MSVCRT_new_mode = mode;
150   UNLOCK_HEAP;
151   return old_mode;
152 }
153
154 /*********************************************************************
155  *              _callnewh (MSVCRT.@)
156  */
157 int CDECL _callnewh(MSVCRT_size_t size)
158 {
159   if(MSVCRT_new_handler)
160     (*MSVCRT_new_handler)(size);
161   return 0;
162 }
163
164 /*********************************************************************
165  *              _expand (MSVCRT.@)
166  */
167 void* CDECL _expand(void* mem, MSVCRT_size_t size)
168 {
169   return HeapReAlloc(GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY, mem, size);
170 }
171
172 /*********************************************************************
173  *              _heapchk (MSVCRT.@)
174  */
175 int CDECL _heapchk(void)
176 {
177   if (!HeapValidate( GetProcessHeap(), 0, NULL))
178   {
179     msvcrt_set_errno(GetLastError());
180     return MSVCRT__HEAPBADNODE;
181   }
182   return MSVCRT__HEAPOK;
183 }
184
185 /*********************************************************************
186  *              _heapmin (MSVCRT.@)
187  */
188 int CDECL _heapmin(void)
189 {
190   if (!HeapCompact( GetProcessHeap(), 0 ))
191   {
192     if (GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
193       msvcrt_set_errno(GetLastError());
194     return -1;
195   }
196   return 0;
197 }
198
199 /*********************************************************************
200  *              _heapwalk (MSVCRT.@)
201  */
202 int CDECL _heapwalk(struct MSVCRT__heapinfo* next)
203 {
204   PROCESS_HEAP_ENTRY phe;
205
206   LOCK_HEAP;
207   phe.lpData = next->_pentry;
208   phe.cbData = next->_size;
209   phe.wFlags = next->_useflag == MSVCRT__USEDENTRY ? PROCESS_HEAP_ENTRY_BUSY : 0;
210
211   if (phe.lpData && phe.wFlags & PROCESS_HEAP_ENTRY_BUSY &&
212       !HeapValidate( GetProcessHeap(), 0, phe.lpData ))
213   {
214     UNLOCK_HEAP;
215     msvcrt_set_errno(GetLastError());
216     return MSVCRT__HEAPBADNODE;
217   }
218
219   do
220   {
221     if (!HeapWalk( GetProcessHeap(), &phe ))
222     {
223       UNLOCK_HEAP;
224       if (GetLastError() == ERROR_NO_MORE_ITEMS)
225          return MSVCRT__HEAPEND;
226       msvcrt_set_errno(GetLastError());
227       if (!phe.lpData)
228         return MSVCRT__HEAPBADBEGIN;
229       return MSVCRT__HEAPBADNODE;
230     }
231   } while (phe.wFlags & (PROCESS_HEAP_REGION|PROCESS_HEAP_UNCOMMITTED_RANGE));
232
233   UNLOCK_HEAP;
234   next->_pentry = phe.lpData;
235   next->_size = phe.cbData;
236   next->_useflag = phe.wFlags & PROCESS_HEAP_ENTRY_BUSY ? MSVCRT__USEDENTRY : MSVCRT__FREEENTRY;
237   return MSVCRT__HEAPOK;
238 }
239
240 /*********************************************************************
241  *              _heapset (MSVCRT.@)
242  */
243 int CDECL _heapset(unsigned int value)
244 {
245   int retval;
246   struct MSVCRT__heapinfo heap;
247
248   memset( &heap, 0, sizeof(heap) );
249   LOCK_HEAP;
250   while ((retval = _heapwalk(&heap)) == MSVCRT__HEAPOK)
251   {
252     if (heap._useflag == MSVCRT__FREEENTRY)
253       memset(heap._pentry, value, heap._size);
254   }
255   UNLOCK_HEAP;
256   return retval == MSVCRT__HEAPEND? MSVCRT__HEAPOK : retval;
257 }
258
259 /*********************************************************************
260  *              _heapadd (MSVCRT.@)
261  */
262 int CDECL _heapadd(void* mem, MSVCRT_size_t size)
263 {
264   TRACE("(%p,%ld) unsupported in Win32\n", mem,size);
265   *MSVCRT__errno() = MSVCRT_ENOSYS;
266   return -1;
267 }
268
269 /*********************************************************************
270  *              _heapadd (MSVCRT.@)
271  */
272 MSVCRT_intptr_t CDECL _get_heap_handle(void)
273 {
274     return (MSVCRT_intptr_t)GetProcessHeap();
275 }
276
277 /*********************************************************************
278  *              _msize (MSVCRT.@)
279  */
280 MSVCRT_size_t CDECL _msize(void* mem)
281 {
282   MSVCRT_size_t size = HeapSize(GetProcessHeap(),0,mem);
283   if (size == ~(MSVCRT_size_t)0)
284   {
285     WARN(":Probably called with non wine-allocated memory, ret = -1\n");
286     /* At least the Win32 crtdll/msvcrt also return -1 in this case */
287   }
288   return size;
289 }
290
291 /*********************************************************************
292  *              calloc (MSVCRT.@)
293  */
294 void* CDECL MSVCRT_calloc(MSVCRT_size_t size, MSVCRT_size_t count)
295 {
296   return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size * count );
297 }
298
299 /*********************************************************************
300  *              free (MSVCRT.@)
301  */
302 void CDECL MSVCRT_free(void* ptr)
303 {
304   HeapFree(GetProcessHeap(),0,ptr);
305 }
306
307 /*********************************************************************
308  *                  malloc (MSVCRT.@)
309  */
310 void* CDECL MSVCRT_malloc(MSVCRT_size_t size)
311 {
312   void *ret = HeapAlloc(GetProcessHeap(),0,size);
313   if (!ret)
314       *MSVCRT__errno() = MSVCRT_ENOMEM;
315   return ret;
316 }
317
318 /*********************************************************************
319  *              realloc (MSVCRT.@)
320  */
321 void* CDECL MSVCRT_realloc(void* ptr, MSVCRT_size_t size)
322 {
323   if (!ptr) return MSVCRT_malloc(size);
324   if (size) return HeapReAlloc(GetProcessHeap(), 0, ptr, size);
325   MSVCRT_free(ptr);
326   return NULL;
327 }
328
329 /*********************************************************************
330  *              __p__amblksiz (MSVCRT.@)
331  */
332 unsigned int* CDECL __p__amblksiz(void)
333 {
334   return &MSVCRT_amblksiz;
335 }
336
337 /*********************************************************************
338  *              _get_sbh_threshold (MSVCRT.@)
339  */
340 MSVCRT_size_t CDECL _get_sbh_threshold(void)
341 {
342   return MSVCRT_sbh_threshold;
343 }
344
345 /*********************************************************************
346  *              _set_sbh_threshold (MSVCRT.@)
347  */
348 int CDECL _set_sbh_threshold(MSVCRT_size_t threshold)
349 {
350   if(threshold > 1016)
351      return 0;
352   else
353      MSVCRT_sbh_threshold = threshold;
354   return 1;
355 }
356
357 /*********************************************************************
358  *              _aligned_free (MSVCRT.@)
359  */
360 void CDECL _aligned_free(void *memblock)
361 {
362     TRACE("(%p)\n", memblock);
363
364     if (memblock)
365     {
366         void **saved = SAVED_PTR(memblock);
367         MSVCRT_free(*saved);
368     }
369 }
370
371 /*********************************************************************
372  *              _aligned_offset_malloc (MSVCRT.@)
373  */
374 void * CDECL _aligned_offset_malloc(MSVCRT_size_t size, MSVCRT_size_t alignment, MSVCRT_size_t offset)
375 {
376     void *memblock, *temp, **saved;
377     TRACE("(%lu, %lu, %lu)\n", size, alignment, offset);
378
379     /* alignment must be a power of 2 */
380     if ((alignment & (alignment - 1)) != 0)
381     {
382         *MSVCRT__errno() = MSVCRT_EINVAL;
383         return NULL;
384     }
385
386     /* offset must be less than size */
387     if (offset >= size)
388     {
389         *MSVCRT__errno() = MSVCRT_EINVAL;
390         return NULL;
391     }
392
393     /* don't align to less than void pointer size */
394     if (alignment < sizeof(void *))
395         alignment = sizeof(void *);
396
397     /* allocate enough space for void pointer and alignment */
398     temp = MSVCRT_malloc(size + alignment + sizeof(void *));
399
400     if (!temp)
401         return NULL;
402
403     /* adjust pointer for proper alignment and offset */
404     memblock = ALIGN_PTR(temp, alignment, offset);
405
406     /* Save the real allocation address below returned address */
407     /* so it can be found later to free. */
408     saved = SAVED_PTR(memblock);
409     *saved = temp;
410
411     return memblock;
412 }
413
414 /*********************************************************************
415  *              _aligned_malloc (MSVCRT.@)
416  */
417 void * CDECL _aligned_malloc(MSVCRT_size_t size, MSVCRT_size_t alignment)
418 {
419     TRACE("(%lu, %lu)\n", size, alignment);
420     return _aligned_offset_malloc(size, alignment, 0);
421 }
422
423 /*********************************************************************
424  *              _aligned_offset_realloc (MSVCRT.@)
425  */
426 void * CDECL _aligned_offset_realloc(void *memblock, MSVCRT_size_t size,
427                                      MSVCRT_size_t alignment, MSVCRT_size_t offset)
428 {
429     void * temp, **saved;
430     MSVCRT_size_t old_padding, new_padding, old_size;
431     TRACE("(%p, %lu, %lu, %lu)\n", memblock, size, alignment, offset);
432
433     if (!memblock)
434         return _aligned_offset_malloc(size, alignment, offset);
435
436     /* alignment must be a power of 2 */
437     if ((alignment & (alignment - 1)) != 0)
438     {
439         *MSVCRT__errno() = MSVCRT_EINVAL;
440         return NULL;
441     }
442
443     /* offset must be less than size */
444     if (offset >= size)
445     {
446         *MSVCRT__errno() = MSVCRT_EINVAL;
447         return NULL;
448     }
449
450     if (size == 0)
451     {
452         _aligned_free(memblock);
453         return NULL;
454     }
455
456     /* don't align to less than void pointer size */
457     if (alignment < sizeof(void *))
458         alignment = sizeof(void *);
459
460     /* make sure alignment and offset didn't change */
461     saved = SAVED_PTR(memblock);
462     if (memblock != ALIGN_PTR(*saved, alignment, offset))
463     {
464         *MSVCRT__errno() = MSVCRT_EINVAL;
465         return NULL;
466     }
467
468     old_padding = (char *)memblock - (char *)*saved;
469
470     /* Get previous size of block */
471     old_size = _msize(*saved);
472     if (old_size == -1)
473     {
474         /* It seems this function was called with an invalid pointer. Bail out. */
475         return NULL;
476     }
477
478     /* Adjust old_size to get amount of actual data in old block. */
479     if (old_size < old_padding)
480     {
481         /* Shouldn't happen. Something's weird, so bail out. */
482         return NULL;
483     }
484     old_size -= old_padding;
485
486     temp = MSVCRT_realloc(*saved, size + alignment + sizeof(void *));
487
488     if (!temp)
489         return NULL;
490
491     /* adjust pointer for proper alignment and offset */
492     memblock = ALIGN_PTR(temp, alignment, offset);
493
494     /* Save the real allocation address below returned address */
495     /* so it can be found later to free. */
496     saved = SAVED_PTR(memblock);
497
498     new_padding = (char *)memblock - (char *)temp;
499
500 /*
501    Memory layout of old block is as follows:
502    +-------+---------------------+-+--------------------------+-----------+
503    |  ...  | "old_padding" bytes | | ... "old_size" bytes ... |    ...    |
504    +-------+---------------------+-+--------------------------+-----------+
505            ^                     ^ ^
506            |                     | |
507         *saved               saved memblock
508
509    Memory layout of new block is as follows:
510    +-------+-----------------------------+-+----------------------+-------+
511    |  ...  |    "new_padding" bytes      | | ... "size" bytes ... |  ...  |
512    +-------+-----------------------------+-+----------------------+-------+
513            ^                             ^ ^
514            |                             | |
515           temp                       saved memblock
516
517    However, in the new block, actual data is still written as follows
518    (because it was copied by MSVCRT_realloc):
519    +-------+---------------------+--------------------------------+-------+
520    |  ...  | "old_padding" bytes |   ... "old_size" bytes ...     |  ...  |
521    +-------+---------------------+--------------------------------+-------+
522            ^                             ^ ^
523            |                             | |
524           temp                       saved memblock
525
526    Therefore, min(old_size,size) bytes of actual data have to be moved
527    from the offset they were at in the old block (temp + old_padding),
528    to the offset they have to be in the new block (temp + new_padding == memblock).
529 */
530     if (new_padding != old_padding)
531         memmove((char *)memblock, (char *)temp + old_padding, (old_size < size) ? old_size : size);
532
533     *saved = temp;
534
535     return memblock;
536 }
537
538 /*********************************************************************
539  *              _aligned_realloc (MSVCRT.@)
540  */
541 void * CDECL _aligned_realloc(void *memblock, MSVCRT_size_t size, MSVCRT_size_t alignment)
542 {
543     TRACE("(%p, %lu, %lu)\n", memblock, size, alignment);
544     return _aligned_offset_realloc(memblock, size, alignment, 0);
545 }
546
547 /*********************************************************************
548  *              memmove_s (MSVCRT.@)
549  */
550 int CDECL memmove_s(void *dest, MSVCRT_size_t numberOfElements, const void *src, MSVCRT_size_t count)
551 {
552     TRACE("(%p %lu %p %lu)\n", dest, numberOfElements, src, count);
553
554     if(!count)
555         return 0;
556
557     if(!dest || !src) {
558         if(dest)
559             memset(dest, 0, numberOfElements);
560
561         *MSVCRT__errno() = MSVCRT_EINVAL;
562         return MSVCRT_EINVAL;
563     }
564
565     if(count > numberOfElements) {
566         memset(dest, 0, numberOfElements);
567
568         *MSVCRT__errno() = MSVCRT_ERANGE;
569         return MSVCRT_ERANGE;
570     }
571
572     memmove(dest, src, count);
573     return 0;
574 }
575
576 /*********************************************************************
577  *              strncpy_s (MSVCRT.@)
578  */
579 int CDECL strncpy_s(char *dest, MSVCRT_size_t numberOfElements,
580         const char *src, MSVCRT_size_t count)
581 {
582     MSVCRT_size_t i, end;
583
584     TRACE("(%s %lu %s %lu)\n", dest, numberOfElements, src, count);
585
586     if(!count)
587         return 0;
588
589     if (!MSVCRT_CHECK_PMT(dest != NULL) || !MSVCRT_CHECK_PMT(src != NULL) || !MSVCRT_CHECK_PMT(numberOfElements != 0)) {
590         *MSVCRT__errno() = MSVCRT_EINVAL;
591         return MSVCRT_EINVAL;
592     }
593
594     if(count!=MSVCRT__TRUNCATE && count<numberOfElements)
595         end = count;
596     else
597         end = numberOfElements-1;
598
599     for(i=0; i<end && src[i]; i++)
600         dest[i] = src[i];
601
602     if(!src[i] || end==count || count==MSVCRT__TRUNCATE) {
603         dest[i] = '\0';
604         return 0;
605     }
606
607     MSVCRT_INVALID_PMT("dest[numberOfElements] is too small");
608     dest[0] = '\0';
609     *MSVCRT__errno() = MSVCRT_EINVAL;
610     return MSVCRT_EINVAL;
611 }