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 <time.h>
  23
  24 #include "ntstatus.h"
  25 #define WIN32_NO_STATUS
  26 #include "wine/debug.h"
  27 #include "ntdll_misc.h"
  28 #include "wmistr.h"
  29 #include "evntrace.h"
  30 #include "evntprov.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
  33
  34 LPCSTR debugstr_us( const UNICODE_STRING *us )
  35 {
  36     if (!us) return "<null>";
  37     return debugstr_wn(us->Buffer, us->Length / sizeof(WCHAR));
  38 }
  39
  40 static int __cdecl compare_wrapper(void *ctx, const void *e1, const void *e2)
  41 {
  42     int (__cdecl *compare)( const void *, const void * ) = ctx;
  43     return compare( e1, e2 );
  44 }
  45
  46 static inline void swap(char *l, char *r, size_t size)
  47 {
  48     char tmp;
  49
  50     while(size--) {
  51         tmp = *l;
  52         *l++ = *r;
  53         *r++ = tmp;
  54     }
  55 }
  56
  57 static void small_sort(void *base, size_t nmemb, size_t size,
  58         int (CDECL *compar)(void *, const void *, const void *), void *context)
  59 {
  60     size_t e, i;
  61     char *max, *p;
  62
  63     for(e=nmemb; e>1; e--) {
  64         max = base;
  65         for(i=1; i<e; i++) {
  66             p = (char*)base + i*size;
  67             if(compar(context, p, max) > 0)
  68                 max = p;
  69         }
  70
  71         if(p != max)
  72             swap(p, max, size);
  73     }
  74 }
  75
  76 static void quick_sort(void *base, size_t nmemb, size_t size,
  77         int (CDECL *compar)(void *, const void *, const void *), void *context)
  78 {
  79     size_t stack_lo[8*sizeof(size_t)], stack_hi[8*sizeof(size_t)];
  80     size_t beg, end, lo, hi, med;
  81     int stack_pos;
  82
  83     stack_pos = 0;
  84     stack_lo[stack_pos] = 0;
  85     stack_hi[stack_pos] = nmemb-1;
  86
  87 #define X(i) ((char*)base+size*(i))
  88     while(stack_pos >= 0) {
  89         beg = stack_lo[stack_pos];
  90         end = stack_hi[stack_pos--];
  91
  92         if(end-beg < 8) {
  93             small_sort(X(beg), end-beg+1, size, compar, context);
  94             continue;
  95         }
  96
  97         lo = beg;
  98         hi = end;
  99         med = lo + (hi-lo+1)/2;
 100         if(compar(context, X(lo), X(med)) > 0)
 101             swap(X(lo), X(med), size);
 102         if(compar(context, X(lo), X(hi)) > 0)
 103             swap(X(lo), X(hi), size);
 104         if(compar(context, X(med), X(hi)) > 0)
 105             swap(X(med), X(hi), size);
 106
 107         lo++;
 108         hi--;
 109         while(1) {
 110             while(lo <= hi) {
 111                 if(lo!=med && compar(context, X(lo), X(med))>0)
 112                     break;
 113                 lo++;
 114             }
 115
 116             while(med != hi) {
 117                 if(compar(context, X(hi), X(med)) <= 0)
 118                     break;
 119                 hi--;
 120             }
 121
 122             if(hi < lo)
 123                 break;
 124
 125             swap(X(lo), X(hi), size);
 126             if(hi == med)
 127                 med = lo;
 128             lo++;
 129             hi--;
 130         }
 131
 132         while(hi > beg) {
 133             if(hi!=med && compar(context, X(hi), X(med))!=0)
 134                 break;
 135             hi--;
 136         }
 137
 138         if(hi-beg >= end-lo) {
 139             stack_lo[++stack_pos] = beg;
 140             stack_hi[stack_pos] = hi;
 141             stack_lo[++stack_pos] = lo;
 142             stack_hi[stack_pos] = end;
 143         }else {
 144             stack_lo[++stack_pos] = lo;
 145             stack_hi[stack_pos] = end;
 146             stack_lo[++stack_pos] = beg;
 147             stack_hi[stack_pos] = hi;
 148         }
 149     }
 150 #undef X
 151 }
 152
 153
 154 /*********************************************************************
 155  *                  qsort_s   (NTDLL.@)
 156  */
 157 void __cdecl qsort_s( void *base, size_t nmemb, size_t size,
 158                       int (__cdecl *compar)(void *, const void *, const void *), void *context )
 159 {
 160     const size_t total_size = nmemb * size;
 161
 162     if (!base && nmemb) return;
 163     if (!size) return;
 164     if (!compar) return;
 165     if (total_size / size != nmemb) return;
 166     if (nmemb < 2) return;
 167     quick_sort( base, nmemb, size, compar, context );
 168 }
 169
 170
 171 /*********************************************************************
 172  *                  qsort   (NTDLL.@)
 173  */
 174 void __cdecl qsort( void *base, size_t nmemb, size_t size,
 175                     int (__cdecl *compar)(const void *, const void *) )
 176 {
 177     qsort_s( base, nmemb, size, compare_wrapper, compar );
 178 }
 179
 180
 181 /*********************************************************************
 182  *                  bsearch_s   (NTDLL.@)
 183  */
 184 void * __cdecl bsearch_s( const void *key, const void *base, size_t nmemb, size_t size,
 185                           int (__cdecl *compare)(void *, const void *, const void *), void *ctx )
 186 {
 187     ssize_t min = 0;
 188     ssize_t max = nmemb - 1;
 189
 190     if (!size) return NULL;
 191     if (!compare) return NULL;
 192
 193     while (min <= max)
 194     {
 195         ssize_t cursor = min + (max - min) / 2;
 196         int ret = compare(ctx, key,(const char *)base+(cursor*size));
 197         if (!ret)
 198             return (char*)base+(cursor*size);
 199         if (ret < 0)
 200             max = cursor - 1;
 201         else
 202             min = cursor + 1;
 203     }
 204     return NULL;
 205 }
 206
 207
 208 /*********************************************************************
 209  *                  bsearch   (NTDLL.@)
 210  */
 211 void * __cdecl bsearch( const void *key, const void *base, size_t nmemb,
 212                         size_t size, int (__cdecl *compar)(const void *, const void *) )
 213 {
 214     return bsearch_s( key, base, nmemb, size, compare_wrapper, compar );
 215 }
 216
 217
 218
 219 /*********************************************************************
 220  *                  _lfind   (NTDLL.@)
 221  */
 222 void * __cdecl _lfind( const void *key, const void *base, unsigned int *nmemb,
 223                        size_t size, int(__cdecl *compar)(const void *, const void *) )
 224 {
 225     size_t i, n = *nmemb;
 226
 227     for (i=0;i<n;i++)
 228         if (!compar(key,(char*)base+(size*i)))
 229             return (char*)base+(size*i);
 230     return NULL;
 231 }
 232
 233 /******************************************************************************
 234  *                  WinSqmEndSession   (NTDLL.@)
 235  */
 236 NTSTATUS WINAPI WinSqmEndSession(HANDLE session)
 237 {
 238     FIXME("(%p): stub\n", session);
 239     return STATUS_NOT_IMPLEMENTED;
 240 }
 241
 242 /*********************************************************************
 243  *          WinSqmIncrementDWORD (NTDLL.@)
 244  */
 245 void WINAPI WinSqmIncrementDWORD(DWORD unk1, DWORD unk2, DWORD unk3)
 246 {
 247     FIXME("(%ld, %ld, %ld): stub\n", unk1, unk2, unk3);
 248 }
 249
 250 /*********************************************************************
 251  *                  WinSqmIsOptedIn   (NTDLL.@)
 252  */
 253 BOOL WINAPI WinSqmIsOptedIn(void)
 254 {
 255     FIXME("(): stub\n");
 256     return FALSE;
 257 }
 258
 259 /******************************************************************************
 260  *                  WinSqmStartSession   (NTDLL.@)
 261  */
 262 HANDLE WINAPI WinSqmStartSession(GUID *sessionguid, DWORD sessionid, DWORD unknown1)
 263 {
 264     FIXME("(%p, 0x%lx, 0x%lx): stub\n", sessionguid, sessionid, unknown1);
 265     return INVALID_HANDLE_VALUE;
 266 }
 267
 268 /***********************************************************************
 269  *          WinSqmSetDWORD (NTDLL.@)
 270  */
 271 void WINAPI WinSqmSetDWORD(HANDLE session, DWORD datapoint_id, DWORD datapoint_value)
 272 {
 273     FIXME("(%p, %ld, %ld): stub\n", session, datapoint_id, datapoint_value);
 274 }
 275
 276 /******************************************************************************
 277  *                  EtwEventActivityIdControl (NTDLL.@)
 278  */
 279 ULONG WINAPI EtwEventActivityIdControl(ULONG code, GUID *guid)
 280 {
 281     static int once;
 282
 283     if (!once++) FIXME("0x%lx, %p: stub\n", code, guid);
 284     return ERROR_SUCCESS;
 285 }
 286
 287 /******************************************************************************
 288  *                  EtwEventProviderEnabled (NTDLL.@)
 289  */
 290 BOOLEAN WINAPI EtwEventProviderEnabled( REGHANDLE handle, UCHAR level, ULONGLONG keyword )
 291 {
 292     WARN("%s, %u, %s: stub\n", wine_dbgstr_longlong(handle), level, wine_dbgstr_longlong(keyword));
 293     return FALSE;
 294 }
 295
 296 /******************************************************************************
 297  *                  EtwEventRegister (NTDLL.@)
 298  */
 299 ULONG WINAPI EtwEventRegister( LPCGUID provider, PENABLECALLBACK callback, PVOID context,
 300                 PREGHANDLE handle )
 301 {
 302     WARN("(%s, %p, %p, %p) stub.\n", debugstr_guid(provider), callback, context, handle);
 303
 304     if (!handle) return ERROR_INVALID_PARAMETER;
 305
 306     *handle = 0xdeadbeef;
 307     return ERROR_SUCCESS;
 308 }
 309
 310 /******************************************************************************
 311  *                  EtwEventUnregister (NTDLL.@)
 312  */
 313 ULONG WINAPI EtwEventUnregister( REGHANDLE handle )
 314 {
 315     WARN("(%s) stub.\n", wine_dbgstr_longlong(handle));
 316     return ERROR_SUCCESS;
 317 }
 318
 319 /*********************************************************************
 320  *                  EtwEventSetInformation   (NTDLL.@)
 321  */
 322 ULONG WINAPI EtwEventSetInformation( REGHANDLE handle, EVENT_INFO_CLASS class, void *info,
 323                                      ULONG length )
 324 {
 325     FIXME("(%s, %u, %p, %lu) stub\n", wine_dbgstr_longlong(handle), class, info, length);
 326     return ERROR_SUCCESS;
 327 }
 328
 329 /******************************************************************************
 330  *                  EtwEventWriteString   (NTDLL.@)
 331  */
 332 ULONG WINAPI EtwEventWriteString( REGHANDLE handle, UCHAR level, ULONGLONG keyword, PCWSTR string )
 333 {
 334     FIXME("%s, %u, %s, %s: stub\n", wine_dbgstr_longlong(handle), level,
 335           wine_dbgstr_longlong(keyword), debugstr_w(string));
 336     return ERROR_SUCCESS;
 337 }
 338
 339 /******************************************************************************
 340  *                  EtwEventWriteTransfer   (NTDLL.@)
 341  */
 342 ULONG WINAPI EtwEventWriteTransfer( REGHANDLE handle, PCEVENT_DESCRIPTOR descriptor, LPCGUID activity,
 343                                     LPCGUID related, ULONG count, PEVENT_DATA_DESCRIPTOR data )
 344 {
 345     FIXME("%s, %p, %s, %s, %lu, %p: stub\n", wine_dbgstr_longlong(handle), descriptor,
 346           debugstr_guid(activity), debugstr_guid(related), count, data);
 347     return ERROR_SUCCESS;
 348 }
 349
 350 /******************************************************************************
 351  *                  EtwRegisterTraceGuidsW (NTDLL.@)
 352  *
 353  * Register an event trace provider and the event trace classes that it uses
 354  * to generate events.
 355  *
 356  * PARAMS
 357  *  RequestAddress     [I]   ControlCallback function
 358  *  RequestContext     [I]   Optional provider-defined context
 359  *  ControlGuid        [I]   GUID of the registering provider
 360  *  GuidCount          [I]   Number of elements in the TraceGuidReg array
 361  *  TraceGuidReg       [I/O] Array of TRACE_GUID_REGISTRATION structures
 362  *  MofImagePath       [I]   not supported, set to NULL
 363  *  MofResourceName    [I]   not supported, set to NULL
 364  *  RegistrationHandle [O]   Provider's registration handle
 365  *
 366  * RETURNS
 367  *  Success: ERROR_SUCCESS
 368  *  Failure: System error code
 369  */
 370 ULONG WINAPI EtwRegisterTraceGuidsW( WMIDPREQUEST RequestAddress,
 371                 void *RequestContext, const GUID *ControlGuid, ULONG GuidCount,
 372                 TRACE_GUID_REGISTRATION *TraceGuidReg, const WCHAR *MofImagePath,
 373                 const WCHAR *MofResourceName, TRACEHANDLE *RegistrationHandle )
 374 {
 375     WARN("(%p, %p, %s, %lu, %p, %s, %s, %p): stub\n", RequestAddress, RequestContext,
 376           debugstr_guid(ControlGuid), GuidCount, TraceGuidReg, debugstr_w(MofImagePath),
 377           debugstr_w(MofResourceName), RegistrationHandle);
 378
 379     if (TraceGuidReg)
 380     {
 381         ULONG i;
 382         for (i = 0; i < GuidCount; i++)
 383         {
 384             FIXME("  register trace class %s\n", debugstr_guid(TraceGuidReg[i].Guid));
 385             TraceGuidReg[i].RegHandle = (HANDLE)0xdeadbeef;
 386         }
 387     }
 388     *RegistrationHandle = (TRACEHANDLE)0xdeadbeef;
 389     return ERROR_SUCCESS;
 390 }
 391
 392 /******************************************************************************
 393  *                  EtwRegisterTraceGuidsA (NTDLL.@)
 394  */
 395 ULONG WINAPI EtwRegisterTraceGuidsA( WMIDPREQUEST RequestAddress,
 396                 void *RequestContext, const GUID *ControlGuid, ULONG GuidCount,
 397                 TRACE_GUID_REGISTRATION *TraceGuidReg, const char *MofImagePath,
 398                 const char *MofResourceName, TRACEHANDLE *RegistrationHandle )
 399 {
 400     WARN("(%p, %p, %s, %lu, %p, %s, %s, %p): stub\n", RequestAddress, RequestContext,
 401           debugstr_guid(ControlGuid), GuidCount, TraceGuidReg, debugstr_a(MofImagePath),
 402           debugstr_a(MofResourceName), RegistrationHandle);
 403     return ERROR_SUCCESS;
 404 }
 405
 406 /******************************************************************************
 407  *                  EtwUnregisterTraceGuids (NTDLL.@)
 408  */
 409 ULONG WINAPI EtwUnregisterTraceGuids( TRACEHANDLE RegistrationHandle )
 410 {
 411     if (!RegistrationHandle)
 412          return ERROR_INVALID_PARAMETER;
 413
 414     WARN("%s: stub\n", wine_dbgstr_longlong(RegistrationHandle));
 415     return ERROR_SUCCESS;
 416 }
 417
 418 /******************************************************************************
 419  *                  EtwEventEnabled (NTDLL.@)
 420  */
 421 BOOLEAN WINAPI EtwEventEnabled( REGHANDLE handle, const EVENT_DESCRIPTOR *descriptor )
 422 {
 423     WARN("(%s, %p): stub\n", wine_dbgstr_longlong(handle), descriptor);
 424     return FALSE;
 425 }
 426
 427 /******************************************************************************
 428  *                  EtwEventWrite (NTDLL.@)
 429  */
 430 ULONG WINAPI EtwEventWrite( REGHANDLE handle, const EVENT_DESCRIPTOR *descriptor, ULONG count,
 431     EVENT_DATA_DESCRIPTOR *data )
 432 {
 433     FIXME("(%s, %p, %lu, %p): stub\n", wine_dbgstr_longlong(handle), descriptor, count, data);
 434     return ERROR_SUCCESS;
 435 }
 436
 437 /******************************************************************************
 438  *                  EtwGetTraceEnableFlags (NTDLL.@)
 439  */
 440 ULONG WINAPI EtwGetTraceEnableFlags( TRACEHANDLE handle )
 441 {
 442     FIXME("(%s) stub\n", wine_dbgstr_longlong(handle));
 443     return 0;
 444 }
 445
 446 /******************************************************************************
 447  *                  EtwGetTraceEnableLevel (NTDLL.@)
 448  */
 449 UCHAR WINAPI EtwGetTraceEnableLevel( TRACEHANDLE handle )
 450 {
 451     FIXME("(%s) stub\n", wine_dbgstr_longlong(handle));
 452     return TRACE_LEVEL_VERBOSE;
 453 }
 454
 455 /******************************************************************************
 456  *                  EtwGetTraceLoggerHandle (NTDLL.@)
 457  */
 458 TRACEHANDLE WINAPI EtwGetTraceLoggerHandle( PVOID buf )
 459 {
 460     FIXME("(%p) stub\n", buf);
 461     return INVALID_PROCESSTRACE_HANDLE;
 462 }
 463
 464 /******************************************************************************
 465  *                  EtwLogTraceEvent (NTDLL.@)
 466  */
 467 ULONG WINAPI EtwLogTraceEvent( TRACEHANDLE SessionHandle, PEVENT_TRACE_HEADER EventTrace )
 468 {
 469     FIXME("%s %p\n", wine_dbgstr_longlong(SessionHandle), EventTrace);
 470     return ERROR_CALL_NOT_IMPLEMENTED;
 471 }
 472
 473 /******************************************************************************
 474  *                  EtwTraceMessageVa (NTDLL.@)
 475  */
 476 ULONG WINAPI EtwTraceMessageVa( TRACEHANDLE handle, ULONG flags, LPGUID guid, USHORT number,
 477                                 va_list args )
 478 {
 479     FIXME("(%s %lx %s %d) : stub\n", wine_dbgstr_longlong(handle), flags, debugstr_guid(guid), number);
 480     return ERROR_SUCCESS;
 481 }
 482
 483 /******************************************************************************
 484  *                  EtwTraceMessage (NTDLL.@)
 485  */
 486 ULONG WINAPIV EtwTraceMessage( TRACEHANDLE handle, ULONG flags, LPGUID guid, /*USHORT*/ ULONG number, ... )
 487 {
 488     va_list valist;
 489     ULONG ret;
 490
 491     va_start( valist, number );
 492     ret = EtwTraceMessageVa( handle, flags, guid, number, valist );
 493     va_end( valist );
 494     return ret;
 495 }