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 "wine/library.h"
  31 #include "wine/debug.h"
  32 #include "ntdll_misc.h"
  33 #include "wmistr.h"
  34 #include "evntrace.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
  37
  38 LPCSTR debugstr_ObjectAttributes(const OBJECT_ATTRIBUTES *oa)
  39 {
  40     if (!oa) return "<null>";
  41     return wine_dbg_sprintf( "{name=%s, attr=0x%08x, hRoot=%p, sd=%p}\n",
  42                              debugstr_us(oa->ObjectName), oa->Attributes,
  43                              oa->RootDirectory, oa->SecurityDescriptor );
  44 }
  45
  46 LPCSTR debugstr_us( const UNICODE_STRING *us )
  47 {
  48     if (!us) return "<null>";
  49     return debugstr_wn(us->Buffer, us->Length / sizeof(WCHAR));
  50 }
  51
  52 /*********************************************************************
  53  *                  wine_get_version   (NTDLL.@)
  54  */
  55 const char * CDECL NTDLL_wine_get_version(void)
  56 {
  57     return wine_get_version();
  58 }
  59
  60 /*********************************************************************
  61  *                  wine_get_build_id   (NTDLL.@)
  62  */
  63 const char * CDECL NTDLL_wine_get_build_id(void)
  64 {
  65     return wine_get_build_id();
  66 }
  67
  68 /*********************************************************************
  69  *                  wine_get_host_version   (NTDLL.@)
  70  */
  71 void CDECL NTDLL_wine_get_host_version( const char **sysname, const char **release )
  72 {
  73 #ifdef HAVE_SYS_UTSNAME_H
  74     static struct utsname buf;
  75     static BOOL init_done;
  76
  77     if (!init_done)
  78     {
  79         uname( &buf );
  80         init_done = TRUE;
  81     }
  82     if (sysname) *sysname = buf.sysname;
  83     if (release) *release = buf.release;
  84 #else
  85     if (sysname) *sysname = "";
  86     if (release) *release = "";
  87 #endif
  88 }
  89
  90 /*********************************************************************
  91  *                  abs   (NTDLL.@)
  92  */
  93 int CDECL NTDLL_abs( int i )
  94 {
  95     return abs( i );
  96 }
  97
  98 /*********************************************************************
  99  *                  labs   (NTDLL.@)
 100  */
 101 LONG CDECL NTDLL_labs( LONG i )
 102 {
 103     return labs( i );
 104 }
 105
 106 /*********************************************************************
 107  *                  atan   (NTDLL.@)
 108  */
 109 double CDECL NTDLL_atan( double d )
 110 {
 111     return atan( d );
 112 }
 113
 114 /*********************************************************************
 115  *                  ceil   (NTDLL.@)
 116  */
 117 double CDECL NTDLL_ceil( double d )
 118 {
 119     return ceil( d );
 120 }
 121
 122 /*********************************************************************
 123  *                  cos   (NTDLL.@)
 124  */
 125 double CDECL NTDLL_cos( double d )
 126 {
 127     return cos( d );
 128 }
 129
 130 /*********************************************************************
 131  *                  fabs   (NTDLL.@)
 132  */
 133 double CDECL NTDLL_fabs( double d )
 134 {
 135     return fabs( d );
 136 }
 137
 138 /*********************************************************************
 139  *                  floor   (NTDLL.@)
 140  */
 141 double CDECL NTDLL_floor( double d )
 142 {
 143     return floor( d );
 144 }
 145
 146 /*********************************************************************
 147  *                  log   (NTDLL.@)
 148  */
 149 double CDECL NTDLL_log( double d )
 150 {
 151     return log( d );
 152 }
 153
 154 /*********************************************************************
 155  *                  pow   (NTDLL.@)
 156  */
 157 double CDECL NTDLL_pow( double x, double y )
 158 {
 159     return pow( x, y );
 160 }
 161
 162 /*********************************************************************
 163  *                  sin   (NTDLL.@)
 164  */
 165 double CDECL NTDLL_sin( double d )
 166 {
 167     return sin( d );
 168 }
 169
 170 /*********************************************************************
 171  *                  sqrt   (NTDLL.@)
 172  */
 173 double CDECL NTDLL_sqrt( double d )
 174 {
 175     return sqrt( d );
 176 }
 177
 178 /*********************************************************************
 179  *                  tan   (NTDLL.@)
 180  */
 181 double CDECL NTDLL_tan( double d )
 182 {
 183     return tan( d );
 184 }
 185
 186 #if defined(__GNUC__) && defined(__i386__)
 187
 188 #define FPU_DOUBLE(var) double var; \
 189     __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var) : )
 190 #define FPU_DOUBLES(var1,var2) double var1,var2; \
 191     __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var2) : ); \
 192     __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var1) : )
 193
 194 /*********************************************************************
 195  *              _CIcos (NTDLL.@)
 196  */
 197 double CDECL NTDLL__CIcos(void)
 198 {
 199     FPU_DOUBLE(x);
 200     return NTDLL_cos(x);
 201 }
 202
 203 /*********************************************************************
 204  *              _CIlog (NTDLL.@)
 205  */
 206 double CDECL NTDLL__CIlog(void)
 207 {
 208     FPU_DOUBLE(x);
 209     return NTDLL_log(x);
 210 }
 211
 212 /*********************************************************************
 213  *              _CIpow (NTDLL.@)
 214  */
 215 double CDECL NTDLL__CIpow(void)
 216 {
 217     FPU_DOUBLES(x,y);
 218     return NTDLL_pow(x,y);
 219 }
 220
 221 /*********************************************************************
 222  *              _CIsin (NTDLL.@)
 223  */
 224 double CDECL NTDLL__CIsin(void)
 225 {
 226     FPU_DOUBLE(x);
 227     return NTDLL_sin(x);
 228 }
 229
 230 /*********************************************************************
 231  *              _CIsqrt (NTDLL.@)
 232  */
 233 double CDECL NTDLL__CIsqrt(void)
 234 {
 235     FPU_DOUBLE(x);
 236     return NTDLL_sqrt(x);
 237 }
 238
 239 /*********************************************************************
 240  *                  _ftol   (NTDLL.@)
 241  */
 242 LONGLONG CDECL NTDLL__ftol(void)
 243 {
 244     FPU_DOUBLE(x);
 245     return (LONGLONG)x;
 246 }
 247
 248 #endif /* defined(__GNUC__) && defined(__i386__) */
 249
 250 static void
 251 NTDLL_mergesort( void *arr, void *barr, size_t elemsize, int(__cdecl *compar)(const void *, const void *),
 252                  size_t left, size_t right )
 253 {
 254     if(right>left) {
 255         size_t i, j, k, m;
 256         m=left+(right-left)/2;
 257         NTDLL_mergesort( arr, barr, elemsize, compar, left, m);
 258         NTDLL_mergesort( arr, barr, elemsize, compar, m+1, right);
 259
 260 #define X(a,i) ((char*)a+elemsize*(i))
 261         for (k=left, i=left, j=m+1; i<=m && j<=right; k++) {
 262             if (compar(X(arr, i), X(arr,j)) <= 0) {
 263                 memcpy(X(barr,k), X(arr, i), elemsize);
 264                 i++;
 265             } else {
 266                 memcpy(X(barr,k), X(arr, j), elemsize);
 267                 j++;
 268             }
 269         }
 270         if (i<=m)
 271             memcpy(X(barr,k), X(arr,i), (m-i+1)*elemsize);
 272         else
 273             memcpy(X(barr,k), X(arr,j), (right-j+1)*elemsize);
 274
 275         memcpy(X(arr, left), X(barr, left), (right-left+1)*elemsize);
 276     }
 277 #undef X
 278 }
 279
 280 /*********************************************************************
 281  *                  qsort   (NTDLL.@)
 282  */
 283 void __cdecl NTDLL_qsort( void *base, size_t nmemb, size_t size,
 284                           int(__cdecl *compar)(const void *, const void *) )
 285 {
 286     void *secondarr;
 287     if (nmemb < 2 || size == 0) return;
 288     secondarr = RtlAllocateHeap (GetProcessHeap(), 0, nmemb*size);
 289     NTDLL_mergesort( base, secondarr, size, compar, 0, nmemb-1 );
 290     RtlFreeHeap (GetProcessHeap(),0, secondarr);
 291 }
 292
 293 /*********************************************************************
 294  *                  bsearch   (NTDLL.@)
 295  */
 296 void * __cdecl
 297 NTDLL_bsearch( const void *key, const void *base, size_t nmemb,
 298                size_t size, int (__cdecl *compar)(const void *, const void *) )
 299 {
 300     ssize_t min = 0;
 301     ssize_t max = nmemb - 1;
 302
 303     while (min <= max)
 304     {
 305         ssize_t cursor = min + (max - min) / 2;
 306         int ret = compar(key,(const char *)base+(cursor*size));
 307         if (!ret)
 308             return (char*)base+(cursor*size);
 309         if (ret < 0)
 310             max = cursor - 1;
 311         else
 312             min = cursor + 1;
 313     }
 314     return NULL;
 315 }
 316
 317
 318 /*********************************************************************
 319  *                  _lfind   (NTDLL.@)
 320  */
 321 void * __cdecl _lfind( const void *key, const void *base, unsigned int *nmemb,
 322                        size_t size, int(__cdecl *compar)(const void *, const void *) )
 323 {
 324     size_t i, n = *nmemb;
 325
 326     for (i=0;i<n;i++)
 327         if (!compar(key,(char*)base+(size*i)))
 328             return (char*)base+(size*i);
 329     return NULL;
 330 }
 331
 332 /*********************************************************************
 333  *                  WinSqmIsOptedIn   (NTDLL.@)
 334  */
 335 BOOL WINAPI WinSqmIsOptedIn(void)
 336 {
 337     FIXME("() stub\n");
 338     return FALSE;
 339 }
 340
 341 /******************************************************************************
 342  *                  EtwRegisterTraceGuidsW (NTDLL.@)
 343  *
 344  * Register an event trace provider and the event trace classes that it uses
 345  * to generate events.
 346  *
 347  * PARAMS
 348  *  RequestAddress     [I]   ControlCallback function
 349  *  RequestContext     [I]   Optional provider-defined context
 350  *  ControlGuid        [I]   GUID of the registering provider
 351  *  GuidCount          [I]   Number of elements in the TraceGuidReg array
 352  *  TraceGuidReg       [I/O] Array of TRACE_GUID_REGISTRATION structures
 353  *  MofImagePath       [I]   not supported, set to NULL
 354  *  MofResourceName    [I]   not supported, set to NULL
 355  *  RegistrationHandle [O]   Provider's registration handle
 356  *
 357  * RETURNS
 358  *  Success: ERROR_SUCCESS
 359  *  Failure: System error code
 360  */
 361 ULONG WINAPI EtwRegisterTraceGuidsW( WMIDPREQUEST RequestAddress,
 362                 void *RequestContext, const GUID *ControlGuid, ULONG GuidCount,
 363                 TRACE_GUID_REGISTRATION *TraceGuidReg, const WCHAR *MofImagePath,
 364                 const WCHAR *MofResourceName, TRACEHANDLE *RegistrationHandle )
 365 {
 366     FIXME("(%p, %p, %s, %u, %p, %s, %s, %p): stub\n", RequestAddress, RequestContext,
 367           debugstr_guid(ControlGuid), GuidCount, TraceGuidReg, debugstr_w(MofImagePath),
 368           debugstr_w(MofResourceName), RegistrationHandle);
 369
 370     if (TraceGuidReg)
 371     {
 372         ULONG i;
 373         for (i = 0; i < GuidCount; i++)
 374         {
 375             FIXME("  register trace class %s\n", debugstr_guid(TraceGuidReg[i].Guid));
 376             TraceGuidReg[i].RegHandle = (HANDLE)0xdeadbeef;
 377         }
 378     }
 379     *RegistrationHandle = (TRACEHANDLE)0xdeadbeef;
 380     return ERROR_SUCCESS;
 381 }
 382
 383 /******************************************************************************
 384  *                  EtwRegisterTraceGuidsA (NTDLL.@)
 385  */
 386 ULONG WINAPI EtwRegisterTraceGuidsA( WMIDPREQUEST RequestAddress,
 387                 void *RequestContext, const GUID *ControlGuid, ULONG GuidCount,
 388                 TRACE_GUID_REGISTRATION *TraceGuidReg, const char *MofImagePath,
 389                 const char *MofResourceName, TRACEHANDLE *RegistrationHandle )
 390 {
 391     FIXME("(%p, %p, %s, %u, %p, %s, %s, %p): stub\n", RequestAddress, RequestContext,
 392           debugstr_guid(ControlGuid), GuidCount, TraceGuidReg, debugstr_a(MofImagePath),
 393           debugstr_a(MofResourceName), RegistrationHandle);
 394     return ERROR_SUCCESS;
 395 }