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  *                  EtwEventRegister (NTDLL.@)
 380  */
 381 ULONG WINAPI EtwEventRegister( LPCGUID provider, PENABLECALLBACK callback, PVOID context,
 382                 PREGHANDLE handle )
 383 {
 384     FIXME("(%s, %p, %p, %p) stub.\n", debugstr_guid(provider), callback, context, handle);
 385
 386     *handle = 0xdeadbeef;
 387     return ERROR_SUCCESS;
 388 }
 389
 390 /******************************************************************************
 391  *                  EtwEventUnregister (NTDLL.@)
 392  */
 393 ULONG WINAPI EtwEventUnregister( REGHANDLE handle )
 394 {
 395     FIXME("(%s) stub.\n", wine_dbgstr_longlong(handle));
 396     return ERROR_SUCCESS;
 397 }
 398
 399 /*********************************************************************
 400  *                  EtwEventSetInformation   (NTDLL.@)
 401  */
 402 ULONG WINAPI EtwEventSetInformation( REGHANDLE handle, EVENT_INFO_CLASS class, void *info,
 403                                      ULONG length )
 404 {
 405     FIXME("(%s, %u, %p, %u) stub\n", wine_dbgstr_longlong(handle), class, info, length);
 406     return ERROR_SUCCESS;
 407 }
 408
 409 /******************************************************************************
 410  *                  EtwRegisterTraceGuidsW (NTDLL.@)
 411  *
 412  * Register an event trace provider and the event trace classes that it uses
 413  * to generate events.
 414  *
 415  * PARAMS
 416  *  RequestAddress     [I]   ControlCallback function
 417  *  RequestContext     [I]   Optional provider-defined context
 418  *  ControlGuid        [I]   GUID of the registering provider
 419  *  GuidCount          [I]   Number of elements in the TraceGuidReg array
 420  *  TraceGuidReg       [I/O] Array of TRACE_GUID_REGISTRATION structures
 421  *  MofImagePath       [I]   not supported, set to NULL
 422  *  MofResourceName    [I]   not supported, set to NULL
 423  *  RegistrationHandle [O]   Provider's registration handle
 424  *
 425  * RETURNS
 426  *  Success: ERROR_SUCCESS
 427  *  Failure: System error code
 428  */
 429 ULONG WINAPI EtwRegisterTraceGuidsW( WMIDPREQUEST RequestAddress,
 430                 void *RequestContext, const GUID *ControlGuid, ULONG GuidCount,
 431                 TRACE_GUID_REGISTRATION *TraceGuidReg, const WCHAR *MofImagePath,
 432                 const WCHAR *MofResourceName, TRACEHANDLE *RegistrationHandle )
 433 {
 434     FIXME("(%p, %p, %s, %u, %p, %s, %s, %p): stub\n", RequestAddress, RequestContext,
 435           debugstr_guid(ControlGuid), GuidCount, TraceGuidReg, debugstr_w(MofImagePath),
 436           debugstr_w(MofResourceName), RegistrationHandle);
 437
 438     if (TraceGuidReg)
 439     {
 440         ULONG i;
 441         for (i = 0; i < GuidCount; i++)
 442         {
 443             FIXME("  register trace class %s\n", debugstr_guid(TraceGuidReg[i].Guid));
 444             TraceGuidReg[i].RegHandle = (HANDLE)0xdeadbeef;
 445         }
 446     }
 447     *RegistrationHandle = (TRACEHANDLE)0xdeadbeef;
 448     return ERROR_SUCCESS;
 449 }
 450
 451 /******************************************************************************
 452  *                  EtwRegisterTraceGuidsA (NTDLL.@)
 453  */
 454 ULONG WINAPI EtwRegisterTraceGuidsA( WMIDPREQUEST RequestAddress,
 455                 void *RequestContext, const GUID *ControlGuid, ULONG GuidCount,
 456                 TRACE_GUID_REGISTRATION *TraceGuidReg, const char *MofImagePath,
 457                 const char *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_a(MofImagePath),
 461           debugstr_a(MofResourceName), RegistrationHandle);
 462     return ERROR_SUCCESS;
 463 }
 464
 465 /******************************************************************************
 466  *                  EtwUnregisterTraceGuids (NTDLL.@)
 467  */
 468 ULONG WINAPI EtwUnregisterTraceGuids( TRACEHANDLE RegistrationHandle )
 469 {
 470     if (!RegistrationHandle)
 471          return ERROR_INVALID_PARAMETER;
 472
 473     FIXME("%s: stub\n", wine_dbgstr_longlong(RegistrationHandle));
 474     return ERROR_SUCCESS;
 475 }
 476
 477 /******************************************************************************
 478  *                  EtwEventEnabled (NTDLL.@)
 479  */
 480 BOOLEAN WINAPI EtwEventEnabled( REGHANDLE handle, const EVENT_DESCRIPTOR *descriptor )
 481 {
 482     FIXME("(%s, %p): stub\n", wine_dbgstr_longlong(handle), descriptor);
 483     return FALSE;
 484 }
 485
 486 /******************************************************************************
 487  *                  EtwEventWrite (NTDLL.@)
 488  */
 489 ULONG WINAPI EtwEventWrite( REGHANDLE handle, const EVENT_DESCRIPTOR *descriptor, ULONG count,
 490     EVENT_DATA_DESCRIPTOR *data )
 491 {
 492     FIXME("(%s, %p, %u, %p): stub\n", wine_dbgstr_longlong(handle), descriptor, count, data);
 493     return ERROR_SUCCESS;
 494 }
 495
 496 /***********************************************************************
 497  *                  DbgUiRemoteBreakin (NTDLL.@)
 498  */
 499 void WINAPI DbgUiRemoteBreakin( void *arg )
 500 {
 501     FIXME("stub\n");
 502 }
 503
 504 NTSTATUS WINAPI NtCreateLowBoxToken(HANDLE *token_handle, HANDLE existing_token_handle, ACCESS_MASK desired_access,
 505                                     OBJECT_ATTRIBUTES *object_attributes, SID *package_sid, ULONG capability_count,
 506                                     SID_AND_ATTRIBUTES *capabilities, ULONG handle_count, HANDLE *handle)
 507 {
 508     FIXME("(%p, %p, %x, %p, %p, %u, %p, %u, %p): stub\n", token_handle, existing_token_handle, desired_access,
 509             object_attributes, package_sid, capability_count, capabilities, handle_count, handle);
 510
 511     /* We need to return a NULL handle since later it will be passed to CloseHandle and that must not fail */
 512     *token_handle = NULL;
 513     return STATUS_SUCCESS;
 514 }
 515
 516 /*********************************************************************
 517  *                  ApiSetQueryApiSetPresence   (NTDLL.@)
 518  */
 519 BOOL WINAPI ApiSetQueryApiSetPresence(const UNICODE_STRING *namespace, BOOLEAN *present)
 520 {
 521     FIXME("(%s, %p) stub!\n", debugstr_us(namespace), present);
 522
 523     if(present)
 524         *present = TRUE;
 525     return TRUE;
 526 }