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 "config.h"
  23
  24 #include <time.h>
  25 #include <math.h>
  26
  27 #include "ntstatus.h"
  28 #define WIN32_NO_STATUS
  29 #include "wine/debug.h"
  30 #include "ntdll_misc.h"
  31 #include "wmistr.h"
  32 #include "evntrace.h"
  33 #include "evntprov.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
  36
  37 LPCSTR debugstr_ObjectAttributes(const OBJECT_ATTRIBUTES *oa)
  38 {
  39     if (!oa) return "<null>";
  40     return wine_dbg_sprintf( "{name=%s, attr=0x%08x, hRoot=%p, sd=%p}\n",
  41                              debugstr_us(oa->ObjectName), oa->Attributes,
  42                              oa->RootDirectory, oa->SecurityDescriptor );
  43 }
  44
  45 LPCSTR debugstr_us( const UNICODE_STRING *us )
  46 {
  47     if (!us) return "<null>";
  48     return debugstr_wn(us->Buffer, us->Length / sizeof(WCHAR));
  49 }
  50
  51 /*********************************************************************
  52  *                  wine_get_version   (NTDLL.@)
  53  */
  54 const char * CDECL NTDLL_wine_get_version(void)
  55 {
  56     return unix_funcs->get_version();
  57 }
  58
  59 /*********************************************************************
  60  *                  wine_get_build_id   (NTDLL.@)
  61  */
  62 const char * CDECL NTDLL_wine_get_build_id(void)
  63 {
  64     return unix_funcs->get_build_id();
  65 }
  66
  67 /*********************************************************************
  68  *                  wine_get_host_version   (NTDLL.@)
  69  */
  70 void CDECL NTDLL_wine_get_host_version( const char **sysname, const char **release )
  71 {
  72     return unix_funcs->get_host_version( sysname, release );
  73 }
  74
  75 /*********************************************************************
  76  *                  abs   (NTDLL.@)
  77  */
  78 int CDECL NTDLL_abs( int i )
  79 {
  80     return abs( i );
  81 }
  82
  83 /*********************************************************************
  84  *                  labs   (NTDLL.@)
  85  */
  86 LONG CDECL NTDLL_labs( LONG i )
  87 {
  88     return labs( i );
  89 }
  90
  91 /*********************************************************************
  92  *                  atan   (NTDLL.@)
  93  */
  94 double CDECL NTDLL_atan( double d )
  95 {
  96     return atan( d );
  97 }
  98
  99 /*********************************************************************
 100  *                  ceil   (NTDLL.@)
 101  */
 102 double CDECL NTDLL_ceil( double d )
 103 {
 104     return ceil( d );
 105 }
 106
 107 /*********************************************************************
 108  *                  cos   (NTDLL.@)
 109  */
 110 double CDECL NTDLL_cos( double d )
 111 {
 112     return cos( d );
 113 }
 114
 115 /*********************************************************************
 116  *                  fabs   (NTDLL.@)
 117  */
 118 double CDECL NTDLL_fabs( double d )
 119 {
 120     return fabs( d );
 121 }
 122
 123 /*********************************************************************
 124  *                  floor   (NTDLL.@)
 125  */
 126 double CDECL NTDLL_floor( double d )
 127 {
 128     return floor( d );
 129 }
 130
 131 /*********************************************************************
 132  *                  log   (NTDLL.@)
 133  */
 134 double CDECL NTDLL_log( double d )
 135 {
 136     return log( d );
 137 }
 138
 139 /*********************************************************************
 140  *                  pow   (NTDLL.@)
 141  */
 142 double CDECL NTDLL_pow( double x, double y )
 143 {
 144     return pow( x, y );
 145 }
 146
 147 /*********************************************************************
 148  *                  sin   (NTDLL.@)
 149  */
 150 double CDECL NTDLL_sin( double d )
 151 {
 152     return sin( d );
 153 }
 154
 155 /*********************************************************************
 156  *                  sqrt   (NTDLL.@)
 157  */
 158 double CDECL NTDLL_sqrt( double d )
 159 {
 160     return sqrt( d );
 161 }
 162
 163 /*********************************************************************
 164  *                  tan   (NTDLL.@)
 165  */
 166 double CDECL NTDLL_tan( double d )
 167 {
 168     return tan( d );
 169 }
 170
 171 #if defined(__GNUC__) && defined(__i386__)
 172
 173 #define FPU_DOUBLE(var) double var; \
 174     __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var) : )
 175 #define FPU_DOUBLES(var1,var2) double var1,var2; \
 176     __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var2) : ); \
 177     __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var1) : )
 178
 179 /*********************************************************************
 180  *              _CIcos (NTDLL.@)
 181  */
 182 double CDECL NTDLL__CIcos(void)
 183 {
 184     FPU_DOUBLE(x);
 185     return NTDLL_cos(x);
 186 }
 187
 188 /*********************************************************************
 189  *              _CIlog (NTDLL.@)
 190  */
 191 double CDECL NTDLL__CIlog(void)
 192 {
 193     FPU_DOUBLE(x);
 194     return NTDLL_log(x);
 195 }
 196
 197 /*********************************************************************
 198  *              _CIpow (NTDLL.@)
 199  */
 200 double CDECL NTDLL__CIpow(void)
 201 {
 202     FPU_DOUBLES(x,y);
 203     return NTDLL_pow(x,y);
 204 }
 205
 206 /*********************************************************************
 207  *              _CIsin (NTDLL.@)
 208  */
 209 double CDECL NTDLL__CIsin(void)
 210 {
 211     FPU_DOUBLE(x);
 212     return NTDLL_sin(x);
 213 }
 214
 215 /*********************************************************************
 216  *              _CIsqrt (NTDLL.@)
 217  */
 218 double CDECL NTDLL__CIsqrt(void)
 219 {
 220     FPU_DOUBLE(x);
 221     return NTDLL_sqrt(x);
 222 }
 223
 224 /*********************************************************************
 225  *                  _ftol   (NTDLL.@)
 226  */
 227 LONGLONG CDECL NTDLL__ftol(void)
 228 {
 229     FPU_DOUBLE(x);
 230     return (LONGLONG)x;
 231 }
 232
 233 #endif /* defined(__GNUC__) && defined(__i386__) */
 234
 235 static void
 236 NTDLL_mergesort( void *arr, void *barr, size_t elemsize, int(__cdecl *compar)(const void *, const void *),
 237                  size_t left, size_t right )
 238 {
 239     if(right>left) {
 240         size_t i, j, k, m;
 241         m=left+(right-left)/2;
 242         NTDLL_mergesort( arr, barr, elemsize, compar, left, m);
 243         NTDLL_mergesort( arr, barr, elemsize, compar, m+1, right);
 244
 245 #define X(a,i) ((char*)a+elemsize*(i))
 246         for (k=left, i=left, j=m+1; i<=m && j<=right; k++) {
 247             if (compar(X(arr, i), X(arr,j)) <= 0) {
 248                 memcpy(X(barr,k), X(arr, i), elemsize);
 249                 i++;
 250             } else {
 251                 memcpy(X(barr,k), X(arr, j), elemsize);
 252                 j++;
 253             }
 254         }
 255         if (i<=m)
 256             memcpy(X(barr,k), X(arr,i), (m-i+1)*elemsize);
 257         else
 258             memcpy(X(barr,k), X(arr,j), (right-j+1)*elemsize);
 259
 260         memcpy(X(arr, left), X(barr, left), (right-left+1)*elemsize);
 261     }
 262 #undef X
 263 }
 264
 265 /*********************************************************************
 266  *                  qsort   (NTDLL.@)
 267  */
 268 void __cdecl NTDLL_qsort( void *base, size_t nmemb, size_t size,
 269                           int(__cdecl *compar)(const void *, const void *) )
 270 {
 271     void *secondarr;
 272     if (nmemb < 2 || size == 0) return;
 273     secondarr = RtlAllocateHeap (GetProcessHeap(), 0, nmemb*size);
 274     NTDLL_mergesort( base, secondarr, size, compar, 0, nmemb-1 );
 275     RtlFreeHeap (GetProcessHeap(),0, secondarr);
 276 }
 277
 278 /*********************************************************************
 279  *                  bsearch   (NTDLL.@)
 280  */
 281 void * __cdecl
 282 NTDLL_bsearch( const void *key, const void *base, size_t nmemb,
 283                size_t size, int (__cdecl *compar)(const void *, const void *) )
 284 {
 285     ssize_t min = 0;
 286     ssize_t max = nmemb - 1;
 287
 288     while (min <= max)
 289     {
 290         ssize_t cursor = min + (max - min) / 2;
 291         int ret = compar(key,(const char *)base+(cursor*size));
 292         if (!ret)
 293             return (char*)base+(cursor*size);
 294         if (ret < 0)
 295             max = cursor - 1;
 296         else
 297             min = cursor + 1;
 298     }
 299     return NULL;
 300 }
 301
 302
 303 /*********************************************************************
 304  *                  _lfind   (NTDLL.@)
 305  */
 306 void * __cdecl _lfind( const void *key, const void *base, unsigned int *nmemb,
 307                        size_t size, int(__cdecl *compar)(const void *, const void *) )
 308 {
 309     size_t i, n = *nmemb;
 310
 311     for (i=0;i<n;i++)
 312         if (!compar(key,(char*)base+(size*i)))
 313             return (char*)base+(size*i);
 314     return NULL;
 315 }
 316
 317 /******************************************************************************
 318  *                  WinSqmEndSession   (NTDLL.@)
 319  */
 320 NTSTATUS WINAPI WinSqmEndSession(HANDLE session)
 321 {
 322     FIXME("(%p): stub\n", session);
 323     return STATUS_NOT_IMPLEMENTED;
 324 }
 325
 326 /*********************************************************************
 327  *          WinSqmIncrementDWORD (NTDLL.@)
 328  */
 329 void WINAPI WinSqmIncrementDWORD(DWORD unk1, DWORD unk2, DWORD unk3)
 330 {
 331     FIXME("(%d, %d, %d): stub\n", unk1, unk2, unk3);
 332 }
 333
 334 /*********************************************************************
 335  *                  WinSqmIsOptedIn   (NTDLL.@)
 336  */
 337 BOOL WINAPI WinSqmIsOptedIn(void)
 338 {
 339     FIXME("(): stub\n");
 340     return FALSE;
 341 }
 342
 343 /******************************************************************************
 344  *                  WinSqmStartSession   (NTDLL.@)
 345  */
 346 HANDLE WINAPI WinSqmStartSession(GUID *sessionguid, DWORD sessionid, DWORD unknown1)
 347 {
 348     FIXME("(%p, 0x%x, 0x%x): stub\n", sessionguid, sessionid, unknown1);
 349     return INVALID_HANDLE_VALUE;
 350 }
 351
 352 /***********************************************************************
 353  *          WinSqmSetDWORD (NTDLL.@)
 354  */
 355 void WINAPI WinSqmSetDWORD(HANDLE session, DWORD datapoint_id, DWORD datapoint_value)
 356 {
 357     FIXME("(%p, %d, %d): stub\n", session, datapoint_id, datapoint_value);
 358 }
 359
 360 /******************************************************************************
 361  *                  EtwEventActivityIdControl (NTDLL.@)
 362  */
 363 ULONG WINAPI EtwEventActivityIdControl(ULONG code, GUID *guid)
 364 {
 365     static int once;
 366
 367     if (!once++) FIXME("0x%x, %p: stub\n", code, guid);
 368     return ERROR_SUCCESS;
 369 }
 370
 371 /******************************************************************************
 372  *                  EtwEventProviderEnabled (NTDLL.@)
 373  */
 374 BOOLEAN WINAPI EtwEventProviderEnabled( REGHANDLE handle, UCHAR level, ULONGLONG keyword )
 375 {
 376     FIXME("%s, %u, %s: stub\n", wine_dbgstr_longlong(handle), level, wine_dbgstr_longlong(keyword));
 377     return FALSE;
 378 }
 379
 380 /******************************************************************************
 381  *                  EtwEventRegister (NTDLL.@)
 382  */
 383 ULONG WINAPI EtwEventRegister( LPCGUID provider, PENABLECALLBACK callback, PVOID context,
 384                 PREGHANDLE handle )
 385 {
 386     FIXME("(%s, %p, %p, %p) stub.\n", debugstr_guid(provider), callback, context, handle);
 387
 388     if (!handle) return ERROR_INVALID_PARAMETER;
 389
 390     *handle = 0xdeadbeef;
 391     return ERROR_SUCCESS;
 392 }
 393
 394 /******************************************************************************
 395  *                  EtwEventUnregister (NTDLL.@)
 396  */
 397 ULONG WINAPI EtwEventUnregister( REGHANDLE handle )
 398 {
 399     FIXME("(%s) stub.\n", wine_dbgstr_longlong(handle));
 400     return ERROR_SUCCESS;
 401 }
 402
 403 /*********************************************************************
 404  *                  EtwEventSetInformation   (NTDLL.@)
 405  */
 406 ULONG WINAPI EtwEventSetInformation( REGHANDLE handle, EVENT_INFO_CLASS class, void *info,
 407                                      ULONG length )
 408 {
 409     FIXME("(%s, %u, %p, %u) stub\n", wine_dbgstr_longlong(handle), class, info, length);
 410     return ERROR_SUCCESS;
 411 }
 412
 413 /******************************************************************************
 414  *                  EtwEventWriteString   (NTDLL.@)
 415  */
 416 ULONG WINAPI EtwEventWriteString( REGHANDLE handle, UCHAR level, ULONGLONG keyword, PCWSTR string )
 417 {
 418     FIXME("%s, %u, %s, %s: stub\n", wine_dbgstr_longlong(handle), level,
 419           wine_dbgstr_longlong(keyword), debugstr_w(string));
 420     return ERROR_SUCCESS;
 421 }
 422
 423 /******************************************************************************
 424  *                  EtwEventWriteTransfer   (NTDLL.@)
 425  */
 426 ULONG WINAPI EtwEventWriteTransfer( REGHANDLE handle, PCEVENT_DESCRIPTOR descriptor, LPCGUID activity,
 427                                     LPCGUID related, ULONG count, PEVENT_DATA_DESCRIPTOR data )
 428 {
 429     FIXME("%s, %p, %s, %s, %u, %p: stub\n", wine_dbgstr_longlong(handle), descriptor,
 430           debugstr_guid(activity), debugstr_guid(related), count, data);
 431     return ERROR_SUCCESS;
 432 }
 433
 434 /******************************************************************************
 435  *                  EtwRegisterTraceGuidsW (NTDLL.@)
 436  *
 437  * Register an event trace provider and the event trace classes that it uses
 438  * to generate events.
 439  *
 440  * PARAMS
 441  *  RequestAddress     [I]   ControlCallback function
 442  *  RequestContext     [I]   Optional provider-defined context
 443  *  ControlGuid        [I]   GUID of the registering provider
 444  *  GuidCount          [I]   Number of elements in the TraceGuidReg array
 445  *  TraceGuidReg       [I/O] Array of TRACE_GUID_REGISTRATION structures
 446  *  MofImagePath       [I]   not supported, set to NULL
 447  *  MofResourceName    [I]   not supported, set to NULL
 448  *  RegistrationHandle [O]   Provider's registration handle
 449  *
 450  * RETURNS
 451  *  Success: ERROR_SUCCESS
 452  *  Failure: System error code
 453  */
 454 ULONG WINAPI EtwRegisterTraceGuidsW( WMIDPREQUEST RequestAddress,
 455                 void *RequestContext, const GUID *ControlGuid, ULONG GuidCount,
 456                 TRACE_GUID_REGISTRATION *TraceGuidReg, const WCHAR *MofImagePath,
 457                 const WCHAR *MofResourceName, TRACEHANDLE *RegistrationHandle )
 458 {
 459     FIXME("(%p, %p, %s, %u, %p, %s, %s, %p): stub\n", RequestAddress, RequestContext,
 460           debugstr_guid(ControlGuid), GuidCount, TraceGuidReg, debugstr_w(MofImagePath),
 461           debugstr_w(MofResourceName), RegistrationHandle);
 462
 463     if (TraceGuidReg)
 464     {
 465         ULONG i;
 466         for (i = 0; i < GuidCount; i++)
 467         {
 468             FIXME("  register trace class %s\n", debugstr_guid(TraceGuidReg[i].Guid));
 469             TraceGuidReg[i].RegHandle = (HANDLE)0xdeadbeef;
 470         }
 471     }
 472     *RegistrationHandle = (TRACEHANDLE)0xdeadbeef;
 473     return ERROR_SUCCESS;
 474 }
 475
 476 /******************************************************************************
 477  *                  EtwRegisterTraceGuidsA (NTDLL.@)
 478  */
 479 ULONG WINAPI EtwRegisterTraceGuidsA( WMIDPREQUEST RequestAddress,
 480                 void *RequestContext, const GUID *ControlGuid, ULONG GuidCount,
 481                 TRACE_GUID_REGISTRATION *TraceGuidReg, const char *MofImagePath,
 482                 const char *MofResourceName, TRACEHANDLE *RegistrationHandle )
 483 {
 484     FIXME("(%p, %p, %s, %u, %p, %s, %s, %p): stub\n", RequestAddress, RequestContext,
 485           debugstr_guid(ControlGuid), GuidCount, TraceGuidReg, debugstr_a(MofImagePath),
 486           debugstr_a(MofResourceName), RegistrationHandle);
 487     return ERROR_SUCCESS;
 488 }
 489
 490 /******************************************************************************
 491  *                  EtwUnregisterTraceGuids (NTDLL.@)
 492  */
 493 ULONG WINAPI EtwUnregisterTraceGuids( TRACEHANDLE RegistrationHandle )
 494 {
 495     if (!RegistrationHandle)
 496          return ERROR_INVALID_PARAMETER;
 497
 498     FIXME("%s: stub\n", wine_dbgstr_longlong(RegistrationHandle));
 499     return ERROR_SUCCESS;
 500 }
 501
 502 /******************************************************************************
 503  *                  EtwEventEnabled (NTDLL.@)
 504  */
 505 BOOLEAN WINAPI EtwEventEnabled( REGHANDLE handle, const EVENT_DESCRIPTOR *descriptor )
 506 {
 507     FIXME("(%s, %p): stub\n", wine_dbgstr_longlong(handle), descriptor);
 508     return FALSE;
 509 }
 510
 511 /******************************************************************************
 512  *                  EtwEventWrite (NTDLL.@)
 513  */
 514 ULONG WINAPI EtwEventWrite( REGHANDLE handle, const EVENT_DESCRIPTOR *descriptor, ULONG count,
 515     EVENT_DATA_DESCRIPTOR *data )
 516 {
 517     FIXME("(%s, %p, %u, %p): stub\n", wine_dbgstr_longlong(handle), descriptor, count, data);
 518     return ERROR_SUCCESS;
 519 }
 520
 521 /******************************************************************************
 522  *                  EtwGetTraceEnableFlags (NTDLL.@)
 523  */
 524 ULONG WINAPI EtwGetTraceEnableFlags( TRACEHANDLE handle )
 525 {
 526     FIXME("(%s) stub\n", wine_dbgstr_longlong(handle));
 527     return 0;
 528 }
 529
 530 /******************************************************************************
 531  *                  EtwGetTraceEnableLevel (NTDLL.@)
 532  */
 533 UCHAR WINAPI EtwGetTraceEnableLevel( TRACEHANDLE handle )
 534 {
 535     FIXME("(%s) stub\n", wine_dbgstr_longlong(handle));
 536     return TRACE_LEVEL_VERBOSE;
 537 }
 538
 539 /******************************************************************************
 540  *                  EtwGetTraceLoggerHandle (NTDLL.@)
 541  */
 542 TRACEHANDLE WINAPI EtwGetTraceLoggerHandle( PVOID buf )
 543 {
 544     FIXME("(%p) stub\n", buf);
 545     return INVALID_PROCESSTRACE_HANDLE;
 546 }
 547
 548 /******************************************************************************
 549  *                  EtwLogTraceEvent (NTDLL.@)
 550  */
 551 ULONG WINAPI EtwLogTraceEvent( TRACEHANDLE SessionHandle, PEVENT_TRACE_HEADER EventTrace )
 552 {
 553     FIXME("%s %p\n", wine_dbgstr_longlong(SessionHandle), EventTrace);
 554     return ERROR_CALL_NOT_IMPLEMENTED;
 555 }
 556
 557 /******************************************************************************
 558  *                  EtwTraceMessageVa (NTDLL.@)
 559  */
 560 ULONG WINAPI EtwTraceMessageVa( TRACEHANDLE handle, ULONG flags, LPGUID guid, USHORT number,
 561                                 __ms_va_list args )
 562 {
 563     FIXME("(%s %x %s %d) : stub\n", wine_dbgstr_longlong(handle), flags, debugstr_guid(guid), number);
 564     return ERROR_SUCCESS;
 565 }
 566
 567 /******************************************************************************
 568  *                  EtwTraceMessage (NTDLL.@)
 569  */
 570 ULONG WINAPIV EtwTraceMessage( TRACEHANDLE handle, ULONG flags, LPGUID guid, USHORT number, ... )
 571 {
 572     __ms_va_list valist;
 573     ULONG ret;
 574
 575     __ms_va_start( valist, number );
 576     ret = EtwTraceMessageVa( handle, flags, guid, number, valist );
 577     __ms_va_end( valist );
 578     return ret;
 579 }
 580
 581 NTSTATUS WINAPI NtCreateLowBoxToken(HANDLE *token_handle, HANDLE existing_token_handle, ACCESS_MASK desired_access,
 582                                     OBJECT_ATTRIBUTES *object_attributes, SID *package_sid, ULONG capability_count,
 583                                     SID_AND_ATTRIBUTES *capabilities, ULONG handle_count, HANDLE *handle)
 584 {
 585     FIXME("(%p, %p, %x, %p, %p, %u, %p, %u, %p): stub\n", token_handle, existing_token_handle, desired_access,
 586             object_attributes, package_sid, capability_count, capabilities, handle_count, handle);
 587
 588     /* We need to return a NULL handle since later it will be passed to CloseHandle and that must not fail */
 589     *token_handle = NULL;
 590     return STATUS_SUCCESS;
 591 }
 592
 593 /*********************************************************************
 594  *                  ApiSetQueryApiSetPresence   (NTDLL.@)
 595  */
 596 BOOL WINAPI ApiSetQueryApiSetPresence(const UNICODE_STRING *namespace, BOOLEAN *present)
 597 {
 598     FIXME("(%s, %p) stub!\n", debugstr_us(namespace), present);
 599
 600     if(present)
 601         *present = TRUE;
 602     return TRUE;
 603 }