dlls/ntdll/misc.c

   1 /*
   2  * Helper functions for ntdll
   3  *
   4  * Copyright 2000 Juergen Schmied
   5  * Copyright 2010 Marcus Meissner
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <time.h>
  23 #include <math.h>
  24
  25 #include "ntstatus.h"
  26 #define WIN32_NO_STATUS
  27 #include "wine/debug.h"
  28 #include "ntdll_misc.h"
  29 #include "wmistr.h"
  30 #include "evntrace.h"
  31 #include "evntprov.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
  34
  35 LPCSTR debugstr_us( const UNICODE_STRING *us )
  36 {
  37     if (!us) return "<null>";
  38     return debugstr_wn(us->Buffer, us->Length / sizeof(WCHAR));
  39 }
  40
  41 /*********************************************************************
  42  *                  abs   (NTDLL.@)
  43  */
  44 int CDECL abs( int i )
  45 {
  46     return i >= 0 ? i : -i;
  47 }
  48
  49 /*********************************************************************
  50  *                  atan   (NTDLL.@)
  51  */
  52 double CDECL atan( double d )
  53 {
  54     return unix_funcs->atan( d );
  55 }
  56
  57 /*********************************************************************
  58  *                  ceil   (NTDLL.@)
  59  */
  60 double CDECL ceil( double d )
  61 {
  62     return unix_funcs->ceil( d );
  63 }
  64
  65 /*********************************************************************
  66  *                  cos   (NTDLL.@)
  67  */
  68 double CDECL cos( double d )
  69 {
  70     return unix_funcs->cos( d );
  71 }
  72
  73 /*********************************************************************
  74  *                  fabs   (NTDLL.@)
  75  */
  76 double CDECL fabs( double d )
  77 {
  78     return unix_funcs->fabs( d );
  79 }
  80
  81 /*********************************************************************
  82  *                  floor   (NTDLL.@)
  83  */
  84 double CDECL floor( double d )
  85 {
  86     return unix_funcs->floor( d );
  87 }
  88
  89 /*********************************************************************
  90  *                  log   (NTDLL.@)
  91  */
  92 double CDECL log( double d )
  93 {
  94     return unix_funcs->log( d );
  95 }
  96
  97 /*********************************************************************
  98  *                  pow   (NTDLL.@)
  99  */
 100 double CDECL pow( double x, double y )
 101 {
 102     return unix_funcs->pow( x, y );
 103 }
 104
 105 /*********************************************************************
 106  *                  sin   (NTDLL.@)
 107  */
 108 double CDECL sin( double d )
 109 {
 110     return unix_funcs->sin( d );
 111 }
 112
 113 /*********************************************************************
 114  *                  sqrt   (NTDLL.@)
 115  */
 116 double CDECL sqrt( double d )
 117 {
 118     return unix_funcs->sqrt( d );
 119 }
 120
 121 /*********************************************************************
 122  *                  tan   (NTDLL.@)
 123  */
 124 double CDECL tan( double d )
 125 {
 126     return unix_funcs->tan( d );
 127 }
 128
 129 #if (defined(__GNUC__) || defined(__clang__)) && defined(__i386__)
 130
 131 #define FPU_DOUBLE(var) double var; \
 132     __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var) : )
 133 #define FPU_DOUBLES(var1,var2) double var1,var2; \
 134     __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var2) : ); \
 135     __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var1) : )
 136
 137 /*********************************************************************
 138  *              _CIcos (NTDLL.@)
 139  */
 140 double CDECL _CIcos(void)
 141 {
 142     FPU_DOUBLE(x);
 143     return cos(x);
 144 }
 145
 146 /*********************************************************************
 147  *              _CIlog (NTDLL.@)
 148  */
 149 double CDECL _CIlog(void)
 150 {
 151     FPU_DOUBLE(x);
 152     return log(x);
 153 }
 154
 155 /*********************************************************************
 156  *              _CIpow (NTDLL.@)
 157  */
 158 double CDECL _CIpow(void)
 159 {
 160     FPU_DOUBLES(x,y);
 161     return pow(x,y);
 162 }
 163
 164 /*********************************************************************
 165  *              _CIsin (NTDLL.@)
 166  */
 167 double CDECL _CIsin(void)
 168 {
 169     FPU_DOUBLE(x);
 170     return sin(x);
 171 }
 172
 173 /*********************************************************************
 174  *              _CIsqrt (NTDLL.@)
 175  */
 176 double CDECL _CIsqrt(void)
 177 {
 178     FPU_DOUBLE(x);
 179     return sqrt(x);
 180 }
 181
 182 /*********************************************************************
 183  *                  _ftol   (NTDLL.@)
 184  */
 185 LONGLONG CDECL _ftol(void)
 186 {
 187     FPU_DOUBLE(x);
 188     return (LONGLONG)x;
 189 }
 190
 191 #endif /* (defined(__GNUC__) || defined(__clang__)) && defined(__i386__) */
 192
 193 static void
 194 NTDLL_mergesort( void *arr, void *barr, size_t elemsize, int(__cdecl *compar)(const void *, const void *),
 195                  size_t left, size_t right )
 196 {
 197     if(right>left) {
 198         size_t i, j, k, m;
 199         m=left+(right-left)/2;
 200         NTDLL_mergesort( arr, barr, elemsize, compar, left, m);
 201         NTDLL_mergesort( arr, barr, elemsize, compar, m+1, right);
 202
 203 #define X(a,i) ((char*)a+elemsize*(i))
 204         for (k=left, i=left, j=m+1; i<=m && j<=right; k++) {
 205             if (compar(X(arr, i), X(arr,j)) <= 0) {
 206                 memcpy(X(barr,k), X(arr, i), elemsize);
 207                 i++;
 208             } else {
 209                 memcpy(X(barr,k), X(arr, j), elemsize);
 210                 j++;
 211             }
 212         }
 213         if (i<=m)
 214             memcpy(X(barr,k), X(arr,i), (m-i+1)*elemsize);
 215         else
 216             memcpy(X(barr,k), X(arr,j), (right-j+1)*elemsize);
 217
 218         memcpy(X(arr, left), X(barr, left), (right-left+1)*elemsize);
 219     }
 220 #undef X
 221 }
 222
 223 /*********************************************************************
 224  *                  qsort   (NTDLL.@)
 225  */
 226 void __cdecl qsort( void *base, size_t nmemb, size_t size,
 227                     int (__cdecl *compar)(const void *, const void *) )
 228 {
 229     void *secondarr;
 230     if (nmemb < 2 || size == 0) return;
 231     secondarr = RtlAllocateHeap (GetProcessHeap(), 0, nmemb*size);
 232     NTDLL_mergesort( base, secondarr, size, compar, 0, nmemb-1 );
 233     RtlFreeHeap (GetProcessHeap(),0, secondarr);
 234 }
 235
 236 /*********************************************************************
 237  *                  bsearch   (NTDLL.@)
 238  */
 239 void * __cdecl bsearch( const void *key, const void *base, size_t nmemb,
 240                         size_t size, int (__cdecl *compar)(const void *, const void *) )
 241 {
 242     ssize_t min = 0;
 243     ssize_t max = nmemb - 1;
 244
 245     while (min <= max)
 246     {
 247         ssize_t cursor = min + (max - min) / 2;
 248         int ret = compar(key,(const char *)base+(cursor*size));
 249         if (!ret)
 250             return (char*)base+(cursor*size);
 251         if (ret < 0)
 252             max = cursor - 1;
 253         else
 254             min = cursor + 1;
 255     }
 256     return NULL;
 257 }
 258
 259
 260 /*********************************************************************
 261  *                  _lfind   (NTDLL.@)
 262  */
 263 void * __cdecl _lfind( const void *key, const void *base, unsigned int *nmemb,
 264                        size_t size, int(__cdecl *compar)(const void *, const void *) )
 265 {
 266     size_t i, n = *nmemb;
 267
 268     for (i=0;i<n;i++)
 269         if (!compar(key,(char*)base+(size*i)))
 270             return (char*)base+(size*i);
 271     return NULL;
 272 }
 273
 274 /******************************************************************************
 275  *                  WinSqmEndSession   (NTDLL.@)
 276  */
 277 NTSTATUS WINAPI WinSqmEndSession(HANDLE session)
 278 {
 279     FIXME("(%p): stub\n", session);
 280     return STATUS_NOT_IMPLEMENTED;
 281 }
 282
 283 /*********************************************************************
 284  *          WinSqmIncrementDWORD (NTDLL.@)
 285  */
 286 void WINAPI WinSqmIncrementDWORD(DWORD unk1, DWORD unk2, DWORD unk3)
 287 {
 288     FIXME("(%d, %d, %d): stub\n", unk1, unk2, unk3);
 289 }
 290
 291 /*********************************************************************
 292  *                  WinSqmIsOptedIn   (NTDLL.@)
 293  */
 294 BOOL WINAPI WinSqmIsOptedIn(void)
 295 {
 296     FIXME("(): stub\n");
 297     return FALSE;
 298 }
 299
 300 /******************************************************************************
 301  *                  WinSqmStartSession   (NTDLL.@)
 302  */
 303 HANDLE WINAPI WinSqmStartSession(GUID *sessionguid, DWORD sessionid, DWORD unknown1)
 304 {
 305     FIXME("(%p, 0x%x, 0x%x): stub\n", sessionguid, sessionid, unknown1);
 306     return INVALID_HANDLE_VALUE;
 307 }
 308
 309 /***********************************************************************
 310  *          WinSqmSetDWORD (NTDLL.@)
 311  */
 312 void WINAPI WinSqmSetDWORD(HANDLE session, DWORD datapoint_id, DWORD datapoint_value)
 313 {
 314     FIXME("(%p, %d, %d): stub\n", session, datapoint_id, datapoint_value);
 315 }
 316
 317 /******************************************************************************
 318  *                  EtwEventActivityIdControl (NTDLL.@)
 319  */
 320 ULONG WINAPI EtwEventActivityIdControl(ULONG code, GUID *guid)
 321 {
 322     static int once;
 323
 324     if (!once++) FIXME("0x%x, %p: stub\n", code, guid);
 325     return ERROR_SUCCESS;
 326 }
 327
 328 /******************************************************************************
 329  *                  EtwEventProviderEnabled (NTDLL.@)
 330  */
 331 BOOLEAN WINAPI EtwEventProviderEnabled( REGHANDLE handle, UCHAR level, ULONGLONG keyword )
 332 {
 333     WARN("%s, %u, %s: stub\n", wine_dbgstr_longlong(handle), level, wine_dbgstr_longlong(keyword));
 334     return FALSE;
 335 }
 336
 337 /******************************************************************************
 338  *                  EtwEventRegister (NTDLL.@)
 339  */
 340 ULONG WINAPI EtwEventRegister( LPCGUID provider, PENABLECALLBACK callback, PVOID context,
 341                 PREGHANDLE handle )
 342 {
 343     WARN("(%s, %p, %p, %p) stub.\n", debugstr_guid(provider), callback, context, handle);
 344
 345     if (!handle) return ERROR_INVALID_PARAMETER;
 346
 347     *handle = 0xdeadbeef;
 348     return ERROR_SUCCESS;
 349 }
 350
 351 /******************************************************************************
 352  *                  EtwEventUnregister (NTDLL.@)
 353  */
 354 ULONG WINAPI EtwEventUnregister( REGHANDLE handle )
 355 {
 356     WARN("(%s) stub.\n", wine_dbgstr_longlong(handle));
 357     return ERROR_SUCCESS;
 358 }
 359
 360 /*********************************************************************
 361  *                  EtwEventSetInformation   (NTDLL.@)
 362  */
 363 ULONG WINAPI EtwEventSetInformation( REGHANDLE handle, EVENT_INFO_CLASS class, void *info,
 364                                      ULONG length )
 365 {
 366     FIXME("(%s, %u, %p, %u) stub\n", wine_dbgstr_longlong(handle), class, info, length);
 367     return ERROR_SUCCESS;
 368 }
 369
 370 /******************************************************************************
 371  *                  EtwEventWriteString   (NTDLL.@)
 372  */
 373 ULONG WINAPI EtwEventWriteString( REGHANDLE handle, UCHAR level, ULONGLONG keyword, PCWSTR string )
 374 {
 375     FIXME("%s, %u, %s, %s: stub\n", wine_dbgstr_longlong(handle), level,
 376           wine_dbgstr_longlong(keyword), debugstr_w(string));
 377     return ERROR_SUCCESS;
 378 }
 379
 380 /******************************************************************************
 381  *                  EtwEventWriteTransfer   (NTDLL.@)
 382  */
 383 ULONG WINAPI EtwEventWriteTransfer( REGHANDLE handle, PCEVENT_DESCRIPTOR descriptor, LPCGUID activity,
 384                                     LPCGUID related, ULONG count, PEVENT_DATA_DESCRIPTOR data )
 385 {
 386     FIXME("%s, %p, %s, %s, %u, %p: stub\n", wine_dbgstr_longlong(handle), descriptor,
 387           debugstr_guid(activity), debugstr_guid(related), count, data);
 388     return ERROR_SUCCESS;
 389 }
 390
 391 /******************************************************************************
 392  *                  EtwRegisterTraceGuidsW (NTDLL.@)
 393  *
 394  * Register an event trace provider and the event trace classes that it uses
 395  * to generate events.
 396  *
 397  * PARAMS
 398  *  RequestAddress     [I]   ControlCallback function
 399  *  RequestContext     [I]   Optional provider-defined context
 400  *  ControlGuid        [I]   GUID of the registering provider
 401  *  GuidCount          [I]   Number of elements in the TraceGuidReg array
 402  *  TraceGuidReg       [I/O] Array of TRACE_GUID_REGISTRATION structures
 403  *  MofImagePath       [I]   not supported, set to NULL
 404  *  MofResourceName    [I]   not supported, set to NULL
 405  *  RegistrationHandle [O]   Provider's registration handle
 406  *
 407  * RETURNS
 408  *  Success: ERROR_SUCCESS
 409  *  Failure: System error code
 410  */
 411 ULONG WINAPI EtwRegisterTraceGuidsW( WMIDPREQUEST RequestAddress,
 412                 void *RequestContext, const GUID *ControlGuid, ULONG GuidCount,
 413                 TRACE_GUID_REGISTRATION *TraceGuidReg, const WCHAR *MofImagePath,
 414                 const WCHAR *MofResourceName, TRACEHANDLE *RegistrationHandle )
 415 {
 416     WARN("(%p, %p, %s, %u, %p, %s, %s, %p): stub\n", RequestAddress, RequestContext,
 417           debugstr_guid(ControlGuid), GuidCount, TraceGuidReg, debugstr_w(MofImagePath),
 418           debugstr_w(MofResourceName), RegistrationHandle);
 419
 420     if (TraceGuidReg)
 421     {
 422         ULONG i;
 423         for (i = 0; i < GuidCount; i++)
 424         {
 425             FIXME("  register trace class %s\n", debugstr_guid(TraceGuidReg[i].Guid));
 426             TraceGuidReg[i].RegHandle = (HANDLE)0xdeadbeef;
 427         }
 428     }
 429     *RegistrationHandle = (TRACEHANDLE)0xdeadbeef;
 430     return ERROR_SUCCESS;
 431 }
 432
 433 /******************************************************************************
 434  *                  EtwRegisterTraceGuidsA (NTDLL.@)
 435  */
 436 ULONG WINAPI EtwRegisterTraceGuidsA( WMIDPREQUEST RequestAddress,
 437                 void *RequestContext, const GUID *ControlGuid, ULONG GuidCount,
 438                 TRACE_GUID_REGISTRATION *TraceGuidReg, const char *MofImagePath,
 439                 const char *MofResourceName, TRACEHANDLE *RegistrationHandle )
 440 {
 441     WARN("(%p, %p, %s, %u, %p, %s, %s, %p): stub\n", RequestAddress, RequestContext,
 442           debugstr_guid(ControlGuid), GuidCount, TraceGuidReg, debugstr_a(MofImagePath),
 443           debugstr_a(MofResourceName), RegistrationHandle);
 444     return ERROR_SUCCESS;
 445 }
 446
 447 /******************************************************************************
 448  *                  EtwUnregisterTraceGuids (NTDLL.@)
 449  */
 450 ULONG WINAPI EtwUnregisterTraceGuids( TRACEHANDLE RegistrationHandle )
 451 {
 452     if (!RegistrationHandle)
 453          return ERROR_INVALID_PARAMETER;
 454
 455     WARN("%s: stub\n", wine_dbgstr_longlong(RegistrationHandle));
 456     return ERROR_SUCCESS;
 457 }
 458
 459 /******************************************************************************
 460  *                  EtwEventEnabled (NTDLL.@)
 461  */
 462 BOOLEAN WINAPI EtwEventEnabled( REGHANDLE handle, const EVENT_DESCRIPTOR *descriptor )
 463 {
 464     WARN("(%s, %p): stub\n", wine_dbgstr_longlong(handle), descriptor);
 465     return FALSE;
 466 }
 467
 468 /******************************************************************************
 469  *                  EtwEventWrite (NTDLL.@)
 470  */
 471 ULONG WINAPI EtwEventWrite( REGHANDLE handle, const EVENT_DESCRIPTOR *descriptor, ULONG count,
 472     EVENT_DATA_DESCRIPTOR *data )
 473 {
 474     FIXME("(%s, %p, %u, %p): stub\n", wine_dbgstr_longlong(handle), descriptor, count, data);
 475     return ERROR_SUCCESS;
 476 }
 477
 478 /******************************************************************************
 479  *                  EtwGetTraceEnableFlags (NTDLL.@)
 480  */
 481 ULONG WINAPI EtwGetTraceEnableFlags( TRACEHANDLE handle )
 482 {
 483     FIXME("(%s) stub\n", wine_dbgstr_longlong(handle));
 484     return 0;
 485 }
 486
 487 /******************************************************************************
 488  *                  EtwGetTraceEnableLevel (NTDLL.@)
 489  */
 490 UCHAR WINAPI EtwGetTraceEnableLevel( TRACEHANDLE handle )
 491 {
 492     FIXME("(%s) stub\n", wine_dbgstr_longlong(handle));
 493     return TRACE_LEVEL_VERBOSE;
 494 }
 495
 496 /******************************************************************************
 497  *                  EtwGetTraceLoggerHandle (NTDLL.@)
 498  */
 499 TRACEHANDLE WINAPI EtwGetTraceLoggerHandle( PVOID buf )
 500 {
 501     FIXME("(%p) stub\n", buf);
 502     return INVALID_PROCESSTRACE_HANDLE;
 503 }
 504
 505 /******************************************************************************
 506  *                  EtwLogTraceEvent (NTDLL.@)
 507  */
 508 ULONG WINAPI EtwLogTraceEvent( TRACEHANDLE SessionHandle, PEVENT_TRACE_HEADER EventTrace )
 509 {
 510     FIXME("%s %p\n", wine_dbgstr_longlong(SessionHandle), EventTrace);
 511     return ERROR_CALL_NOT_IMPLEMENTED;
 512 }
 513
 514 /******************************************************************************
 515  *                  EtwTraceMessageVa (NTDLL.@)
 516  */
 517 ULONG WINAPI EtwTraceMessageVa( TRACEHANDLE handle, ULONG flags, LPGUID guid, USHORT number,
 518                                 __ms_va_list args )
 519 {
 520     FIXME("(%s %x %s %d) : stub\n", wine_dbgstr_longlong(handle), flags, debugstr_guid(guid), number);
 521     return ERROR_SUCCESS;
 522 }
 523
 524 /******************************************************************************
 525  *                  EtwTraceMessage (NTDLL.@)
 526  */
 527 ULONG WINAPIV EtwTraceMessage( TRACEHANDLE handle, ULONG flags, LPGUID guid, /*USHORT*/ ULONG number, ... )
 528 {
 529     __ms_va_list valist;
 530     ULONG ret;
 531
 532     __ms_va_start( valist, number );
 533     ret = EtwTraceMessageVa( handle, flags, guid, number, valist );
 534     __ms_va_end( valist );
 535     return ret;
 536 }
 537
 538 /*********************************************************************
 539  *                  ApiSetQueryApiSetPresence   (NTDLL.@)
 540  */
 541 BOOL WINAPI ApiSetQueryApiSetPresence(const UNICODE_STRING *namespace, BOOLEAN *present)
 542 {
 543     FIXME("(%s, %p) stub!\n", debugstr_us(namespace), present);
 544
 545     if(present)
 546         *present = TRUE;
 547     return TRUE;
 548 }