git.oblomov.eu Git - wine/blob - misc/version.c

   1 /*
   2  * Windows and DOS version functions
   3  *
   4  * Copyright 1997 Alexandre Julliard
   5  * Copyright 1997 Marcus Meissner
   6  * Copyright 1998 Patrik Stridvall
   7  * Copyright 1998 Andreas Mohr
   8  */
   9
  10 #include <string.h>
  11 #include <stdlib.h>
  12 #include <stdio.h>
  13 #include "windef.h"
  14 #include "winbase.h"
  15 #include "wingdi.h"
  16 #include "winuser.h"
  17 #include "wine/winbase16.h"
  18 #include "module.h"
  19 #include "options.h"
  20 #include "debugtools.h"
  21 #include "winerror.h"
  22
  23 DEFAULT_DEBUG_CHANNEL(ver);
  24
  25 typedef enum
  26 {
  27     WIN20,   /* Windows 2.0 */
  28     WIN30,   /* Windows 3.0 */
  29     WIN31,   /* Windows 3.1 */
  30     WIN95,   /* Windows 95 */
  31     WIN98,   /* Windows 98 */
  32     WINME,   /* Windows Me */
  33     NT351,   /* Windows NT 3.51 */
  34     NT40,    /* Windows NT 4.0 */
  35     NT2K,    /* Windows 2000 */
  36     WINXP,   /* Windows XP */
  37     NB_WINDOWS_VERSIONS
  38 } WINDOWS_VERSION;
  39
  40 typedef struct
  41 {
  42     LONG             getVersion16;
  43     LONG             getVersion32;
  44     OSVERSIONINFOA getVersionEx;
  45 } VERSION_DATA;
  46
  47 /* FIXME: compare values below with original and fix */
  48 static VERSION_DATA VersionData[NB_WINDOWS_VERSIONS] =
  49 {
  50     /* WIN20 FIXME: verify values */
  51     {
  52         MAKELONG( 0x0002, 0x0303 ), /* assume DOS 3.3 */
  53         MAKELONG( 0x0003, 0x8000 ),
  54         {
  55             sizeof(OSVERSIONINFOA), 2, 0, 0,
  56             VER_PLATFORM_WIN32s, "Win32s 1.3"
  57         }
  58     },
  59     /* WIN30 FIXME: verify values */
  60     {
  61         MAKELONG( 0x0003, 0x0500 ), /* assume DOS 5.00 */
  62         MAKELONG( 0x0003, 0x8000 ),
  63         {
  64             sizeof(OSVERSIONINFOA), 3, 0, 0,
  65             VER_PLATFORM_WIN32s, "Win32s 1.3"
  66         }
  67     },
  68     /* WIN31 */
  69     {
  70         MAKELONG( 0x0a03, 0x0616 ), /* DOS 6.22 */
  71         MAKELONG( 0x0a03, 0x8000 ),
  72         {
  73             sizeof(OSVERSIONINFOA), 3, 10, 0,
  74             VER_PLATFORM_WIN32s, "Win32s 1.3"
  75         }
  76     },
  77     /* WIN95 */
  78     {
  79         0x07005F03,
  80         0xC0000004,
  81         {
  82             /* Win95:       4, 0, 0x40003B6, ""
  83              * Win95sp1:    4, 0, 0x40003B6, " A " (according to doc)
  84              * Win95osr2:   4, 0, 0x4000457, " B " (according to doc)
  85              * Win95osr2.1: 4, 3, 0x40304BC, " B " (according to doc)
  86              * Win95osr2.5: 4, 3, 0x40304BE, " C " (according to doc)
  87              * Win95a/b can be discerned via regkey SubVersionNumber
  88              * See also:
  89              * http://support.microsoft.com/support/kb/articles/q158/2/38.asp
  90              */
  91             sizeof(OSVERSIONINFOA), 4, 0, 0x40003B6,
  92             VER_PLATFORM_WIN32_WINDOWS, ""
  93         }
  94     },
  95     /* WIN98 */
  96     {
  97         0x070A5F03,
  98         0xC0000A04,
  99         {
 100             /* Win98:   4, 10, 0x40A07CE, " "
 101              * Win98SE: 4, 10, 0x40A08AE, " A "
 102              */
 103             sizeof(OSVERSIONINFOA), 4, 10, 0x40A07CE,
 104             VER_PLATFORM_WIN32_WINDOWS, " "
 105         }
 106     },
 107     /* WINME */
 108     {
 109         0x07005F03, /* Assuming DOS 7 like the other Win9x */
 110         0xC0005A04,
 111         {
 112             sizeof(OSVERSIONINFOA), 4, 90, 0x45A0BB8,
 113             VER_PLATFORM_WIN32_WINDOWS, " "
 114         }
 115     },
 116     /* NT351 */
 117     {
 118         0x05000A03,
 119         0x04213303,
 120         {
 121             sizeof(OSVERSIONINFOA), 3, 51, 0x421,
 122             VER_PLATFORM_WIN32_NT, "Service Pack 2"
 123         }
 124     },
 125     /* NT40 */
 126     {
 127         0x05000A03,
 128         0x05650004,
 129         {
 130             sizeof(OSVERSIONINFOA), 4, 0, 0x565,
 131             VER_PLATFORM_WIN32_NT, "Service Pack 6"
 132         }
 133     },
 134     /* NT2K */
 135     {
 136         0x05005F03,
 137         0x08930005,
 138         {
 139             sizeof(OSVERSIONINFOA), 5, 0, 0x893,
 140             VER_PLATFORM_WIN32_NT, "Service Pack 2"
 141         }
 142     },
 143     /* WINXP */
 144     {
 145         0x05005F03, /* Assuming DOS 5 like the other NT */
 146         0x0A280105,
 147         {
 148             sizeof(OSVERSIONINFOA), 5, 1, 0xA28,
 149             VER_PLATFORM_WIN32_NT, ""
 150         }
 151     }
 152 };
 153
 154 static const char *WinVersionNames[NB_WINDOWS_VERSIONS] =
 155 { /* no spaces in here ! */
 156     "win20",
 157     "win30",
 158     "win31",
 159     "win95",
 160     "win98",
 161     "winme",
 162     "nt351",
 163     "nt40",
 164     "win2000,win2k,nt2k,nt2000",
 165     "winxp"
 166 };
 167
 168 /* if one of the following dlls is importing ntdll the windows
 169 version autodetection switches wine to unicode (nt 3.51 or 4.0) */
 170 static char * special_dlls[] =
 171 {
 172         "COMDLG32",
 173         "COMCTL32",
 174         "SHELL32",
 175         "OLE32",
 176         "RPCRT4",
 177         NULL
 178 };
 179
 180 /* the current version has not been autodetected but forced via cmdline */
 181 static BOOL versionForced = FALSE;
 182 static WINDOWS_VERSION defaultWinVersion = WIN31;
 183
 184 /**********************************************************************
 185  *         VERSION_ParseWinVersion
 186  */
 187 void VERSION_ParseWinVersion( const char *arg )
 188 {
 189     int i, len;
 190     const char *pCurr, *p;
 191     for (i = 0; i < NB_WINDOWS_VERSIONS; i++)
 192     {
 193         pCurr = WinVersionNames[i];
 194         /* iterate through all winver aliases separated by comma */
 195         do {
 196             p = strchr(pCurr, ',');
 197             len = p ? (int)p - (int)pCurr : strlen(pCurr);
 198             if ( (!strncmp( pCurr, arg, len )) && (arg[len] == '\0') )
 199             {
 200                 defaultWinVersion = (WINDOWS_VERSION)i;
 201                 versionForced = TRUE;
 202                 return;
 203             }
 204             pCurr = p+1;
 205         } while (p);
 206     }
 207     MESSAGE("Invalid winver value '%s' specified.\n", arg );
 208     MESSAGE("Valid versions are:" );
 209     for (i = 0; i < NB_WINDOWS_VERSIONS; i++)
 210     {
 211         /* only list the first, "official" alias in case of aliases */
 212         pCurr = WinVersionNames[i];
 213         p = strchr(pCurr, ',');
 214         len = (p) ? (int)p - (int)pCurr : strlen(pCurr);
 215
 216         MESSAGE(" '%.*s'%c", len, pCurr,
 217                 (i == NB_WINDOWS_VERSIONS - 1) ? '\n' : ',' );
 218     }
 219     ExitProcess(1);
 220 }
 221
 222
 223 /**********************************************************************
 224  *         VERSION_ParseDosVersion
 225  */
 226 void VERSION_ParseDosVersion( const char *arg )
 227 {
 228     int hi, lo;
 229     if (sscanf( arg, "%d.%d", &hi, &lo ) == 2)
 230     {
 231         VersionData[WIN31].getVersion16 =
 232             MAKELONG(LOWORD(VersionData[WIN31].getVersion16),
 233                      (hi<<8) + lo);
 234     }
 235     else
 236     {
 237         MESSAGE("--dosver: Wrong version format. Use \"--dosver x.xx\"\n");
 238         ExitProcess(1);
 239     }
 240 }
 241
 242 /**********************************************************************
 243  *      VERSION_GetSystemDLLVersion
 244  *
 245  * This function tries to figure out if a given (native) dll comes from
 246  * win95/98 or winnt. Since all values in the OptionalHeader are not a
 247  * usable hint, we test if a dll imports the ntdll.
 248  * This is at least working for all system dlls like comctl32, comdlg32 and
 249  * shell32.
 250  * If you have a better idea to figure this out...
 251  */
 252 static DWORD VERSION_GetSystemDLLVersion( HMODULE hmod )
 253 {
 254     IMAGE_DATA_DIRECTORY *dir = PE_HEADER(hmod)->OptionalHeader.DataDirectory
 255                                 + IMAGE_DIRECTORY_ENTRY_IMPORT;
 256     if (dir->Size && dir->VirtualAddress)
 257     {
 258         IMAGE_IMPORT_DESCRIPTOR *pe_imp = (IMAGE_IMPORT_DESCRIPTOR *)((char *)hmod + dir->VirtualAddress);
 259         for ( ; pe_imp->Name; pe_imp++)
 260         {
 261             char * name = (char *)hmod + (unsigned int)pe_imp->Name;
 262             TRACE("%s\n", name);
 263
 264             if (!strncasecmp(name, "ntdll", 5))
 265             {
 266               if (3 == PE_HEADER(hmod)->OptionalHeader.MajorOperatingSystemVersion)
 267                 return NT351;
 268               else
 269                 return NT40;
 270             }
 271         }
 272     }
 273     return WIN95;
 274 }
 275 /**********************************************************************
 276  *      VERSION_GetLinkedDllVersion
 277  *
 278  * Some version data (not reliable!):
 279  * linker/OS/image/subsys
 280  *
 281  * x.xx/1.00/0.00/3.10  Win32s          (any version ?)
 282  * 2.39/1.00/0.00/3.10  Win32s          freecell.exe (any version)
 283  * 2.50/1.00/4.00/4.00  Win32s 1.30     winhlp32.exe
 284  * 2.60/3.51/3.51/3.51  NT351SP5        system dlls
 285  * 2.60/3.51/3.51/4.00  NT351SP5        comctl32 dll
 286  * 2.xx/1.00/0.00/4.00  Win95           system files
 287  * x.xx/4.00/0.00/4.00  Win95           most applications
 288  * 3.10/4.00/0.00/4.00  Win98           notepad
 289  * x.xx/5.00/5.00/4.00  Win98           system dlls
 290  * x.xx/4.00/4.00/4.00  NT 4            most apps
 291  * 5.12/5.00/5.00/4.00  NT4+IE5         comctl32.dll
 292  * 5.12/5.00/5.00/4.00  Win98           calc
 293  * x.xx/5.00/5.00/4.00  win95/win98/NT4 IE5 files
 294  */
 295 DWORD VERSION_GetLinkedDllVersion(void)
 296 {
 297         WINE_MODREF *wm;
 298         DWORD WinVersion = NB_WINDOWS_VERSIONS;
 299         PIMAGE_OPTIONAL_HEADER ophd;
 300
 301         /* First check the native dlls provided. These have to be
 302         from one windows version */
 303         for ( wm = MODULE_modref_list; wm; wm=wm->next )
 304         {
 305           ophd = &(PE_HEADER(wm->module)->OptionalHeader);
 306
 307           TRACE("%s: %02x.%02x/%02x.%02x/%02x.%02x/%02x.%02x\n",
 308             wm->modname,
 309             ophd->MajorLinkerVersion, ophd->MinorLinkerVersion,
 310             ophd->MajorOperatingSystemVersion, ophd->MinorOperatingSystemVersion,
 311             ophd->MajorImageVersion, ophd->MinorImageVersion,
 312             ophd->MajorSubsystemVersion, ophd->MinorSubsystemVersion);
 313
 314           /* test if it is an external (native) dll */
 315           if (!(wm->flags & WINE_MODREF_INTERNAL))
 316           {
 317             int i;
 318             for (i = 0; special_dlls[i]; i++)
 319             {
 320               /* test if it is a special dll */
 321               if (!strncasecmp(wm->modname, special_dlls[i], strlen(special_dlls[i]) ))
 322               {
 323                 DWORD DllVersion = VERSION_GetSystemDLLVersion(wm->module);
 324                 if (WinVersion == NB_WINDOWS_VERSIONS)
 325                   WinVersion = DllVersion;
 326                 else {
 327                   if (WinVersion != DllVersion) {
 328                     ERR("You mixed system dlls from different windows versions! Expect a crash! (%s: expected version '%s', but is '%s')\n",
 329                         wm->modname,
 330                         VersionData[WinVersion].getVersionEx.szCSDVersion,
 331                         VersionData[DllVersion].getVersionEx.szCSDVersion);
 332                     return WIN31; /* this may let the exe exiting */
 333                   }
 334                 }
 335                 break;
 336               }
 337             }
 338           }
 339         }
 340
 341         if(WinVersion != NB_WINDOWS_VERSIONS) return WinVersion;
 342
 343         /* we are using no external system dlls, look at the exe */
 344         ophd = &(PE_HEADER(GetModuleHandleA(NULL))->OptionalHeader);
 345
 346         TRACE("%02x.%02x/%02x.%02x/%02x.%02x/%02x.%02x\n",
 347             ophd->MajorLinkerVersion, ophd->MinorLinkerVersion,
 348             ophd->MajorOperatingSystemVersion, ophd->MinorOperatingSystemVersion,
 349             ophd->MajorImageVersion, ophd->MinorImageVersion,
 350             ophd->MajorSubsystemVersion, ophd->MinorSubsystemVersion);
 351
 352         /* special nt 3.51 */
 353         if (3 == ophd->MajorOperatingSystemVersion && 51 == ophd->MinorOperatingSystemVersion)
 354         {
 355             return NT351;
 356         }
 357
 358         /* the MajorSubsystemVersion is the only usable sign */
 359         if (ophd->MajorSubsystemVersion < 4)
 360         {
 361           if ( ophd->MajorOperatingSystemVersion == 1
 362             && ophd->MinorOperatingSystemVersion == 0)
 363           {
 364             return WIN31; /* win32s */
 365           }
 366
 367           if (ophd->Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI)
 368             return NT351; /* FIXME: NT 3.1, not tested */
 369           else
 370             return WIN95;
 371         }
 372
 373         return WIN95;
 374 }
 375
 376 /**********************************************************************
 377  *         VERSION_GetVersion
 378  *
 379  * WARNING !!!
 380  * Don't call this function too early during the Wine init,
 381  * as pdb->exe_modref (required by VERSION_GetImageVersion()) might still
 382  * be NULL in such cases, which causes the winver to ALWAYS be detected
 383  * as WIN31.
 384  * And as we cache the winver once it has been determined, this is bad.
 385  * This can happen much easier than you might think, as this function
 386  * is called by EVERY GetVersion*() API !
 387  *
 388  */
 389 static WINDOWS_VERSION VERSION_GetVersion(void)
 390 {
 391     static WORD winver = 0xffff;
 392
 393     if (winver == 0xffff) /* to be determined */
 394     {
 395         WINDOWS_VERSION retver;
 396
 397         if (versionForced) /* user has overridden any sensible checks */
 398             winver = defaultWinVersion;
 399         else
 400         {
 401             retver = VERSION_GetLinkedDllVersion();
 402
 403             /* cache determined value, but do not store in case of WIN31 */
 404             if (retver != WIN31) winver = retver;
 405
 406             return retver;
 407         }
 408     }
 409
 410     return winver;
 411 }
 412
 413
 414 /***********************************************************************
 415  *         GetVersion   (KERNEL.3)
 416  */
 417 LONG WINAPI GetVersion16(void)
 418 {
 419     WINDOWS_VERSION ver = VERSION_GetVersion();
 420     return VersionData[ver].getVersion16;
 421 }
 422
 423
 424 /***********************************************************************
 425  *         GetVersion   (KERNEL32.@)
 426  */
 427 LONG WINAPI GetVersion(void)
 428 {
 429     WINDOWS_VERSION ver = VERSION_GetVersion();
 430     return VersionData[ver].getVersion32;
 431 }
 432
 433
 434 /***********************************************************************
 435  *         GetVersionEx   (KERNEL.149)
 436  */
 437 BOOL16 WINAPI GetVersionEx16(OSVERSIONINFO16 *v)
 438 {
 439     WINDOWS_VERSION ver = VERSION_GetVersion();
 440     if (v->dwOSVersionInfoSize < sizeof(OSVERSIONINFO16))
 441     {
 442         WARN("wrong OSVERSIONINFO size from app\n");
 443         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 444         return FALSE;
 445     }
 446     v->dwMajorVersion = VersionData[ver].getVersionEx.dwMajorVersion;
 447     v->dwMinorVersion = VersionData[ver].getVersionEx.dwMinorVersion;
 448     v->dwBuildNumber  = VersionData[ver].getVersionEx.dwBuildNumber;
 449     v->dwPlatformId   = VersionData[ver].getVersionEx.dwPlatformId;
 450     strcpy( v->szCSDVersion, VersionData[ver].getVersionEx.szCSDVersion );
 451     return TRUE;
 452 }
 453
 454
 455 /***********************************************************************
 456  *         GetVersionExA   (KERNEL32.@)
 457  */
 458 BOOL WINAPI GetVersionExA(OSVERSIONINFOA *v)
 459 {
 460     WINDOWS_VERSION ver = VERSION_GetVersion();
 461     if (v->dwOSVersionInfoSize < sizeof(OSVERSIONINFOA))
 462     {
 463         WARN("wrong OSVERSIONINFO size from app (got: %ld, expected: %d)\n",
 464                         v->dwOSVersionInfoSize, sizeof(OSVERSIONINFOA));
 465         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 466         return FALSE;
 467     }
 468     v->dwMajorVersion = VersionData[ver].getVersionEx.dwMajorVersion;
 469     v->dwMinorVersion = VersionData[ver].getVersionEx.dwMinorVersion;
 470     v->dwBuildNumber  = VersionData[ver].getVersionEx.dwBuildNumber;
 471     v->dwPlatformId   = VersionData[ver].getVersionEx.dwPlatformId;
 472     strcpy( v->szCSDVersion, VersionData[ver].getVersionEx.szCSDVersion );
 473     return TRUE;
 474 }
 475
 476
 477 /***********************************************************************
 478  *         GetVersionExW   (KERNEL32.@)
 479  */
 480 BOOL WINAPI GetVersionExW(OSVERSIONINFOW *v)
 481 {
 482     WINDOWS_VERSION ver = VERSION_GetVersion();
 483
 484     if (v->dwOSVersionInfoSize < sizeof(OSVERSIONINFOW))
 485     {
 486         WARN("wrong OSVERSIONINFO size from app (got: %ld, expected: %d)\n",
 487                         v->dwOSVersionInfoSize, sizeof(OSVERSIONINFOW));
 488         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 489         return FALSE;
 490     }
 491     v->dwMajorVersion = VersionData[ver].getVersionEx.dwMajorVersion;
 492     v->dwMinorVersion = VersionData[ver].getVersionEx.dwMinorVersion;
 493     v->dwBuildNumber  = VersionData[ver].getVersionEx.dwBuildNumber;
 494     v->dwPlatformId   = VersionData[ver].getVersionEx.dwPlatformId;
 495     MultiByteToWideChar( CP_ACP, 0, VersionData[ver].getVersionEx.szCSDVersion, -1,
 496                          v->szCSDVersion, sizeof(v->szCSDVersion)/sizeof(WCHAR) );
 497     return TRUE;
 498 }
 499
 500
 501 /***********************************************************************
 502  *          GetWinFlags   (KERNEL.132)
 503  */
 504 DWORD WINAPI GetWinFlags16(void)
 505 {
 506   static const long cpuflags[5] =
 507     { WF_CPU086, WF_CPU186, WF_CPU286, WF_CPU386, WF_CPU486 };
 508   SYSTEM_INFO si;
 509   OSVERSIONINFOA ovi;
 510   DWORD result;
 511
 512   GetSystemInfo(&si);
 513
 514   /* There doesn't seem to be any Pentium flag.  */
 515   result = cpuflags[min(si.wProcessorLevel, 4)] | WF_ENHANCED | WF_PMODE | WF_80x87 | WF_PAGING;
 516   if (si.wProcessorLevel >= 4) result |= WF_HASCPUID;
 517   ovi.dwOSVersionInfoSize = sizeof(ovi);
 518   GetVersionExA(&ovi);
 519   if (ovi.dwPlatformId == VER_PLATFORM_WIN32_NT)
 520       result |= WF_WIN32WOW; /* undocumented WF_WINNT */
 521   return result;
 522 }
 523
 524
 525 #if 0
 526 /* Not used at this time. This is here for documentation only */
 527
 528 /* WINDEBUGINFO flags values */
 529 #define WDI_OPTIONS         0x0001
 530 #define WDI_FILTER          0x0002
 531 #define WDI_ALLOCBREAK      0x0004
 532
 533 /* dwOptions values */
 534 #define DBO_CHECKHEAP       0x0001
 535 #define DBO_BUFFERFILL      0x0004
 536 #define DBO_DISABLEGPTRAPPING 0x0010
 537 #define DBO_CHECKFREE       0x0020
 538
 539 #define DBO_SILENT          0x8000
 540
 541 #define DBO_TRACEBREAK      0x2000
 542 #define DBO_WARNINGBREAK    0x1000
 543 #define DBO_NOERRORBREAK    0x0800
 544 #define DBO_NOFATALBREAK    0x0400
 545 #define DBO_INT3BREAK       0x0100
 546
 547 /* DebugOutput flags values */
 548 #define DBF_TRACE           0x0000
 549 #define DBF_WARNING         0x4000
 550 #define DBF_ERROR           0x8000
 551 #define DBF_FATAL           0xc000
 552
 553 /* dwFilter values */
 554 #define DBF_KERNEL          0x1000
 555 #define DBF_KRN_MEMMAN      0x0001
 556 #define DBF_KRN_LOADMODULE  0x0002
 557 #define DBF_KRN_SEGMENTLOAD 0x0004
 558 #define DBF_USER            0x0800
 559 #define DBF_GDI             0x0400
 560 #define DBF_MMSYSTEM        0x0040
 561 #define DBF_PENWIN          0x0020
 562 #define DBF_APPLICATION     0x0008
 563 #define DBF_DRIVER          0x0010
 564
 565 #endif /* NOLOGERROR */
 566
 567
 568 /***********************************************************************
 569  *          GetWinDebugInfo   (KERNEL.355)
 570  */
 571 BOOL16 WINAPI GetWinDebugInfo16(WINDEBUGINFO16 *lpwdi, UINT16 flags)
 572 {
 573     FIXME("(%8lx,%d): stub returning 0\n",
 574           (unsigned long)lpwdi, flags);
 575     /* 0 means not in debugging mode/version */
 576     /* Can this type of debugging be used in wine ? */
 577     /* Constants: WDI_OPTIONS WDI_FILTER WDI_ALLOCBREAK */
 578     return 0;
 579 }
 580
 581
 582 /***********************************************************************
 583  *          SetWinDebugInfo   (KERNEL.356)
 584  */
 585 BOOL16 WINAPI SetWinDebugInfo16(WINDEBUGINFO16 *lpwdi)
 586 {
 587     FIXME("(%8lx): stub returning 0\n", (unsigned long)lpwdi);
 588     /* 0 means not in debugging mode/version */
 589     /* Can this type of debugging be used in wine ? */
 590     /* Constants: WDI_OPTIONS WDI_FILTER WDI_ALLOCBREAK */
 591     return 0;
 592 }
 593
 594
 595 /***********************************************************************
 596  *           K329                    (KERNEL.329)
 597  *
 598  * TODO:
 599  * Should fill lpBuffer only if DBO_BUFFERFILL has been set by SetWinDebugInfo()
 600  */
 601 void WINAPI DebugFillBuffer(LPSTR lpBuffer, WORD wBytes)
 602 {
 603         memset(lpBuffer, DBGFILL_BUFFER, wBytes);
 604 }
 605
 606 /***********************************************************************
 607  *           DiagQuery                          (KERNEL.339)
 608  *
 609  * returns TRUE if Win called with "/b" (bootlog.txt)
 610  */
 611 BOOL16 WINAPI DiagQuery16()
 612 {
 613         /* perhaps implement a Wine "/b" command line flag sometime ? */
 614         return FALSE;
 615 }
 616
 617 /***********************************************************************
 618  *           DiagOutput                         (KERNEL.340)
 619  *
 620  * writes a debug string into <windir>\bootlog.txt
 621  */
 622 void WINAPI DiagOutput16(LPCSTR str)
 623 {
 624         /* FIXME */
 625         DPRINTF("DIAGOUTPUT:%s\n", debugstr_a(str));
 626 }