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  *                  WinSqmIsOptedIn   (NTDLL.@)
 346  */
 347 BOOL WINAPI WinSqmIsOptedIn(void)
 348 {
 349     FIXME("(): stub\n");
 350     return FALSE;
 351 }
 352
 353 /******************************************************************************
 354  *                  WinSqmStartSession   (NTDLL.@)
 355  */
 356 HANDLE WINAPI WinSqmStartSession(GUID *sessionguid, DWORD sessionid, DWORD unknown1)
 357 {
 358     FIXME("(%p, 0x%x, 0x%x): stub\n", sessionguid, sessionid, unknown1);
 359     return INVALID_HANDLE_VALUE;
 360 }
 361
 362 /******************************************************************************
 363  *                  EtwEventRegister (NTDLL.@)
 364  */
 365 ULONG WINAPI EtwEventRegister( LPCGUID provider, PENABLECALLBACK callback, PVOID context,
 366                 PREGHANDLE handle )
 367 {
 368     FIXME("(%s, %p, %p, %p) stub.\n", debugstr_guid(provider), callback, context, handle);
 369
 370     *handle = 0xdeadbeef;
 371     return ERROR_SUCCESS;
 372 }
 373
 374 /******************************************************************************
 375  *                  EtwEventUnregister (NTDLL.@)
 376  */
 377 ULONG WINAPI EtwEventUnregister( REGHANDLE handle )
 378 {
 379     FIXME("(%s) stub.\n", wine_dbgstr_longlong(handle));
 380     return ERROR_SUCCESS;
 381 }
 382
 383 /*********************************************************************
 384  *                  EtwEventSetInformation   (NTDLL.@)
 385  */
 386 ULONG WINAPI EtwEventSetInformation( REGHANDLE handle, EVENT_INFO_CLASS class, void *info,
 387                                      ULONG length )
 388 {
 389     FIXME("(%s, %u, %p, %u) stub\n", wine_dbgstr_longlong(handle), class, info, length);
 390     return ERROR_SUCCESS;
 391 }
 392
 393 /******************************************************************************
 394  *                  EtwRegisterTraceGuidsW (NTDLL.@)
 395  *
 396  * Register an event trace provider and the event trace classes that it uses
 397  * to generate events.
 398  *
 399  * PARAMS
 400  *  RequestAddress     [I]   ControlCallback function
 401  *  RequestContext     [I]   Optional provider-defined context
 402  *  ControlGuid        [I]   GUID of the registering provider
 403  *  GuidCount          [I]   Number of elements in the TraceGuidReg array
 404  *  TraceGuidReg       [I/O] Array of TRACE_GUID_REGISTRATION structures
 405  *  MofImagePath       [I]   not supported, set to NULL
 406  *  MofResourceName    [I]   not supported, set to NULL
 407  *  RegistrationHandle [O]   Provider's registration handle
 408  *
 409  * RETURNS
 410  *  Success: ERROR_SUCCESS
 411  *  Failure: System error code
 412  */
 413 ULONG WINAPI EtwRegisterTraceGuidsW( WMIDPREQUEST RequestAddress,
 414                 void *RequestContext, const GUID *ControlGuid, ULONG GuidCount,
 415                 TRACE_GUID_REGISTRATION *TraceGuidReg, const WCHAR *MofImagePath,
 416                 const WCHAR *MofResourceName, TRACEHANDLE *RegistrationHandle )
 417 {
 418     FIXME("(%p, %p, %s, %u, %p, %s, %s, %p): stub\n", RequestAddress, RequestContext,
 419           debugstr_guid(ControlGuid), GuidCount, TraceGuidReg, debugstr_w(MofImagePath),
 420           debugstr_w(MofResourceName), RegistrationHandle);
 421
 422     if (TraceGuidReg)
 423     {
 424         ULONG i;
 425         for (i = 0; i < GuidCount; i++)
 426         {
 427             FIXME("  register trace class %s\n", debugstr_guid(TraceGuidReg[i].Guid));
 428             TraceGuidReg[i].RegHandle = (HANDLE)0xdeadbeef;
 429         }
 430     }
 431     *RegistrationHandle = (TRACEHANDLE)0xdeadbeef;
 432     return ERROR_SUCCESS;
 433 }
 434
 435 /******************************************************************************
 436  *                  EtwRegisterTraceGuidsA (NTDLL.@)
 437  */
 438 ULONG WINAPI EtwRegisterTraceGuidsA( WMIDPREQUEST RequestAddress,
 439                 void *RequestContext, const GUID *ControlGuid, ULONG GuidCount,
 440                 TRACE_GUID_REGISTRATION *TraceGuidReg, const char *MofImagePath,
 441                 const char *MofResourceName, TRACEHANDLE *RegistrationHandle )
 442 {
 443     FIXME("(%p, %p, %s, %u, %p, %s, %s, %p): stub\n", RequestAddress, RequestContext,
 444           debugstr_guid(ControlGuid), GuidCount, TraceGuidReg, debugstr_a(MofImagePath),
 445           debugstr_a(MofResourceName), RegistrationHandle);
 446     return ERROR_SUCCESS;
 447 }
 448
 449 /******************************************************************************
 450  *                  EtwUnregisterTraceGuids (NTDLL.@)
 451  */
 452 ULONG WINAPI EtwUnregisterTraceGuids( TRACEHANDLE RegistrationHandle )
 453 {
 454     if (!RegistrationHandle)
 455          return ERROR_INVALID_PARAMETER;
 456
 457     FIXME("%s: stub\n", wine_dbgstr_longlong(RegistrationHandle));
 458     return ERROR_SUCCESS;
 459 }
 460
 461 /******************************************************************************
 462  *                  EtwEventEnabled (NTDLL.@)
 463  */
 464 BOOLEAN WINAPI EtwEventEnabled( REGHANDLE handle, const EVENT_DESCRIPTOR *descriptor )
 465 {
 466     FIXME("(%s, %p): stub\n", wine_dbgstr_longlong(handle), descriptor);
 467     return FALSE;
 468 }
 469
 470 /******************************************************************************
 471  *                  EtwEventWrite (NTDLL.@)
 472  */
 473 ULONG WINAPI EtwEventWrite( REGHANDLE handle, const EVENT_DESCRIPTOR *descriptor, ULONG count,
 474     EVENT_DATA_DESCRIPTOR *data )
 475 {
 476     FIXME("(%s, %p, %u, %p): stub\n", wine_dbgstr_longlong(handle), descriptor, count, data);
 477     return ERROR_SUCCESS;
 478 }