dlls/msvcrt/misc.c

   1 /*
   2  * msvcrt.dll misc 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
  21 #include <stdlib.h>
  22 #include <sys/types.h>
  23
  24 #include "msvcrt.h"
  25 #include "wine/debug.h"
  26 #include "ntsecapi.h"
  27 #include "windows.h"
  28 #include "wine/asm.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  31
  32 static unsigned int output_format;
  33
  34 /*********************************************************************
  35  *              _beep (MSVCRT.@)
  36  */
  37 void CDECL _beep( unsigned int freq, unsigned int duration)
  38 {
  39     TRACE(":Freq %d, Duration %d\n",freq,duration);
  40     Beep(freq, duration);
  41 }
  42
  43 /*********************************************************************
  44  *              srand (MSVCRT.@)
  45  */
  46 void CDECL srand( unsigned int seed )
  47 {
  48     thread_data_t *data = msvcrt_get_thread_data();
  49     data->random_seed = seed;
  50 }
  51
  52 /*********************************************************************
  53  *              rand (MSVCRT.@)
  54  */
  55 int CDECL rand(void)
  56 {
  57     thread_data_t *data = msvcrt_get_thread_data();
  58
  59     /* this is the algorithm used by MSVC, according to
  60      * http://en.wikipedia.org/wiki/List_of_pseudorandom_number_generators */
  61     data->random_seed = data->random_seed * 214013 + 2531011;
  62     return (data->random_seed >> 16) & RAND_MAX;
  63 }
  64
  65 /*********************************************************************
  66  *              rand_s (MSVCRT.@)
  67  */
  68 int CDECL rand_s(unsigned int *pval)
  69 {
  70     if (!pval || !RtlGenRandom(pval, sizeof(*pval)))
  71     {
  72         *_errno() = EINVAL;
  73         return EINVAL;
  74     }
  75     return 0;
  76 }
  77
  78 /*********************************************************************
  79  *              _sleep (MSVCRT.@)
  80  */
  81 void CDECL _sleep(__msvcrt_ulong timeout)
  82 {
  83   TRACE("_sleep for %ld milliseconds\n",timeout);
  84   Sleep((timeout)?timeout:1);
  85 }
  86
  87 /*********************************************************************
  88  *              _lfind (MSVCRT.@)
  89  */
  90 void* CDECL _lfind(const void* match, const void* start,
  91                    unsigned int* array_size, unsigned int elem_size,
  92                    int (CDECL *cf)(const void*,const void*) )
  93 {
  94   unsigned int size = *array_size;
  95   if (size)
  96     do
  97     {
  98       if (cf(match, start) == 0)
  99         return (void *)start; /* found */
 100       start = (const char *)start + elem_size;
 101     } while (--size);
 102   return NULL;
 103 }
 104
 105 /*********************************************************************
 106  *              _lfind_s (MSVCRT.@)
 107  */
 108 void* CDECL _lfind_s(const void* match, const void* start,
 109                    unsigned int* array_size, unsigned int elem_size,
 110                    int (CDECL *cf)(void*,const void*,const void*),
 111                    void* context)
 112 {
 113   unsigned int size;
 114   if (!MSVCRT_CHECK_PMT(match != NULL)) return NULL;
 115   if (!MSVCRT_CHECK_PMT(array_size != NULL)) return NULL;
 116   if (!MSVCRT_CHECK_PMT(start != NULL || *array_size == 0)) return NULL;
 117   if (!MSVCRT_CHECK_PMT(cf != NULL)) return NULL;
 118   if (!MSVCRT_CHECK_PMT(elem_size != 0)) return NULL;
 119
 120   size = *array_size;
 121   if (size)
 122     do
 123     {
 124       if (cf(context, match, start) == 0)
 125         return (void *)start; /* found */
 126       start = (const char *)start + elem_size;
 127     } while (--size);
 128   return NULL;
 129 }
 130
 131 /*********************************************************************
 132  *              _lsearch (MSVCRT.@)
 133  */
 134 void* CDECL _lsearch(const void* match, void* start,
 135                      unsigned int* array_size, unsigned int elem_size,
 136                      int (CDECL *cf)(const void*,const void*) )
 137 {
 138   unsigned int size = *array_size;
 139   if (size)
 140     do
 141     {
 142       if (cf(match, start) == 0)
 143         return start; /* found */
 144       start = (char*)start + elem_size;
 145     } while (--size);
 146
 147   /* not found, add to end */
 148   memcpy(start, match, elem_size);
 149   array_size[0]++;
 150   return start;
 151 }
 152
 153 /*********************************************************************
 154  *                  bsearch_s (msvcrt.@)
 155  */
 156 void* CDECL bsearch_s(const void *key, const void *base, size_t nmemb, size_t size,
 157                              int (__cdecl *compare)(void *, const void *, const void *), void *ctx)
 158 {
 159     ssize_t min = 0;
 160     ssize_t max = nmemb - 1;
 161
 162     if (!MSVCRT_CHECK_PMT(size != 0)) return NULL;
 163     if (!MSVCRT_CHECK_PMT(compare != NULL)) return NULL;
 164
 165     while (min <= max)
 166     {
 167         ssize_t cursor = min + (max - min) / 2;
 168         int ret = compare(ctx, key,(const char *)base+(cursor*size));
 169         if (!ret)
 170             return (char*)base+(cursor*size);
 171         if (ret < 0)
 172             max = cursor - 1;
 173         else
 174             min = cursor + 1;
 175     }
 176     return NULL;
 177 }
 178
 179 static int CDECL compare_wrapper(void *ctx, const void *e1, const void *e2)
 180 {
 181     int (__cdecl *compare)(const void *, const void *) = ctx;
 182     return compare(e1, e2);
 183 }
 184
 185 /*********************************************************************
 186  *                  bsearch (msvcrt.@)
 187  */
 188 void* CDECL bsearch(const void *key, const void *base, size_t nmemb,
 189         size_t size, int (__cdecl *compar)(const void *, const void *))
 190 {
 191     return bsearch_s(key, base, nmemb, size, compare_wrapper, compar);
 192 }
 193 /*********************************************************************
 194  *              _chkesp (MSVCRT.@)
 195  *
 196  * Trap to a debugger if the value of the stack pointer has changed.
 197  *
 198  * PARAMS
 199  *  None.
 200  *
 201  * RETURNS
 202  *  Does not return.
 203  *
 204  * NOTES
 205  *  This function is available for iX86 only.
 206  *
 207  *  When VC++ generates debug code, it stores the value of the stack pointer
 208  *  before calling any external function, and checks the value following
 209  *  the call. It then calls this function, which will trap if the values are
 210  *  not the same. Usually this means that the prototype used to call
 211  *  the function is incorrect.  It can also mean that the .spec entry has
 212  *  the wrong calling convention or parameters.
 213  */
 214 #ifdef __i386__
 215
 216 # if defined(__GNUC__) || defined(__clang__)
 217
 218 __ASM_GLOBAL_FUNC(_chkesp,
 219                   "jnz 1f\n\t"
 220                   "ret\n"
 221                   "1:\tpushl %ebp\n\t"
 222                   __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
 223                   __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
 224                   "movl %esp,%ebp\n\t"
 225                   __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
 226                   "subl $12,%esp\n\t"
 227                   "pushl %eax\n\t"
 228                   "pushl %ecx\n\t"
 229                   "pushl %edx\n\t"
 230                   "call " __ASM_NAME("chkesp_fail") "\n\t"
 231                   "popl %edx\n\t"
 232                   "popl %ecx\n\t"
 233                   "popl %eax\n\t"
 234                   "leave\n\t"
 235                   __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
 236                   __ASM_CFI(".cfi_same_value %ebp\n\t")
 237                   "ret")
 238
 239 void CDECL DECLSPEC_HIDDEN chkesp_fail(void)
 240 {
 241   ERR("Stack pointer incorrect after last function call - Bad prototype/spec entry?\n");
 242   DebugBreak();
 243 }
 244
 245 # else  /* __GNUC__ || __clang__ */
 246
 247 /**********************************************************************/
 248
 249 void CDECL _chkesp(void)
 250 {
 251 }
 252
 253 # endif  /* __GNUC__ || __clang__ */
 254
 255 #endif  /* __i386__ */
 256
 257 static inline void swap(char *l, char *r, size_t size)
 258 {
 259     char tmp;
 260
 261     while(size--) {
 262         tmp = *l;
 263         *l++ = *r;
 264         *r++ = tmp;
 265     }
 266 }
 267
 268 static void small_sort(void *base, size_t nmemb, size_t size,
 269         int (CDECL *compar)(void *, const void *, const void *), void *context)
 270 {
 271     size_t e, i;
 272     char *max, *p;
 273
 274     for(e=nmemb; e>1; e--) {
 275         max = base;
 276         for(i=1; i<e; i++) {
 277             p = (char*)base + i*size;
 278             if(compar(context, p, max) > 0)
 279                 max = p;
 280         }
 281
 282         if(p != max)
 283             swap(p, max, size);
 284     }
 285 }
 286
 287 static void quick_sort(void *base, size_t nmemb, size_t size,
 288         int (CDECL *compar)(void *, const void *, const void *), void *context)
 289 {
 290     size_t stack_lo[8*sizeof(size_t)], stack_hi[8*sizeof(size_t)];
 291     size_t beg, end, lo, hi, med;
 292     int stack_pos;
 293
 294     stack_pos = 0;
 295     stack_lo[stack_pos] = 0;
 296     stack_hi[stack_pos] = nmemb-1;
 297
 298 #define X(i) ((char*)base+size*(i))
 299     while(stack_pos >= 0) {
 300         beg = stack_lo[stack_pos];
 301         end = stack_hi[stack_pos--];
 302
 303         if(end-beg < 8) {
 304             small_sort(X(beg), end-beg+1, size, compar, context);
 305             continue;
 306         }
 307
 308         lo = beg;
 309         hi = end;
 310         med = lo + (hi-lo+1)/2;
 311         if(compar(context, X(lo), X(med)) > 0)
 312             swap(X(lo), X(med), size);
 313         if(compar(context, X(lo), X(hi)) > 0)
 314             swap(X(lo), X(hi), size);
 315         if(compar(context, X(med), X(hi)) > 0)
 316             swap(X(med), X(hi), size);
 317
 318         lo++;
 319         hi--;
 320         while(1) {
 321             while(lo <= hi) {
 322                 if(lo!=med && compar(context, X(lo), X(med))>0)
 323                     break;
 324                 lo++;
 325             }
 326
 327             while(med != hi) {
 328                 if(compar(context, X(hi), X(med)) <= 0)
 329                     break;
 330                 hi--;
 331             }
 332
 333             if(hi < lo)
 334                 break;
 335
 336             swap(X(lo), X(hi), size);
 337             if(hi == med)
 338                 med = lo;
 339             lo++;
 340             hi--;
 341         }
 342
 343         while(hi > beg) {
 344             if(hi!=med && compar(context, X(hi), X(med))!=0)
 345                 break;
 346             hi--;
 347         }
 348
 349         if(hi-beg >= end-lo) {
 350             stack_lo[++stack_pos] = beg;
 351             stack_hi[stack_pos] = hi;
 352             stack_lo[++stack_pos] = lo;
 353             stack_hi[stack_pos] = end;
 354         }else {
 355             stack_lo[++stack_pos] = lo;
 356             stack_hi[stack_pos] = end;
 357             stack_lo[++stack_pos] = beg;
 358             stack_hi[stack_pos] = hi;
 359         }
 360     }
 361 #undef X
 362 }
 363
 364 /*********************************************************************
 365  * qsort_s (MSVCRT.@)
 366  *
 367  * This function is trying to sort data doing identical comparisons
 368  * as native does. There are still cases where it behaves differently.
 369  */
 370 void CDECL qsort_s(void *base, size_t nmemb, size_t size,
 371     int (CDECL *compar)(void *, const void *, const void *), void *context)
 372 {
 373     const size_t total_size = nmemb*size;
 374
 375     if (!MSVCRT_CHECK_PMT(base != NULL || (base == NULL && nmemb == 0))) return;
 376     if (!MSVCRT_CHECK_PMT(size > 0)) return;
 377     if (!MSVCRT_CHECK_PMT(compar != NULL)) return;
 378     if (total_size / size != nmemb) return;
 379
 380     if (nmemb < 2) return;
 381
 382     quick_sort(base, nmemb, size, compar, context);
 383 }
 384
 385 /*********************************************************************
 386  * qsort (MSVCRT.@)
 387  */
 388 void CDECL qsort(void *base, size_t nmemb, size_t size,
 389         int (CDECL *compar)(const void*, const void*))
 390 {
 391     qsort_s(base, nmemb, size, compare_wrapper, compar);
 392 }
 393
 394 /*********************************************************************
 395  * _get_output_format (MSVCRT.@)
 396  */
 397 unsigned int CDECL _get_output_format(void)
 398 {
 399    return output_format;
 400 }
 401
 402 /*********************************************************************
 403  * _set_output_format (MSVCRT.@)
 404  */
 405 unsigned int CDECL _set_output_format(unsigned int new_output_format)
 406 {
 407     unsigned int ret = output_format;
 408
 409     if(!MSVCRT_CHECK_PMT(new_output_format==0 || new_output_format==_TWO_DIGIT_EXPONENT))
 410         return ret;
 411
 412     output_format = new_output_format;
 413     return ret;
 414 }
 415
 416 /*********************************************************************
 417  * _resetstkoflw (MSVCRT.@)
 418  */
 419 int CDECL _resetstkoflw(void)
 420 {
 421     int stack_addr;
 422     DWORD oldprot;
 423
 424     /* causes stack fault that updates NtCurrentTeb()->Tib.StackLimit */
 425     return VirtualProtect(&stack_addr, 1, PAGE_GUARD|PAGE_READWRITE, &oldprot);
 426 }
 427
 428 #if _MSVCR_VER>=80 && _MSVCR_VER<=90
 429
 430 /*********************************************************************
 431  *  _decode_pointer (MSVCR80.@)
 432  */
 433 void * CDECL _decode_pointer(void * ptr)
 434 {
 435     return DecodePointer(ptr);
 436 }
 437
 438 /*********************************************************************
 439  *  _encode_pointer (MSVCR80.@)
 440  */
 441 void * CDECL _encode_pointer(void * ptr)
 442 {
 443     return EncodePointer(ptr);
 444 }
 445
 446 #endif /* _MSVCR_VER>=80 && _MSVCR_VER<=90 */
 447
 448 #if _MSVCR_VER>=80 && _MSVCR_VER<=100
 449 /*********************************************************************
 450  *  _encoded_null (MSVCR80.@)
 451  */
 452 void * CDECL _encoded_null(void)
 453 {
 454     TRACE("\n");
 455
 456     return EncodePointer(NULL);
 457 }
 458 #endif
 459
 460 #if _MSVCR_VER>=70
 461 /*********************************************************************
 462  * _CRT_RTC_INIT (MSVCR70.@)
 463  */
 464 void* CDECL _CRT_RTC_INIT(void *unk1, void *unk2, int unk3, int unk4, int unk5)
 465 {
 466     TRACE("%p %p %x %x %x\n", unk1, unk2, unk3, unk4, unk5);
 467     return NULL;
 468 }
 469 #endif
 470
 471 #if _MSVCR_VER>=80
 472
 473 /*********************************************************************
 474  * _CRT_RTC_INITW (MSVCR80.@)
 475  */
 476 void* CDECL _CRT_RTC_INITW(void *unk1, void *unk2, int unk3, int unk4, int unk5)
 477 {
 478     TRACE("%p %p %x %x %x\n", unk1, unk2, unk3, unk4, unk5);
 479     return NULL;
 480 }
 481
 482 /*********************************************************************
 483  * _byteswap_ushort (MSVCR80.@)
 484  */
 485 unsigned short CDECL _byteswap_ushort(unsigned short s)
 486 {
 487     return (s<<8) + (s>>8);
 488 }
 489
 490 /*********************************************************************
 491  * _byteswap_ulong (MSVCR80.@)
 492  */
 493 ULONG CDECL _byteswap_ulong(ULONG l)
 494 {
 495     return (l<<24) + ((l<<8)&0xFF0000) + ((l>>8)&0xFF00) + (l>>24);
 496 }
 497
 498 /*********************************************************************
 499  * _byteswap_uint64 (MSVCR80.@)
 500  */
 501 unsigned __int64 CDECL _byteswap_uint64(unsigned __int64 i)
 502 {
 503     return (i<<56) + ((i&0xFF00)<<40) + ((i&0xFF0000)<<24) + ((i&0xFF000000)<<8) +
 504         ((i>>8)&0xFF000000) + ((i>>24)&0xFF0000) + ((i>>40)&0xFF00) + (i>>56);
 505 }
 506
 507 #endif /* _MSVCR_VER>=80 */
 508
 509 #if _MSVCR_VER>=110
 510
 511 /*********************************************************************
 512  *  __crtGetShowWindowMode (MSVCR110.@)
 513  */
 514 int CDECL __crtGetShowWindowMode(void)
 515 {
 516     STARTUPINFOW si;
 517
 518     GetStartupInfoW(&si);
 519     TRACE("flags=%x window=%d\n", si.dwFlags, si.wShowWindow);
 520     return si.dwFlags & STARTF_USESHOWWINDOW ? si.wShowWindow : SW_SHOWDEFAULT;
 521 }
 522
 523 /*********************************************************************
 524  *  __crtInitializeCriticalSectionEx (MSVCR110.@)
 525  */
 526 BOOL CDECL __crtInitializeCriticalSectionEx(
 527         CRITICAL_SECTION *cs, DWORD spin_count, DWORD flags)
 528 {
 529     TRACE("(%p %x %x)\n", cs, spin_count, flags);
 530     return InitializeCriticalSectionEx(cs, spin_count, flags);
 531 }
 532
 533 #endif /* _MSVCR_VER>=110 */
 534
 535 #if _MSVCR_VER>=120
 536 /*********************************************************************
 537  * _vacopy (MSVCR120.@)
 538  */
 539 void CDECL _vacopy(__ms_va_list *dest, __ms_va_list src)
 540 {
 541     __ms_va_copy(*dest, src);
 542 }
 543 #endif
 544
 545 #if _MSVCR_VER>=80
 546 /*********************************************************************
 547  * _crt_debugger_hook (MSVCR80.@)
 548  */
 549 void CDECL _crt_debugger_hook(int reserved)
 550 {
 551     WARN("(%x)\n", reserved);
 552 }
 553 #endif
 554
 555 #if _MSVCR_VER>=110
 556 /*********************************************************************
 557  *  __crtUnhandledException (MSVCR110.@)
 558  */
 559 LONG CDECL __crtUnhandledException(EXCEPTION_POINTERS *ep)
 560 {
 561     TRACE("(%p)\n", ep);
 562     SetUnhandledExceptionFilter(NULL);
 563     return UnhandledExceptionFilter(ep);
 564 }
 565
 566 /* ?_Trace_agents@Concurrency@@YAXW4Agents_EventType@1@_JZZ */
 567 void WINAPIV _Trace_agents(/*enum Concurrency::Agents_EventType*/int type, __int64 id, ...)
 568 {
 569     FIXME("(%d %s)\n", type, wine_dbgstr_longlong(id));
 570 }
 571 #endif
 572
 573 #if _MSVCR_VER>=120
 574 /*********************************************************************
 575  *              __crtSleep (MSVCR120.@)
 576  */
 577 void CDECL __crtSleep(DWORD timeout)
 578 {
 579   TRACE("(%u)\n", timeout);
 580   Sleep(timeout);
 581 }
 582
 583 /*********************************************************************
 584  * _SetWinRTOutOfMemoryExceptionCallback (MSVCR120.@)
 585  */
 586 void CDECL _SetWinRTOutOfMemoryExceptionCallback(void *callback)
 587 {
 588     FIXME("(%p): stub\n", callback);
 589 }
 590 #endif