?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msxml3: Support ISequentialStream in domdoc_transformNodeToObject.
[wine.git] / dlls / pdh / pdh_main.c
blobd3bf6ab87069fc24d4a712affe3dd6f40faad124
1 /*
2 * Performance Data Helper (pdh.dll)
3 *
4 * Copyright 2007 Andrey Turkin
5 * Copyright 2007 Hans Leidekker
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 <stdarg.h>
23 #include <math.h>
24
25 #define NONAMELESSUNION
26
27 #include "windef.h"
28 #include "winbase.h"
29
30 #include "pdh.h"
31 #include "pdhmsg.h"
32 #include "winperf.h"
33
34 #include "wine/debug.h"
35 #include "wine/heap.h"
36 #include "wine/list.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(pdh);
39
40 static CRITICAL_SECTION pdh_handle_cs;
41 static CRITICAL_SECTION_DEBUG pdh_handle_cs_debug =
42 {
43 0, 0, &pdh_handle_cs,
44 { &pdh_handle_cs_debug.ProcessLocksList,
45 &pdh_handle_cs_debug.ProcessLocksList },
46 0, 0, { (DWORD_PTR)(__FILE__ ": pdh_handle_cs") }
47 };
48 static CRITICAL_SECTION pdh_handle_cs = { &pdh_handle_cs_debug, -1, 0, 0, 0, 0 };
49
50 static inline WCHAR *pdh_strdup( const WCHAR *src )
51 {
52 WCHAR *dst;
53
54 if (!src) return NULL;
55 if ((dst = heap_alloc( (lstrlenW( src ) + 1) * sizeof(WCHAR) ))) lstrcpyW( dst, src );
56 return dst;
57 }
58
59 static inline WCHAR *pdh_strdup_aw( const char *src )
60 {
61 int len;
62 WCHAR *dst;
63
64 if (!src) return NULL;
65 len = MultiByteToWideChar( CP_ACP, 0, src, -1, NULL, 0 );
66 if ((dst = heap_alloc( len * sizeof(WCHAR) ))) MultiByteToWideChar( CP_ACP, 0, src, -1, dst, len );
67 return dst;
68 }
69
70 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
71 {
72 TRACE("(0x%p, %d, %p)\n",hinstDLL,fdwReason,lpvReserved);
73 switch (fdwReason)
74 {
75 case DLL_WINE_PREATTACH:
76 return FALSE; /* prefer native version */
77 case DLL_PROCESS_ATTACH:
78 DisableThreadLibraryCalls(hinstDLL);
79 break;
80 case DLL_PROCESS_DETACH:
81 if (lpvReserved) break;
82 DeleteCriticalSection(&pdh_handle_cs);
83 break;
84 }
85
86 return TRUE;
87 }
88
89 union value
90 {
91 LONG longvalue;
92 double doublevalue;
93 LONGLONG largevalue;
94 };
95
96 struct counter
97 {
98 DWORD magic; /* signature */
99 struct list entry; /* list entry */
100 WCHAR *path; /* identifier */
101 DWORD type; /* counter type */
102 DWORD status; /* update status */
103 LONG scale; /* scale factor */
104 LONG defaultscale; /* default scale factor */
105 DWORD_PTR user; /* user data */
106 DWORD_PTR queryuser; /* query user data */
107 LONGLONG base; /* samples per second */
108 FILETIME stamp; /* time stamp */
109 void (CALLBACK *collect)( struct counter * ); /* collect callback */
110 union value one; /* first value */
111 union value two; /* second value */
112 };
113
114 #define PDH_MAGIC_COUNTER 0x50444831 /* 'PDH1' */
115
116 static struct counter *create_counter( void )
117 {
118 struct counter *counter;
119
120 if ((counter = heap_alloc_zero( sizeof(struct counter) )))
121 {
122 counter->magic = PDH_MAGIC_COUNTER;
123 return counter;
124 }
125 return NULL;
126 }
127
128 static void destroy_counter( struct counter *counter )
129 {
130 counter->magic = 0;
131 heap_free( counter->path );
132 heap_free( counter );
133 }
134
135 #define PDH_MAGIC_QUERY 0x50444830 /* 'PDH0' */
136
137 struct query
138 {
139 DWORD magic; /* signature */
140 DWORD_PTR user; /* user data */
141 HANDLE thread; /* collect thread */
142 DWORD interval; /* collect interval */
143 HANDLE wait; /* wait event */
144 HANDLE stop; /* stop event */
145 struct list counters; /* counter list */
146 };
147
148 static struct query *create_query( void )
149 {
150 struct query *query;
151
152 if ((query = heap_alloc_zero( sizeof(struct query) )))
153 {
154 query->magic = PDH_MAGIC_QUERY;
155 list_init( &query->counters );
156 return query;
157 }
158 return NULL;
159 }
160
161 static void destroy_query( struct query *query )
162 {
163 query->magic = 0;
164 heap_free( query );
165 }
166
167 struct source
168 {
169 DWORD index; /* name index */
170 const WCHAR *path; /* identifier */
171 void (CALLBACK *collect)( struct counter * ); /* collect callback */
172 DWORD type; /* counter type */
173 LONG scale; /* default scale factor */
174 LONGLONG base; /* samples per second */
175 };
176
177 static void CALLBACK collect_processor_time( struct counter *counter )
178 {
179 counter->two.largevalue = 500000; /* FIXME */
180 counter->status = PDH_CSTATUS_VALID_DATA;
181 }
182
183 static void CALLBACK collect_uptime( struct counter *counter )
184 {
185 counter->two.largevalue = GetTickCount64();
186 counter->status = PDH_CSTATUS_VALID_DATA;
187 }
188
189 #define TYPE_PROCESSOR_TIME \
190 (PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_100NS | PERF_DELTA_COUNTER | \
191 PERF_INVERSE_COUNTER | PERF_DISPLAY_PERCENT)
192
193 #define TYPE_UPTIME \
194 (PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_ELAPSED | PERF_OBJECT_TIMER | PERF_DISPLAY_SECONDS)
195
196 /* counter source registry */
197 static const struct source counter_sources[] =
198 {
199 { 6, L"\\Processor(_Total)\\% Processor Time", collect_processor_time, TYPE_PROCESSOR_TIME, -5, 10000000 },
200 { 674, L"\\System\\System Up Time", collect_uptime, TYPE_UPTIME, -3, 1000 }
201 };
202
203 static BOOL is_local_machine( const WCHAR *name, DWORD len )
204 {
205 WCHAR buf[MAX_COMPUTERNAME_LENGTH + 1];
206 DWORD buflen = ARRAY_SIZE(buf);
207
208 if (!GetComputerNameW( buf, &buflen )) return FALSE;
209 return len == buflen && !wcsnicmp( name, buf, buflen );
210 }
211
212 static BOOL pdh_match_path( LPCWSTR fullpath, LPCWSTR path )
213 {
214 const WCHAR *p;
215
216 if (path[0] == '\\' && path[1] == '\\' && (p = wcschr( path + 2, '\\' )) &&
217 is_local_machine( path + 2, p - path - 2 ))
218 {
219 path += p - path;
220 }
221 if (wcschr( path, '\\' )) p = fullpath;
222 else p = wcsrchr( fullpath, '\\' ) + 1;
223 return !wcscmp( p, path );
224 }
225
226 /***********************************************************************
227 * PdhAddCounterA (PDH.@)
228 */
229 PDH_STATUS WINAPI PdhAddCounterA( PDH_HQUERY query, LPCSTR path,
230 DWORD_PTR userdata, PDH_HCOUNTER *counter )
231 {
232 PDH_STATUS ret;
233 WCHAR *pathW;
234
235 TRACE("%p %s %lx %p\n", query, debugstr_a(path), userdata, counter);
236
237 if (!path) return PDH_INVALID_ARGUMENT;
238
239 if (!(pathW = pdh_strdup_aw( path )))
240 return PDH_MEMORY_ALLOCATION_FAILURE;
241
242 ret = PdhAddCounterW( query, pathW, userdata, counter );
243
244 heap_free( pathW );
245 return ret;
246 }
247
248 /***********************************************************************
249 * PdhAddCounterW (PDH.@)
250 */
251 PDH_STATUS WINAPI PdhAddCounterW( PDH_HQUERY hquery, LPCWSTR path,
252 DWORD_PTR userdata, PDH_HCOUNTER *hcounter )
253 {
254 struct query *query = hquery;
255 struct counter *counter;
256 unsigned int i;
257
258 TRACE("%p %s %lx %p\n", hquery, debugstr_w(path), userdata, hcounter);
259
260 if (!path || !hcounter) return PDH_INVALID_ARGUMENT;
261
262 EnterCriticalSection( &pdh_handle_cs );
263 if (!query || query->magic != PDH_MAGIC_QUERY)
264 {
265 LeaveCriticalSection( &pdh_handle_cs );
266 return PDH_INVALID_HANDLE;
267 }
268
269 *hcounter = NULL;
270 for (i = 0; i < ARRAY_SIZE(counter_sources); i++)
271 {
272 if (pdh_match_path( counter_sources[i].path, path ))
273 {
274 if ((counter = create_counter()))
275 {
276 counter->path = pdh_strdup( counter_sources[i].path );
277 counter->collect = counter_sources[i].collect;
278 counter->type = counter_sources[i].type;
279 counter->defaultscale = counter_sources[i].scale;
280 counter->base = counter_sources[i].base;
281 counter->queryuser = query->user;
282 counter->user = userdata;
283
284 list_add_tail( &query->counters, &counter->entry );
285 *hcounter = counter;
286
287 LeaveCriticalSection( &pdh_handle_cs );
288 return ERROR_SUCCESS;
289 }
290 LeaveCriticalSection( &pdh_handle_cs );
291 return PDH_MEMORY_ALLOCATION_FAILURE;
292 }
293 }
294 LeaveCriticalSection( &pdh_handle_cs );
295 return PDH_CSTATUS_NO_COUNTER;
296 }
297
298 /***********************************************************************
299 * PdhAddEnglishCounterA (PDH.@)
300 */
301 PDH_STATUS WINAPI PdhAddEnglishCounterA( PDH_HQUERY query, LPCSTR path,
302 DWORD_PTR userdata, PDH_HCOUNTER *counter )
303 {
304 TRACE("%p %s %lx %p\n", query, debugstr_a(path), userdata, counter);
305
306 if (!query) return PDH_INVALID_ARGUMENT;
307 return PdhAddCounterA( query, path, userdata, counter );
308 }
309
310 /***********************************************************************
311 * PdhAddEnglishCounterW (PDH.@)
312 */
313 PDH_STATUS WINAPI PdhAddEnglishCounterW( PDH_HQUERY query, LPCWSTR path,
314 DWORD_PTR userdata, PDH_HCOUNTER *counter )
315 {
316 TRACE("%p %s %lx %p\n", query, debugstr_w(path), userdata, counter);
317
318 if (!query) return PDH_INVALID_ARGUMENT;
319 return PdhAddCounterW( query, path, userdata, counter );
320 }
321
322 /* caller must hold counter lock */
323 static PDH_STATUS format_value( struct counter *counter, DWORD format, union value *raw1,
324 union value *raw2, PDH_FMT_COUNTERVALUE *value )
325 {
326 LONG factor;
327
328 factor = counter->scale ? counter->scale : counter->defaultscale;
329 if (format & PDH_FMT_LONG)
330 {
331 if (format & PDH_FMT_1000) value->u.longValue = raw2->longvalue * 1000;
332 else value->u.longValue = raw2->longvalue * pow( 10, factor );
333 }
334 else if (format & PDH_FMT_LARGE)
335 {
336 if (format & PDH_FMT_1000) value->u.largeValue = raw2->largevalue * 1000;
337 else value->u.largeValue = raw2->largevalue * pow( 10, factor );
338 }
339 else if (format & PDH_FMT_DOUBLE)
340 {
341 if (format & PDH_FMT_1000) value->u.doubleValue = raw2->doublevalue * 1000;
342 else value->u.doubleValue = raw2->doublevalue * pow( 10, factor );
343 }
344 else
345 {
346 WARN("unknown format %x\n", format);
347 return PDH_INVALID_ARGUMENT;
348 }
349 return ERROR_SUCCESS;
350 }
351
352 /***********************************************************************
353 * PdhCalculateCounterFromRawValue (PDH.@)
354 */
355 PDH_STATUS WINAPI PdhCalculateCounterFromRawValue( PDH_HCOUNTER handle, DWORD format,
356 PPDH_RAW_COUNTER raw1, PPDH_RAW_COUNTER raw2,
357 PPDH_FMT_COUNTERVALUE value )
358 {
359 PDH_STATUS ret;
360 struct counter *counter = handle;
361
362 TRACE("%p 0x%08x %p %p %p\n", handle, format, raw1, raw2, value);
363
364 if (!value) return PDH_INVALID_ARGUMENT;
365
366 EnterCriticalSection( &pdh_handle_cs );
367 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
368 {
369 LeaveCriticalSection( &pdh_handle_cs );
370 return PDH_INVALID_HANDLE;
371 }
372
373 ret = format_value( counter, format, (union value *)&raw1->SecondValue,
374 (union value *)&raw2->SecondValue, value );
375
376 LeaveCriticalSection( &pdh_handle_cs );
377 return ret;
378 }
379
380
381 /***********************************************************************
382 * PdhCloseQuery (PDH.@)
383 */
384 PDH_STATUS WINAPI PdhCloseQuery( PDH_HQUERY handle )
385 {
386 struct query *query = handle;
387 struct list *item, *next;
388
389 TRACE("%p\n", handle);
390
391 EnterCriticalSection( &pdh_handle_cs );
392 if (!query || query->magic != PDH_MAGIC_QUERY)
393 {
394 LeaveCriticalSection( &pdh_handle_cs );
395 return PDH_INVALID_HANDLE;
396 }
397
398 if (query->thread)
399 {
400 HANDLE thread = query->thread;
401 SetEvent( query->stop );
402 LeaveCriticalSection( &pdh_handle_cs );
403
404 WaitForSingleObject( thread, INFINITE );
405
406 EnterCriticalSection( &pdh_handle_cs );
407 if (query->magic != PDH_MAGIC_QUERY)
408 {
409 LeaveCriticalSection( &pdh_handle_cs );
410 return ERROR_SUCCESS;
411 }
412 CloseHandle( query->stop );
413 CloseHandle( query->thread );
414 query->thread = NULL;
415 }
416
417 LIST_FOR_EACH_SAFE( item, next, &query->counters )
418 {
419 struct counter *counter = LIST_ENTRY( item, struct counter, entry );
420
421 list_remove( &counter->entry );
422 destroy_counter( counter );
423 }
424
425 destroy_query( query );
426
427 LeaveCriticalSection( &pdh_handle_cs );
428 return ERROR_SUCCESS;
429 }
430
431 /* caller must hold query lock */
432 static void collect_query_data( struct query *query )
433 {
434 struct list *item;
435
436 LIST_FOR_EACH( item, &query->counters )
437 {
438 SYSTEMTIME time;
439 struct counter *counter = LIST_ENTRY( item, struct counter, entry );
440
441 counter->collect( counter );
442
443 GetLocalTime( &time );
444 SystemTimeToFileTime( &time, &counter->stamp );
445 }
446 }
447
448 /***********************************************************************
449 * PdhCollectQueryData (PDH.@)
450 */
451 PDH_STATUS WINAPI PdhCollectQueryData( PDH_HQUERY handle )
452 {
453 struct query *query = handle;
454
455 TRACE("%p\n", handle);
456
457 EnterCriticalSection( &pdh_handle_cs );
458 if (!query || query->magic != PDH_MAGIC_QUERY)
459 {
460 LeaveCriticalSection( &pdh_handle_cs );
461 return PDH_INVALID_HANDLE;
462 }
463
464 if (list_empty( &query->counters ))
465 {
466 LeaveCriticalSection( &pdh_handle_cs );
467 return PDH_NO_DATA;
468 }
469
470 collect_query_data( query );
471
472 LeaveCriticalSection( &pdh_handle_cs );
473 return ERROR_SUCCESS;
474 }
475
476 static DWORD CALLBACK collect_query_thread( void *arg )
477 {
478 struct query *query = arg;
479 DWORD interval = query->interval;
480 HANDLE stop = query->stop;
481
482 for (;;)
483 {
484 if (WaitForSingleObject( stop, interval ) != WAIT_TIMEOUT) ExitThread( 0 );
485
486 EnterCriticalSection( &pdh_handle_cs );
487 if (query->magic != PDH_MAGIC_QUERY)
488 {
489 LeaveCriticalSection( &pdh_handle_cs );
490 ExitThread( PDH_INVALID_HANDLE );
491 }
492
493 collect_query_data( query );
494
495 if (!SetEvent( query->wait ))
496 {
497 LeaveCriticalSection( &pdh_handle_cs );
498 ExitThread( 0 );
499 }
500 LeaveCriticalSection( &pdh_handle_cs );
501 }
502 }
503
504 /***********************************************************************
505 * PdhCollectQueryDataEx (PDH.@)
506 */
507 PDH_STATUS WINAPI PdhCollectQueryDataEx( PDH_HQUERY handle, DWORD interval, HANDLE event )
508 {
509 PDH_STATUS ret;
510 struct query *query = handle;
511
512 TRACE("%p %d %p\n", handle, interval, event);
513
514 EnterCriticalSection( &pdh_handle_cs );
515 if (!query || query->magic != PDH_MAGIC_QUERY)
516 {
517 LeaveCriticalSection( &pdh_handle_cs );
518 return PDH_INVALID_HANDLE;
519 }
520 if (list_empty( &query->counters ))
521 {
522 LeaveCriticalSection( &pdh_handle_cs );
523 return PDH_NO_DATA;
524 }
525 if (query->thread)
526 {
527 HANDLE thread = query->thread;
528 SetEvent( query->stop );
529 LeaveCriticalSection( &pdh_handle_cs );
530
531 WaitForSingleObject( thread, INFINITE );
532
533 EnterCriticalSection( &pdh_handle_cs );
534 if (query->magic != PDH_MAGIC_QUERY)
535 {
536 LeaveCriticalSection( &pdh_handle_cs );
537 return PDH_INVALID_HANDLE;
538 }
539 CloseHandle( query->thread );
540 query->thread = NULL;
541 }
542 else if (!(query->stop = CreateEventW( NULL, FALSE, FALSE, NULL )))
543 {
544 ret = GetLastError();
545 LeaveCriticalSection( &pdh_handle_cs );
546 return ret;
547 }
548 query->wait = event;
549 query->interval = interval * 1000;
550 if (!(query->thread = CreateThread( NULL, 0, collect_query_thread, query, 0, NULL )))
551 {
552 ret = GetLastError();
553 CloseHandle( query->stop );
554
555 LeaveCriticalSection( &pdh_handle_cs );
556 return ret;
557 }
558
559 LeaveCriticalSection( &pdh_handle_cs );
560 return ERROR_SUCCESS;
561 }
562
563 /***********************************************************************
564 * PdhCollectQueryDataWithTime (PDH.@)
565 */
566 PDH_STATUS WINAPI PdhCollectQueryDataWithTime( PDH_HQUERY handle, LONGLONG *timestamp )
567 {
568 struct query *query = handle;
569 struct counter *counter;
570 struct list *item;
571
572 TRACE("%p %p\n", handle, timestamp);
573
574 if (!timestamp) return PDH_INVALID_ARGUMENT;
575
576 EnterCriticalSection( &pdh_handle_cs );
577 if (!query || query->magic != PDH_MAGIC_QUERY)
578 {
579 LeaveCriticalSection( &pdh_handle_cs );
580 return PDH_INVALID_HANDLE;
581 }
582 if (list_empty( &query->counters ))
583 {
584 LeaveCriticalSection( &pdh_handle_cs );
585 return PDH_NO_DATA;
586 }
587
588 collect_query_data( query );
589
590 item = list_head( &query->counters );
591 counter = LIST_ENTRY( item, struct counter, entry );
592
593 *timestamp = ((LONGLONG)counter->stamp.dwHighDateTime << 32) | counter->stamp.dwLowDateTime;
594
595 LeaveCriticalSection( &pdh_handle_cs );
596 return ERROR_SUCCESS;
597 }
598
599 /***********************************************************************
600 * PdhExpandWildCardPathA (PDH.@)
601 */
602 PDH_STATUS WINAPI PdhExpandWildCardPathA( LPCSTR szDataSource, LPCSTR szWildCardPath, LPSTR mszExpandedPathList, LPDWORD pcchPathListLength, DWORD dwFlags )
603 {
604 FIXME("%s, %s, %p, %p, 0x%x: stub\n", debugstr_a(szDataSource), debugstr_a(szWildCardPath), mszExpandedPathList, pcchPathListLength, dwFlags);
605 return PDH_NOT_IMPLEMENTED;
606 }
607
608 /***********************************************************************
609 * PdhExpandWildCardPathW (PDH.@)
610 */
611 PDH_STATUS WINAPI PdhExpandWildCardPathW( LPCWSTR szDataSource, LPCWSTR szWildCardPath, LPWSTR mszExpandedPathList, LPDWORD pcchPathListLength, DWORD dwFlags )
612 {
613 FIXME("%s, %s, %p, %p, 0x%x: stub\n", debugstr_w(szDataSource), debugstr_w(szWildCardPath), mszExpandedPathList, pcchPathListLength, dwFlags);
614 return PDH_NOT_IMPLEMENTED;
615 }
616
617 /***********************************************************************
618 * PdhExpandCounterPathA (PDH.@)
619 */
620 PDH_STATUS WINAPI PdhExpandCounterPathA( LPCSTR szWildCardPath, LPSTR mszExpandedPathList, LPDWORD pcchPathListLength )
621 {
622 FIXME("%s, %p, %p: stub\n", debugstr_a(szWildCardPath), mszExpandedPathList, pcchPathListLength);
623 return PdhExpandWildCardPathA(NULL, szWildCardPath, mszExpandedPathList, pcchPathListLength, 0);
624 }
625
626 /***********************************************************************
627 * PdhExpandCounterPathW (PDH.@)
628 */
629 PDH_STATUS WINAPI PdhExpandCounterPathW( LPCWSTR szWildCardPath, LPWSTR mszExpandedPathList, LPDWORD pcchPathListLength )
630 {
631 FIXME("%s, %p, %p: stub\n", debugstr_w(szWildCardPath), mszExpandedPathList, pcchPathListLength);
632 return PdhExpandWildCardPathW(NULL, szWildCardPath, mszExpandedPathList, pcchPathListLength, 0);
633 }
634
635 /***********************************************************************
636 * PdhGetCounterInfoA (PDH.@)
637 */
638 PDH_STATUS WINAPI PdhGetCounterInfoA( PDH_HCOUNTER handle, BOOLEAN text, LPDWORD size, PPDH_COUNTER_INFO_A info )
639 {
640 struct counter *counter = handle;
641
642 TRACE("%p %d %p %p\n", handle, text, size, info);
643
644 EnterCriticalSection( &pdh_handle_cs );
645 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
646 {
647 LeaveCriticalSection( &pdh_handle_cs );
648 return PDH_INVALID_HANDLE;
649 }
650 if (!size)
651 {
652 LeaveCriticalSection( &pdh_handle_cs );
653 return PDH_INVALID_ARGUMENT;
654 }
655 if (*size < sizeof(PDH_COUNTER_INFO_A))
656 {
657 *size = sizeof(PDH_COUNTER_INFO_A);
658 LeaveCriticalSection( &pdh_handle_cs );
659 return PDH_MORE_DATA;
660 }
661
662 memset( info, 0, sizeof(PDH_COUNTER_INFO_A) );
663
664 info->dwType = counter->type;
665 info->CStatus = counter->status;
666 info->lScale = counter->scale;
667 info->lDefaultScale = counter->defaultscale;
668 info->dwUserData = counter->user;
669 info->dwQueryUserData = counter->queryuser;
670
671 *size = sizeof(PDH_COUNTER_INFO_A);
672
673 LeaveCriticalSection( &pdh_handle_cs );
674 return ERROR_SUCCESS;
675 }
676
677 /***********************************************************************
678 * PdhGetCounterInfoW (PDH.@)
679 */
680 PDH_STATUS WINAPI PdhGetCounterInfoW( PDH_HCOUNTER handle, BOOLEAN text, LPDWORD size, PPDH_COUNTER_INFO_W info )
681 {
682 struct counter *counter = handle;
683
684 TRACE("%p %d %p %p\n", handle, text, size, info);
685
686 EnterCriticalSection( &pdh_handle_cs );
687 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
688 {
689 LeaveCriticalSection( &pdh_handle_cs );
690 return PDH_INVALID_HANDLE;
691 }
692 if (!size)
693 {
694 LeaveCriticalSection( &pdh_handle_cs );
695 return PDH_INVALID_ARGUMENT;
696 }
697 if (*size < sizeof(PDH_COUNTER_INFO_W))
698 {
699 *size = sizeof(PDH_COUNTER_INFO_W);
700 LeaveCriticalSection( &pdh_handle_cs );
701 return PDH_MORE_DATA;
702 }
703
704 memset( info, 0, sizeof(PDH_COUNTER_INFO_W) );
705
706 info->dwType = counter->type;
707 info->CStatus = counter->status;
708 info->lScale = counter->scale;
709 info->lDefaultScale = counter->defaultscale;
710 info->dwUserData = counter->user;
711 info->dwQueryUserData = counter->queryuser;
712
713 *size = sizeof(PDH_COUNTER_INFO_W);
714
715 LeaveCriticalSection( &pdh_handle_cs );
716 return ERROR_SUCCESS;
717 }
718
719 /***********************************************************************
720 * PdhGetCounterTimeBase (PDH.@)
721 */
722 PDH_STATUS WINAPI PdhGetCounterTimeBase( PDH_HCOUNTER handle, LONGLONG *base )
723 {
724 struct counter *counter = handle;
725
726 TRACE("%p %p\n", handle, base);
727
728 if (!base) return PDH_INVALID_ARGUMENT;
729
730 EnterCriticalSection( &pdh_handle_cs );
731 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
732 {
733 LeaveCriticalSection( &pdh_handle_cs );
734 return PDH_INVALID_HANDLE;
735 }
736
737 *base = counter->base;
738
739 LeaveCriticalSection( &pdh_handle_cs );
740 return ERROR_SUCCESS;
741 }
742
743 /***********************************************************************
744 * PdhGetDllVersion (PDH.@)
745 */
746 PDH_STATUS WINAPI PdhGetDllVersion( LPDWORD version )
747 {
748 if (!version)
749 return PDH_INVALID_ARGUMENT;
750
751 *version = PDH_VERSION;
752
753 return ERROR_SUCCESS;
754 }
755
756 /***********************************************************************
757 * PdhGetFormattedCounterValue (PDH.@)
758 */
759 PDH_STATUS WINAPI PdhGetFormattedCounterValue( PDH_HCOUNTER handle, DWORD format,
760 LPDWORD type, PPDH_FMT_COUNTERVALUE value )
761 {
762 PDH_STATUS ret;
763 struct counter *counter = handle;
764
765 TRACE("%p %x %p %p\n", handle, format, type, value);
766
767 if (!value) return PDH_INVALID_ARGUMENT;
768
769 EnterCriticalSection( &pdh_handle_cs );
770 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
771 {
772 LeaveCriticalSection( &pdh_handle_cs );
773 return PDH_INVALID_HANDLE;
774 }
775 if (counter->status)
776 {
777 LeaveCriticalSection( &pdh_handle_cs );
778 return PDH_INVALID_DATA;
779 }
780 if (!(ret = format_value( counter, format, &counter->one, &counter->two, value )))
781 {
782 value->CStatus = ERROR_SUCCESS;
783 if (type) *type = counter->type;
784 }
785
786 LeaveCriticalSection( &pdh_handle_cs );
787 return ret;
788 }
789
790 /***********************************************************************
791 * PdhGetRawCounterValue (PDH.@)
792 */
793 PDH_STATUS WINAPI PdhGetRawCounterValue( PDH_HCOUNTER handle, LPDWORD type,
794 PPDH_RAW_COUNTER value )
795 {
796 struct counter *counter = handle;
797
798 TRACE("%p %p %p\n", handle, type, value);
799
800 if (!value) return PDH_INVALID_ARGUMENT;
801
802 EnterCriticalSection( &pdh_handle_cs );
803 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
804 {
805 LeaveCriticalSection( &pdh_handle_cs );
806 return PDH_INVALID_HANDLE;
807 }
808
809 value->CStatus = counter->status;
810 value->TimeStamp.dwLowDateTime = counter->stamp.dwLowDateTime;
811 value->TimeStamp.dwHighDateTime = counter->stamp.dwHighDateTime;
812 value->FirstValue = counter->one.largevalue;
813 value->SecondValue = counter->two.largevalue;
814 value->MultiCount = 1; /* FIXME */
815
816 if (type) *type = counter->type;
817
818 LeaveCriticalSection( &pdh_handle_cs );
819 return ERROR_SUCCESS;
820 }
821
822 /***********************************************************************
823 * PdhLookupPerfIndexByNameA (PDH.@)
824 */
825 PDH_STATUS WINAPI PdhLookupPerfIndexByNameA( LPCSTR machine, LPCSTR name, LPDWORD index )
826 {
827 PDH_STATUS ret;
828 WCHAR *machineW = NULL;
829 WCHAR *nameW;
830
831 TRACE("%s %s %p\n", debugstr_a(machine), debugstr_a(name), index);
832
833 if (!name) return PDH_INVALID_ARGUMENT;
834
835 if (machine && !(machineW = pdh_strdup_aw( machine ))) return PDH_MEMORY_ALLOCATION_FAILURE;
836
837 if (!(nameW = pdh_strdup_aw( name )))
838 return PDH_MEMORY_ALLOCATION_FAILURE;
839
840 ret = PdhLookupPerfIndexByNameW( machineW, nameW, index );
841
842 heap_free( nameW );
843 heap_free( machineW );
844 return ret;
845 }
846
847 /***********************************************************************
848 * PdhLookupPerfIndexByNameW (PDH.@)
849 */
850 PDH_STATUS WINAPI PdhLookupPerfIndexByNameW( LPCWSTR machine, LPCWSTR name, LPDWORD index )
851 {
852 unsigned int i;
853
854 TRACE("%s %s %p\n", debugstr_w(machine), debugstr_w(name), index);
855
856 if (!name || !index) return PDH_INVALID_ARGUMENT;
857
858 if (machine)
859 {
860 FIXME("remote machine not supported\n");
861 return PDH_CSTATUS_NO_MACHINE;
862 }
863 for (i = 0; i < ARRAY_SIZE(counter_sources); i++)
864 {
865 if (pdh_match_path( counter_sources[i].path, name ))
866 {
867 *index = counter_sources[i].index;
868 return ERROR_SUCCESS;
869 }
870 }
871 return PDH_STRING_NOT_FOUND;
872 }
873
874 /***********************************************************************
875 * PdhLookupPerfNameByIndexA (PDH.@)
876 */
877 PDH_STATUS WINAPI PdhLookupPerfNameByIndexA( LPCSTR machine, DWORD index, LPSTR buffer, LPDWORD size )
878 {
879 PDH_STATUS ret;
880 WCHAR *machineW = NULL;
881 WCHAR bufferW[PDH_MAX_COUNTER_NAME];
882 DWORD sizeW = ARRAY_SIZE(bufferW);
883
884 TRACE("%s %d %p %p\n", debugstr_a(machine), index, buffer, size);
885
886 if (!buffer || !size) return PDH_INVALID_ARGUMENT;
887
888 if (machine && !(machineW = pdh_strdup_aw( machine ))) return PDH_MEMORY_ALLOCATION_FAILURE;
889
890 if (!(ret = PdhLookupPerfNameByIndexW( machineW, index, bufferW, &sizeW )))
891 {
892 int required = WideCharToMultiByte( CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL );
893
894 if (*size < required) ret = PDH_MORE_DATA;
895 else WideCharToMultiByte( CP_ACP, 0, bufferW, -1, buffer, required, NULL, NULL );
896 *size = required;
897 }
898 heap_free( machineW );
899 return ret;
900 }
901
902 /***********************************************************************
903 * PdhLookupPerfNameByIndexW (PDH.@)
904 */
905 PDH_STATUS WINAPI PdhLookupPerfNameByIndexW( LPCWSTR machine, DWORD index, LPWSTR buffer, LPDWORD size )
906 {
907 PDH_STATUS ret;
908 unsigned int i;
909
910 TRACE("%s %d %p %p\n", debugstr_w(machine), index, buffer, size);
911
912 if (machine)
913 {
914 FIXME("remote machine not supported\n");
915 return PDH_CSTATUS_NO_MACHINE;
916 }
917
918 if (!buffer || !size) return PDH_INVALID_ARGUMENT;
919 if (!index) return ERROR_SUCCESS;
920
921 for (i = 0; i < ARRAY_SIZE(counter_sources); i++)
922 {
923 if (counter_sources[i].index == index)
924 {
925 WCHAR *p = wcsrchr( counter_sources[i].path, '\\' ) + 1;
926 unsigned int required = lstrlenW( p ) + 1;
927
928 if (*size < required) ret = PDH_MORE_DATA;
929 else
930 {
931 lstrcpyW( buffer, p );
932 ret = ERROR_SUCCESS;
933 }
934 *size = required;
935 return ret;
936 }
937 }
938 return PDH_INVALID_ARGUMENT;
939 }
940
941 /***********************************************************************
942 * PdhOpenQueryA (PDH.@)
943 */
944 PDH_STATUS WINAPI PdhOpenQueryA( LPCSTR source, DWORD_PTR userdata, PDH_HQUERY *query )
945 {
946 PDH_STATUS ret;
947 WCHAR *sourceW = NULL;
948
949 TRACE("%s %lx %p\n", debugstr_a(source), userdata, query);
950
951 if (source && !(sourceW = pdh_strdup_aw( source ))) return PDH_MEMORY_ALLOCATION_FAILURE;
952
953 ret = PdhOpenQueryW( sourceW, userdata, query );
954 heap_free( sourceW );
955
956 return ret;
957 }
958
959 /***********************************************************************
960 * PdhOpenQueryW (PDH.@)
961 */
962 PDH_STATUS WINAPI PdhOpenQueryW( LPCWSTR source, DWORD_PTR userdata, PDH_HQUERY *handle )
963 {
964 struct query *query;
965
966 TRACE("%s %lx %p\n", debugstr_w(source), userdata, handle);
967
968 if (!handle) return PDH_INVALID_ARGUMENT;
969
970 if (source)
971 {
972 FIXME("log file data source not supported\n");
973 return PDH_INVALID_ARGUMENT;
974 }
975 if ((query = create_query()))
976 {
977 query->user = userdata;
978 *handle = query;
979
980 return ERROR_SUCCESS;
981 }
982 return PDH_MEMORY_ALLOCATION_FAILURE;
983 }
984
985 /***********************************************************************
986 * PdhRemoveCounter (PDH.@)
987 */
988 PDH_STATUS WINAPI PdhRemoveCounter( PDH_HCOUNTER handle )
989 {
990 struct counter *counter = handle;
991
992 TRACE("%p\n", handle);
993
994 EnterCriticalSection( &pdh_handle_cs );
995 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
996 {
997 LeaveCriticalSection( &pdh_handle_cs );
998 return PDH_INVALID_HANDLE;
999 }
1000
1001 list_remove( &counter->entry );
1002 destroy_counter( counter );
1003
1004 LeaveCriticalSection( &pdh_handle_cs );
1005 return ERROR_SUCCESS;
1006 }
1007
1008 /***********************************************************************
1009 * PdhSetCounterScaleFactor (PDH.@)
1010 */
1011 PDH_STATUS WINAPI PdhSetCounterScaleFactor( PDH_HCOUNTER handle, LONG factor )
1012 {
1013 struct counter *counter = handle;
1014
1015 TRACE("%p\n", handle);
1016
1017 EnterCriticalSection( &pdh_handle_cs );
1018 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
1019 {
1020 LeaveCriticalSection( &pdh_handle_cs );
1021 return PDH_INVALID_HANDLE;
1022 }
1023 if (factor < PDH_MIN_SCALE || factor > PDH_MAX_SCALE)
1024 {
1025 LeaveCriticalSection( &pdh_handle_cs );
1026 return PDH_INVALID_ARGUMENT;
1027 }
1028
1029 counter->scale = factor;
1030
1031 LeaveCriticalSection( &pdh_handle_cs );
1032 return ERROR_SUCCESS;
1033 }
1034
1035 /***********************************************************************
1036 * PdhValidatePathA (PDH.@)
1037 */
1038 PDH_STATUS WINAPI PdhValidatePathA( LPCSTR path )
1039 {
1040 PDH_STATUS ret;
1041 WCHAR *pathW;
1042
1043 TRACE("%s\n", debugstr_a(path));
1044
1045 if (!path) return PDH_INVALID_ARGUMENT;
1046 if (!(pathW = pdh_strdup_aw( path ))) return PDH_MEMORY_ALLOCATION_FAILURE;
1047
1048 ret = PdhValidatePathW( pathW );
1049
1050 heap_free( pathW );
1051 return ret;
1052 }
1053
1054 static PDH_STATUS validate_path( LPCWSTR path )
1055 {
1056 if (!path || !*path) return PDH_INVALID_ARGUMENT;
1057 if (*path++ != '\\' || !wcschr( path, '\\' )) return PDH_CSTATUS_BAD_COUNTERNAME;
1058 return ERROR_SUCCESS;
1059 }
1060
1061 /***********************************************************************
1062 * PdhValidatePathW (PDH.@)
1063 */
1064 PDH_STATUS WINAPI PdhValidatePathW( LPCWSTR path )
1065 {
1066 PDH_STATUS ret;
1067 unsigned int i;
1068
1069 TRACE("%s\n", debugstr_w(path));
1070
1071 if ((ret = validate_path( path ))) return ret;
1072
1073 for (i = 0; i < ARRAY_SIZE(counter_sources); i++)
1074 if (pdh_match_path( counter_sources[i].path, path )) return ERROR_SUCCESS;
1075
1076 return PDH_CSTATUS_NO_COUNTER;
1077 }
1078
1079 /***********************************************************************
1080 * PdhVbAddCounter (PDH.@)
1081 */
1082 PDH_STATUS WINAPI PdhVbAddCounter( PDH_HQUERY query, LPCSTR path, PDH_HCOUNTER *counter )
1083 {
1084 FIXME("%p, %s, %p: stub!\n", query, debugstr_a(path), counter);
1085
1086 if (!path) return PDH_INVALID_ARGUMENT;
1087
1088 return PDH_NOT_IMPLEMENTED;
1089 }
1090
1091 /***********************************************************************
1092 * PdhValidatePathExA (PDH.@)
1093 */
1094 PDH_STATUS WINAPI PdhValidatePathExA( PDH_HLOG source, LPCSTR path )
1095 {
1096 TRACE("%p %s\n", source, debugstr_a(path));
1097
1098 if (source)
1099 {
1100 FIXME("log file data source not supported\n");
1101 return ERROR_SUCCESS;
1102 }
1103 return PdhValidatePathA( path );
1104 }
1105
1106 /***********************************************************************
1107 * PdhValidatePathExW (PDH.@)
1108 */
1109 PDH_STATUS WINAPI PdhValidatePathExW( PDH_HLOG source, LPCWSTR path )
1110 {
1111 TRACE("%p %s\n", source, debugstr_w(path));
1112
1113 if (source)
1114 {
1115 FIXME("log file data source not supported\n");
1116 return ERROR_SUCCESS;
1117 }
1118 return PdhValidatePathW( path );
1119 }
1120
1121 /***********************************************************************
1122 * PdhMakeCounterPathA (PDH.@)
1123 */
1124 PDH_STATUS WINAPI PdhMakeCounterPathA( PDH_COUNTER_PATH_ELEMENTS_A *e, LPSTR buffer,
1125 LPDWORD buflen, DWORD flags )
1126 {
1127 PDH_STATUS ret = PDH_MEMORY_ALLOCATION_FAILURE;
1128 PDH_COUNTER_PATH_ELEMENTS_W eW;
1129 WCHAR *bufferW;
1130 DWORD buflenW;
1131
1132 TRACE("%p %p %p 0x%08x\n", e, buffer, buflen, flags);
1133
1134 if (!e || !buflen) return PDH_INVALID_ARGUMENT;
1135
1136 memset( &eW, 0, sizeof(eW) );
1137 if (e->szMachineName && !(eW.szMachineName = pdh_strdup_aw( e->szMachineName ))) goto done;
1138 if (e->szObjectName && !(eW.szObjectName = pdh_strdup_aw( e->szObjectName ))) goto done;
1139 if (e->szInstanceName && !(eW.szInstanceName = pdh_strdup_aw( e->szInstanceName ))) goto done;
1140 if (e->szParentInstance && !(eW.szParentInstance = pdh_strdup_aw( e->szParentInstance ))) goto done;
1141 if (e->szCounterName && !(eW.szCounterName = pdh_strdup_aw( e->szCounterName ))) goto done;
1142 eW.dwInstanceIndex = e->dwInstanceIndex;
1143
1144 buflenW = 0;
1145 ret = PdhMakeCounterPathW( &eW, NULL, &buflenW, flags );
1146 if (ret == PDH_MORE_DATA)
1147 {
1148 if ((bufferW = heap_alloc( buflenW * sizeof(WCHAR) )))
1149 {
1150 if (!(ret = PdhMakeCounterPathW( &eW, bufferW, &buflenW, flags )))
1151 {
1152 int len = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
1153 if (*buflen >= len) WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, *buflen, NULL, NULL);
1154 else ret = PDH_MORE_DATA;
1155 *buflen = len;
1156 }
1157 heap_free( bufferW );
1158 }
1159 else
1160 ret = PDH_MEMORY_ALLOCATION_FAILURE;
1161 }
1162
1163 done:
1164 heap_free( eW.szMachineName );
1165 heap_free( eW.szObjectName );
1166 heap_free( eW.szInstanceName );
1167 heap_free( eW.szParentInstance );
1168 heap_free( eW.szCounterName );
1169 return ret;
1170 }
1171
1172 /***********************************************************************
1173 * PdhMakeCounterPathW (PDH.@)
1174 */
1175 PDH_STATUS WINAPI PdhMakeCounterPathW( PDH_COUNTER_PATH_ELEMENTS_W *e, LPWSTR buffer,
1176 LPDWORD buflen, DWORD flags )
1177 {
1178 WCHAR path[PDH_MAX_COUNTER_NAME], instance[12];
1179 PDH_STATUS ret = ERROR_SUCCESS;
1180 DWORD len;
1181
1182 TRACE("%p %p %p 0x%08x\n", e, buffer, buflen, flags);
1183
1184 if (flags) FIXME("unimplemented flags 0x%08x\n", flags);
1185
1186 if (!e || !e->szCounterName || !e->szObjectName || !buflen)
1187 return PDH_INVALID_ARGUMENT;
1188
1189 path[0] = 0;
1190 if (e->szMachineName)
1191 {
1192 lstrcatW(path, L"\\\\");
1193 lstrcatW(path, e->szMachineName);
1194 }
1195 lstrcatW(path, L"\\");
1196 lstrcatW(path, e->szObjectName);
1197 if (e->szInstanceName)
1198 {
1199 lstrcatW(path, L"(");
1200 if (e->szParentInstance)
1201 {
1202 lstrcatW(path, e->szParentInstance);
1203 lstrcatW(path, L"/");
1204 }
1205 lstrcatW(path, e->szInstanceName);
1206 swprintf(instance, ARRAY_SIZE(instance), L"#%u", e->dwInstanceIndex);
1207 lstrcatW(path, instance);
1208 lstrcatW(path, L")");
1209 }
1210 lstrcatW(path, L"\\");
1211 lstrcatW(path, e->szCounterName);
1212
1213 len = lstrlenW(path) + 1;
1214 if (*buflen >= len) lstrcpyW(buffer, path);
1215 else ret = PDH_MORE_DATA;
1216 *buflen = len;
1217 return ret;
1218 }
1219
1220 /***********************************************************************
1221 * PdhEnumObjectItemsA (PDH.@)
1222 */
1223 PDH_STATUS WINAPI PdhEnumObjectItemsA(LPCSTR szDataSource, LPCSTR szMachineName, LPCSTR szObjectName,
1224 LPSTR mszCounterList, LPDWORD pcchCounterListLength, LPSTR mszInstanceList,
1225 LPDWORD pcchInstanceListLength, DWORD dwDetailLevel, DWORD dwFlags)
1226 {
1227 FIXME("%s, %s, %s, %p, %p, %p, %p, %d, 0x%x: stub\n", debugstr_a(szDataSource), debugstr_a(szMachineName),
1228 debugstr_a(szObjectName), mszCounterList, pcchCounterListLength, mszInstanceList,
1229 pcchInstanceListLength, dwDetailLevel, dwFlags);
1230
1231 return PDH_NOT_IMPLEMENTED;
1232 }
1233
1234 /***********************************************************************
1235 * PdhEnumObjectItemsW (PDH.@)
1236 */
1237 PDH_STATUS WINAPI PdhEnumObjectItemsW(LPCWSTR szDataSource, LPCWSTR szMachineName, LPCWSTR szObjectName,
1238 LPWSTR mszCounterList, LPDWORD pcchCounterListLength, LPWSTR mszInstanceList,
1239 LPDWORD pcchInstanceListLength, DWORD dwDetailLevel, DWORD dwFlags)
1240 {
1241 FIXME("%s, %s, %s, %p, %p, %p, %p, %d, 0x%x: stub\n", debugstr_w(szDataSource), debugstr_w(szMachineName),
1242 debugstr_w(szObjectName), mszCounterList, pcchCounterListLength, mszInstanceList,
1243 pcchInstanceListLength, dwDetailLevel, dwFlags);
1244
1245 return PDH_NOT_IMPLEMENTED;
1246 }
1247
1248 /***********************************************************************
1249 * PdhSetDefaultRealTimeDataSource (PDH.@)
1250 */
1251 PDH_STATUS WINAPI PdhSetDefaultRealTimeDataSource( DWORD source )
1252 {
1253 FIXME("%u\n", source);
1254 return ERROR_SUCCESS;
1255 }
1256
1257 /***********************************************************************
1258 * PdhGetLogFileTypeA (PDH.@)
1259 */
1260 PDH_STATUS WINAPI PdhGetLogFileTypeA(const char *log, DWORD *type)
1261 {
1262 FIXME("%s, %p: stub\n", debugstr_a(log), type);
1263 return PDH_NOT_IMPLEMENTED;
1264 }
1265
1266 /***********************************************************************
1267 * PdhGetLogFileTypeW (PDH.@)
1268 */
1269 PDH_STATUS WINAPI PdhGetLogFileTypeW(const WCHAR *log, DWORD *type)
1270 {
1271 FIXME("%s, %p: stub\n", debugstr_w(log), type);
1272 return PDH_NOT_IMPLEMENTED;
1273 }
1274
1275 /***********************************************************************
1276 * PdhBindInputDataSourceA (PDH.@)
1277 */
1278 PDH_STATUS WINAPI PdhBindInputDataSourceA(PDH_HLOG *source, const char *filenamelist)
1279 {
1280 FIXME("%p %s: stub\n", source, debugstr_a(filenamelist));
1281 return PDH_NOT_IMPLEMENTED;
1282 }
1283
1284 /***********************************************************************
1285 * PdhBindInputDataSourceW (PDH.@)
1286 */
1287 PDH_STATUS WINAPI PdhBindInputDataSourceW(PDH_HLOG *source, const WCHAR *filenamelist)
1288 {
1289 FIXME("%p %s: stub\n", source, debugstr_w(filenamelist));
1290 return PDH_NOT_IMPLEMENTED;
1291 }
Windows API implementation