dlls/pdh/pdh_main.c

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