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     *handle = 0xdeadbeef;
 407     return ERROR_SUCCESS;
 408 }
 409
 410 /******************************************************************************
 411  *                  EtwEventUnregister (NTDLL.@)
 412  */
 413 ULONG WINAPI EtwEventUnregister( REGHANDLE handle )
 414 {
 415     FIXME("(%s) stub.\n", wine_dbgstr_longlong(handle));
 416     return ERROR_SUCCESS;
 417 }
 418
 419 /*********************************************************************
 420  *                  EtwEventSetInformation   (NTDLL.@)
 421  */
 422 ULONG WINAPI EtwEventSetInformation( REGHANDLE handle, EVENT_INFO_CLASS class, void *info,
 423                                      ULONG length )
 424 {
 425     FIXME("(%s, %u, %p, %u) stub\n", wine_dbgstr_longlong(handle), class, info, length);
 426     return ERROR_SUCCESS;
 427 }
 428
 429 /******************************************************************************
 430  *                  EtwEventWriteTransfer   (NTDLL.@)
 431  */
 432 ULONG WINAPI EtwEventWriteTransfer( REGHANDLE handle, PCEVENT_DESCRIPTOR descriptor, LPCGUID activity,
 433                                     LPCGUID related, ULONG count, PEVENT_DATA_DESCRIPTOR data )
 434 {
 435     FIXME("%s, %p, %s, %s, %u, %p: stub\n", wine_dbgstr_longlong(handle), descriptor,
 436           debugstr_guid(activity), debugstr_guid(related), count, data);
 437     return ERROR_SUCCESS;
 438 }
 439
 440 /******************************************************************************
 441  *                  EtwRegisterTraceGuidsW (NTDLL.@)
 442  *
 443  * Register an event trace provider and the event trace classes that it uses
 444  * to generate events.
 445  *
 446  * PARAMS
 447  *  RequestAddress     [I]   ControlCallback function
 448  *  RequestContext     [I]   Optional provider-defined context
 449  *  ControlGuid        [I]   GUID of the registering provider
 450  *  GuidCount          [I]   Number of elements in the TraceGuidReg array
 451  *  TraceGuidReg       [I/O] Array of TRACE_GUID_REGISTRATION structures
 452  *  MofImagePath       [I]   not supported, set to NULL
 453  *  MofResourceName    [I]   not supported, set to NULL
 454  *  RegistrationHandle [O]   Provider's registration handle
 455  *
 456  * RETURNS
 457  *  Success: ERROR_SUCCESS
 458  *  Failure: System error code
 459  */
 460 ULONG WINAPI EtwRegisterTraceGuidsW( WMIDPREQUEST RequestAddress,
 461                 void *RequestContext, const GUID *ControlGuid, ULONG GuidCount,
 462                 TRACE_GUID_REGISTRATION *TraceGuidReg, const WCHAR *MofImagePath,
 463                 const WCHAR *MofResourceName, TRACEHANDLE *RegistrationHandle )
 464 {
 465     FIXME("(%p, %p, %s, %u, %p, %s, %s, %p): stub\n", RequestAddress, RequestContext,
 466           debugstr_guid(ControlGuid), GuidCount, TraceGuidReg, debugstr_w(MofImagePath),
 467           debugstr_w(MofResourceName), RegistrationHandle);
 468
 469     if (TraceGuidReg)
 470     {
 471         ULONG i;
 472         for (i = 0; i < GuidCount; i++)
 473         {
 474             FIXME("  register trace class %s\n", debugstr_guid(TraceGuidReg[i].Guid));
 475             TraceGuidReg[i].RegHandle = (HANDLE)0xdeadbeef;
 476         }
 477     }
 478     *RegistrationHandle = (TRACEHANDLE)0xdeadbeef;
 479     return ERROR_SUCCESS;
 480 }
 481
 482 /******************************************************************************
 483  *                  EtwRegisterTraceGuidsA (NTDLL.@)
 484  */
 485 ULONG WINAPI EtwRegisterTraceGuidsA( WMIDPREQUEST RequestAddress,
 486                 void *RequestContext, const GUID *ControlGuid, ULONG GuidCount,
 487                 TRACE_GUID_REGISTRATION *TraceGuidReg, const char *MofImagePath,
 488                 const char *MofResourceName, TRACEHANDLE *RegistrationHandle )
 489 {
 490     FIXME("(%p, %p, %s, %u, %p, %s, %s, %p): stub\n", RequestAddress, RequestContext,
 491           debugstr_guid(ControlGuid), GuidCount, TraceGuidReg, debugstr_a(MofImagePath),
 492           debugstr_a(MofResourceName), RegistrationHandle);
 493     return ERROR_SUCCESS;
 494 }
 495
 496 /******************************************************************************
 497  *                  EtwUnregisterTraceGuids (NTDLL.@)
 498  */
 499 ULONG WINAPI EtwUnregisterTraceGuids( TRACEHANDLE RegistrationHandle )
 500 {
 501     if (!RegistrationHandle)
 502          return ERROR_INVALID_PARAMETER;
 503
 504     FIXME("%s: stub\n", wine_dbgstr_longlong(RegistrationHandle));
 505     return ERROR_SUCCESS;
 506 }
 507
 508 /******************************************************************************
 509  *                  EtwEventEnabled (NTDLL.@)
 510  */
 511 BOOLEAN WINAPI EtwEventEnabled( REGHANDLE handle, const EVENT_DESCRIPTOR *descriptor )
 512 {
 513     FIXME("(%s, %p): stub\n", wine_dbgstr_longlong(handle), descriptor);
 514     return FALSE;
 515 }
 516
 517 /******************************************************************************
 518  *                  EtwEventWrite (NTDLL.@)
 519  */
 520 ULONG WINAPI EtwEventWrite( REGHANDLE handle, const EVENT_DESCRIPTOR *descriptor, ULONG count,
 521     EVENT_DATA_DESCRIPTOR *data )
 522 {
 523     FIXME("(%s, %p, %u, %p): stub\n", wine_dbgstr_longlong(handle), descriptor, count, data);
 524     return ERROR_SUCCESS;
 525 }
 526
 527 /******************************************************************************
 528  *                  EtwGetTraceEnableFlags (NTDLL.@)
 529  */
 530 ULONG WINAPI EtwGetTraceEnableFlags( TRACEHANDLE handle )
 531 {
 532     FIXME("(%s) stub\n", wine_dbgstr_longlong(handle));
 533     return 0;
 534 }
 535
 536 /******************************************************************************
 537  *                  EtwGetTraceEnableLevel (NTDLL.@)
 538  */
 539 UCHAR WINAPI EtwGetTraceEnableLevel( TRACEHANDLE handle )
 540 {
 541     FIXME("(%s) stub\n", wine_dbgstr_longlong(handle));
 542     return TRACE_LEVEL_VERBOSE;
 543 }
 544
 545 /******************************************************************************
 546  *                  EtwGetTraceLoggerHandle (NTDLL.@)
 547  */
 548 TRACEHANDLE WINAPI EtwGetTraceLoggerHandle( PVOID buf )
 549 {
 550     FIXME("(%p) stub\n", buf);
 551     return INVALID_PROCESSTRACE_HANDLE;
 552 }
 553
 554 /******************************************************************************
 555  *                  EtwLogTraceEvent (NTDLL.@)
 556  */
 557 ULONG WINAPI EtwLogTraceEvent( TRACEHANDLE SessionHandle, PEVENT_TRACE_HEADER EventTrace )
 558 {
 559     FIXME("%s %p\n", wine_dbgstr_longlong(SessionHandle), EventTrace);
 560     return ERROR_CALL_NOT_IMPLEMENTED;
 561 }
 562
 563 /******************************************************************************
 564  *                  EtwTraceMessageVa (NTDLL.@)
 565  */
 566 ULONG WINAPI EtwTraceMessageVa( TRACEHANDLE handle, ULONG flags, LPGUID guid, USHORT number,
 567                                 __ms_va_list args )
 568 {
 569     FIXME("(%s %x %s %d) : stub\n", wine_dbgstr_longlong(handle), flags, debugstr_guid(guid), number);
 570     return ERROR_SUCCESS;
 571 }
 572
 573 /******************************************************************************
 574  *                  EtwTraceMessage (NTDLL.@)
 575  */
 576 ULONG WINAPIV EtwTraceMessage( TRACEHANDLE handle, ULONG flags, LPGUID guid, USHORT number, ... )
 577 {
 578     __ms_va_list valist;
 579     ULONG ret;
 580
 581     __ms_va_start( valist, number );
 582     ret = EtwTraceMessageVa( handle, flags, guid, number, valist );
 583     __ms_va_end( valist );
 584     return ret;
 585 }
 586
 587 NTSTATUS WINAPI NtCreateLowBoxToken(HANDLE *token_handle, HANDLE existing_token_handle, ACCESS_MASK desired_access,
 588                                     OBJECT_ATTRIBUTES *object_attributes, SID *package_sid, ULONG capability_count,
 589                                     SID_AND_ATTRIBUTES *capabilities, ULONG handle_count, HANDLE *handle)
 590 {
 591     FIXME("(%p, %p, %x, %p, %p, %u, %p, %u, %p): stub\n", token_handle, existing_token_handle, desired_access,
 592             object_attributes, package_sid, capability_count, capabilities, handle_count, handle);
 593
 594     /* We need to return a NULL handle since later it will be passed to CloseHandle and that must not fail */
 595     *token_handle = NULL;
 596     return STATUS_SUCCESS;
 597 }
 598
 599 /*********************************************************************
 600  *                  ApiSetQueryApiSetPresence   (NTDLL.@)
 601  */
 602 BOOL WINAPI ApiSetQueryApiSetPresence(const UNICODE_STRING *namespace, BOOLEAN *present)
 603 {
 604     FIXME("(%s, %p) stub!\n", debugstr_us(namespace), present);
 605
 606     if(present)
 607         *present = TRUE;
 608     return TRUE;
 609 }