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