tee.c

   1 /*
   2  * tee for Windows
   3  * Copyright (c) 2023 "dEajL3kA" <Cumpoing79@web.de>
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
   6  * associated documentation files (the "Software"), to deal in the Software without restriction,
   7  * including without limitation the rights to use, copy, modify, merge, publish, distribute,
   8  * sub license, and/or sell copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions: The above copyright notice and this
  10  * permission notice shall be included in all copies or substantial portions of the Software.
  11  *
  12  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
  13  * NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  14  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  15  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
  16  * OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  17  */
  18 #define WIN32_LEAN_AND_MEAN 1
  19 #include <Windows.h>
  20 #include <ShellAPI.h>
  21 #include <intrin.h>
  22 #include <stdarg.h>
  23 #include "include/cpu.h"
  24 #include "include/version.h"
  25
  26 #pragma intrinsic(_InterlockedIncrement, _InterlockedDecrement)
  27
  28 #define BUFFER_SIZE (PROCESSOR_BITNESS * 128U)
  29 #define BUFFERS 3U
  30 #define MAX_THREADS MAXIMUM_WAIT_OBJECTS
  31
  32 // --------------------------------------------------------------------------
  33 // Assertions
  34 // --------------------------------------------------------------------------
  35
  36 #ifndef NDEBUG
  37 #define ASSERT(CONDIATION, HANDLE_OUT, MESSAGE) do { \
  38     static const wchar_t *const _message = L"[tee] Assertion Failed: " MESSAGE L"\n"; \
  39     if (!(CONDIATION)) { \
  40         write_text((HANDLE_OUT), _message); \
  41         FatalExit(-1); \
  42     } \
  43 } while(0)
  44 #else
  45 #define ASSERT(CONDIATION, HANDLE_OUT, MESSAGE) ((void)0)
  46 #endif
  47
  48 // --------------------------------------------------------------------------
  49 // Utilities
  50 // --------------------------------------------------------------------------
  51
  52 #define POS_LONG(X) ((LONG)((X) & MAXLONG))
  53 #define NEG_LONG(X) (-POS_LONG(X))
  54
  55 static wchar_t to_lower(const wchar_t c)
  56 {
  57     return ((c >= L'A') && (c <= L'Z')) ? (L'a' + (c - L'A')) : c;
  58 }
  59
  60 static BOOL is_terminal(const HANDLE handle)
  61 {
  62     DWORD mode;
  63     return GetConsoleMode(handle, &mode);
  64 }
  65
  66 static DWORD count_handles(const HANDLE *const array, const size_t maximum)
  67 {
  68     DWORD counter;
  69     for (counter = 0U; counter < maximum; ++counter)
  70     {
  71         if (!array[counter])
  72         {
  73             break;
  74         }
  75     }
  76
  77     return counter;
  78 }
  79
  80 static const wchar_t *get_filename(const wchar_t *filePath)
  81 {
  82     for (const wchar_t *ptr = filePath; *ptr != L'\0'; ++ptr)
  83     {
  84         if ((*ptr == L'\\') || (*ptr == L'/'))
  85         {
  86             filePath = ptr + 1U;
  87         }
  88     }
  89
  90     return filePath;
  91 }
  92
  93 static BOOL is_null_device(const wchar_t *filePath)
  94 {
  95     filePath = get_filename(filePath);
  96     if ((to_lower(filePath[0U]) == L'n') && (to_lower(filePath[1U]) == L'u') && (to_lower(filePath[2U]) == L'l'))
  97     {
  98         return ((filePath[3U] == L'\0') || (filePath[3U] == L'.'));
  99     }
 100
 101     return FALSE;
 102 }
 103
 104 static wchar_t *format_string(const wchar_t *const format, ...)
 105 {
 106     wchar_t* buffer = NULL;
 107     va_list ap;
 108
 109     va_start(ap, format);
 110     const DWORD result = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER, format, 0U, 0U, (LPWSTR)&buffer, 1U, &ap);
 111     va_end(ap);
 112
 113     return result ? buffer : NULL;
 114 }
 115
 116 static wchar_t *concat_va(const wchar_t *const first, ...)
 117 {
 118     const wchar_t *ptr;
 119     va_list ap;
 120
 121     va_start(ap, first);
 122     size_t len = 0U;
 123     for (ptr = first; ptr != NULL; ptr = va_arg(ap, const wchar_t*))
 124     {
 125         len = lstrlenW(ptr);
 126     }
 127     va_end(ap);
 128
 129     wchar_t *const buffer = (wchar_t*)LocalAlloc(LPTR, sizeof(wchar_t) * (len + 1U));
 130     if (buffer)
 131     {
 132         va_start(ap, first);
 133         for (ptr = first; ptr != NULL; ptr = va_arg(ap, const wchar_t*))
 134         {
 135             lstrcatW(buffer, ptr);
 136         }
 137         va_end(ap);
 138     }
 139
 140     return buffer;
 141 }
 142
 143 #define CONCAT(...) concat_va(__VA_ARGS__, NULL)
 144
 145 #define VALID_HANDLE(HANDLE) (((HANDLE) != NULL) && ((HANDLE) != INVALID_HANDLE_VALUE))
 146
 147 #define FILL_ARRAY(ARRAY, VALUE) do \
 148 { \
 149     for (size_t _index = 0U; _index < ARRAYSIZE(ARRAY); ++_index) \
 150     { \
 151         ARRAY[_index] = (VALUE); \
 152     } \
 153 } \
 154 while (0)
 155
 156 #define CLOSE_HANDLE(HANDLE) do \
 157 { \
 158     if (VALID_HANDLE(HANDLE)) \
 159     { \
 160         CloseHandle((HANDLE)); \
 161         (HANDLE) = NULL; \
 162     } \
 163 } \
 164 while (0)
 165
 166 // --------------------------------------------------------------------------
 167 // Console CTRL+C handler
 168 // --------------------------------------------------------------------------
 169
 170 static volatile BOOL g_stop = FALSE;
 171
 172 static BOOL WINAPI console_handler(const DWORD ctrlType)
 173 {
 174     switch (ctrlType)
 175     {
 176     case CTRL_C_EVENT:
 177     case CTRL_BREAK_EVENT:
 178     case CTRL_CLOSE_EVENT:
 179         g_stop = TRUE;
 180         return TRUE;
 181     default:
 182         return FALSE;
 183     }
 184 }
 185
 186 // --------------------------------------------------------------------------
 187 // Text output
 188 // --------------------------------------------------------------------------
 189
 190 static char *utf16_to_utf8(const wchar_t *const input)
 191 {
 192     const int buff_size = WideCharToMultiByte(CP_UTF8, 0, input, -1, NULL, 0, NULL, NULL);
 193     if (buff_size > 0)
 194     {
 195         char *const buffer = (char*)LocalAlloc(LPTR, buff_size);
 196         if (buffer)
 197         {
 198             const int result = WideCharToMultiByte(CP_UTF8, 0, input, -1, buffer, buff_size, NULL, NULL);
 199             if ((result > 0) && (result <= buff_size))
 200             {
 201                 return buffer;
 202             }
 203             LocalFree(buffer);
 204         }
 205     }
 206
 207     return NULL;
 208 }
 209
 210 static BOOL write_text(const HANDLE handle, const wchar_t *const text)
 211 {
 212     BOOL result = FALSE;
 213     DWORD written;
 214
 215     if (GetConsoleMode(handle, &written))
 216     {
 217         result = WriteConsoleW(handle, text, lstrlenW(text), &written, NULL);
 218     }
 219     else
 220     {
 221         char *const utf8_text = utf16_to_utf8(text);
 222         if (utf8_text)
 223         {
 224             result = WriteFile(handle, utf8_text, lstrlenA(utf8_text), &written, NULL);
 225             LocalFree(utf8_text);
 226         }
 227     }
 228
 229     return result;
 230 }
 231
 232 #define WRITE_TEXT(...) do \
 233 { \
 234     wchar_t* const _message = CONCAT(__VA_ARGS__); \
 235     if (_message) \
 236     { \
 237         write_text(hStdErr, _message); \
 238         LocalFree(_message); \
 239     } \
 240 } \
 241 while (0)
 242
 243 // --------------------------------------------------------------------------
 244 // Writer thread
 245 // --------------------------------------------------------------------------
 246
 247 #define INCREMENT_INDEX(INDEX, FLAG) do { if (++(INDEX) >= BUFFERS) { (INDEX) = 0U; (FLAG) = (!(FLAG)); } } while (0)
 248
 249 typedef struct _thread
 250 {
 251     HANDLE hOutput, hError;
 252     BOOL flush;
 253 }
 254 thread_t;
 255
 256 static BYTE g_buffer[BUFFERS][BUFFER_SIZE];
 257 static DWORD g_bytesTotal[BUFFERS] = { 0U, 0U, 0U };
 258 static volatile LONG g_pending[BUFFERS] = { 0L, 0L, 0L };
 259 static SRWLOCK g_rwLocks[BUFFERS];
 260 static CONDITION_VARIABLE g_condIsReady[BUFFERS], g_condAllDone[BUFFERS];
 261
 262 static DWORD WINAPI writer_thread_start_routine(const LPVOID lpThreadParameter)
 263 {
 264     DWORD bytesWritten = 0U, myIndex = 0U;
 265     LONG pending = 0L;
 266     BOOL myFlag = TRUE, writeErrors = FALSE;
 267     const thread_t *const param = (const thread_t*)lpThreadParameter;
 268
 269     for (;;)
 270     {
 271         ASSERT(myIndex < BUFFERS, param->hError, L"Current buffer index is out of range!");
 272
 273         AcquireSRWLockShared(&g_rwLocks[myIndex]);
 274
 275         pending = g_pending[myIndex];
 276
 277         while (!(myFlag ? (pending > 0L) : (pending < 0L)))
 278         {
 279             if (!SleepConditionVariableSRW(&g_condIsReady[myIndex], &g_rwLocks[myIndex], INFINITE, CONDITION_VARIABLE_LOCKMODE_SHARED))
 280             {
 281                 ReleaseSRWLockShared(&g_rwLocks[myIndex]);
 282                 write_text(param->hError, L"[tee] Operating system error: SleepConditionVariableSRW() has failed!\n");
 283                 TerminateProcess(GetCurrentProcess(), 1U);
 284             }
 285             pending = g_pending[myIndex];
 286         }
 287
 288         const DWORD bytesTotal = g_bytesTotal[myIndex];
 289         if (bytesTotal == MAXDWORD)
 290         {
 291             ReleaseSRWLockShared(&g_rwLocks[myIndex]);
 292             if (writeErrors)
 293             {
 294                 write_text(param->hError, L"[tee] I/O error: Not all data could be written!\n");
 295             }
 296             return 0U;
 297         }
 298
 299         for (DWORD offset = 0U; offset < bytesTotal; offset += bytesWritten)
 300         {
 301             const BOOL result = WriteFile(param->hOutput, g_buffer[myIndex] + offset, g_bytesTotal[myIndex] - offset, &bytesWritten, NULL);
 302             if ((!result) || (!bytesWritten))
 303             {
 304                 writeErrors = TRUE;
 305                 break;
 306             }
 307         }
 308
 309         ASSERT(g_pending > 0U, param->hError, L"Pending threads counter must be a positive value!");
 310
 311         pending = myFlag ? _InterlockedDecrement(&g_pending[myIndex]) : _InterlockedIncrement(&g_pending[myIndex]);
 312
 313         ReleaseSRWLockShared(&g_rwLocks[myIndex]);
 314
 315         if (!pending)
 316         {
 317             WakeConditionVariable(&g_condAllDone[myIndex]);
 318         }
 319
 320         INCREMENT_INDEX(myIndex, myFlag);
 321
 322         if (param->flush)
 323         {
 324             FlushFileBuffers(param->hOutput);
 325         }
 326     }
 327 }
 328
 329 // --------------------------------------------------------------------------
 330 // Options
 331 // --------------------------------------------------------------------------
 332
 333 typedef struct
 334 {
 335     BOOL append, delay, flush, help, ignore, version;
 336 }
 337 options_t;
 338
 339 #define PARSE_OPTION(SHRT, NAME) do \
 340 { \
 341     if ((lc == L##SHRT) || (name && (lstrcmpiW(name, L#NAME) == 0))) \
 342     { \
 343         options->NAME = TRUE; \
 344         return TRUE; \
 345     } \
 346 } \
 347 while (0)
 348
 349 static BOOL parse_option(options_t *const options, const wchar_t c, const wchar_t *const name)
 350 {
 351     const wchar_t lc = to_lower(c);
 352
 353     PARSE_OPTION('a', append);
 354     PARSE_OPTION('d', delay);
 355     PARSE_OPTION('f', flush);
 356     PARSE_OPTION('h', help);
 357     PARSE_OPTION('i', ignore);
 358     PARSE_OPTION('v', version);
 359
 360     return FALSE;
 361 }
 362
 363 static BOOL parse_argument(options_t *const options, const wchar_t *const argument)
 364 {
 365     if ((argument[0U] != L'-') || (argument[1U] == L'\0'))
 366     {
 367         return FALSE;
 368     }
 369
 370     if (argument[1U] == L'-')
 371     {
 372         return (argument[2U] != L'\0') && parse_option(options, L'\0', argument + 2U);
 373     }
 374     else
 375     {
 376         for (const wchar_t* ptr = argument + 1U; *ptr != L'\0'; ++ptr)
 377         {
 378             if (!parse_option(options, *ptr, NULL))
 379             {
 380                 return FALSE;
 381             }
 382         }
 383         return TRUE;
 384     }
 385 }
 386
 387 // --------------------------------------------------------------------------
 388 // MAIN
 389 // --------------------------------------------------------------------------
 390
 391 int wmain(const int argc, const wchar_t *const argv[])
 392 {
 393     HANDLE hThreads[MAX_THREADS], hMyFiles[MAX_THREADS - 1U];
 394     int exitCode = 1, argOff = 1;
 395     BOOL myFlag = TRUE;
 396     DWORD fileCount = 0U, threadCount = 0U, myIndex = 0U;
 397     options_t options;
 398     static thread_t threadData[MAX_THREADS];
 399
 400     /* Initialize local variables */
 401     FILL_ARRAY(hMyFiles, INVALID_HANDLE_VALUE);
 402     FILL_ARRAY(hThreads, NULL);
 403     SecureZeroMemory(&options, sizeof(options));
 404     SecureZeroMemory(&threadData, sizeof(threadData));
 405
 406     /* Initialize standard streams */
 407     const HANDLE hStdIn = GetStdHandle(STD_INPUT_HANDLE), hStdOut = GetStdHandle(STD_OUTPUT_HANDLE), hStdErr = GetStdHandle(STD_ERROR_HANDLE);
 408     if (!(VALID_HANDLE(hStdIn) && VALID_HANDLE(hStdOut) && VALID_HANDLE(hStdErr)))
 409     {
 410         if (VALID_HANDLE(hStdErr))
 411         {
 412             write_text(hStdErr, L"[tee] Operating system error: GetStdHandle() has failed!\n");
 413         }
 414         return -1;
 415     }
 416
 417     /* Initialize read/write locks and condition variables */
 418     for (DWORD index = 0; index < BUFFERS; ++index)
 419     {
 420         InitializeSRWLock(&g_rwLocks[index]);
 421         InitializeConditionVariable(&g_condIsReady[index]);
 422         InitializeConditionVariable(&g_condAllDone[index]);
 423     }
 424
 425     /* Set up CRTL+C handler */
 426     SetConsoleCtrlHandler(console_handler, TRUE);
 427
 428     /* Parse command-line options */
 429     while ((argOff < argc) && (argv[argOff][0U] == L'-') && (argv[argOff][1U] != L'\0'))
 430     {
 431         const wchar_t *const argValue= argv[argOff++];
 432         if ((argValue[1U] == L'-') && (argValue[2U] == L'\0'))
 433         {
 434             break; /*stop!*/
 435         }
 436         else if (!parse_argument(&options, argValue))
 437         {
 438             WRITE_TEXT(L"[tee] Error: Invalid option \"", argValue, L"\" encountered!\n");
 439             return 1;
 440         }
 441     }
 442
 443     /* Print manual page */
 444     if (options.help || options.version)
 445     {
 446         wchar_t *const versionString = format_string(L"tee for Windows v%1!u!.%2!u!.%3!u! [%4!s!] [%5!s!]\n", APP_VERSION_MAJOR, APP_VERSION_MINOR, APP_VERSION_PATCH, PROCESSOR_ARCHITECTURE, TEXT(__DATE__));
 447         write_text(hStdErr, versionString ? versionString : L"tee for Windows\n");
 448         if (options.help)
 449         {
 450             write_text(hStdErr, L"\n"
 451                 L"Copy standard input to output file(s), and also to standard output.\n\n"
 452                 L"Usage:\n"
 453                 L"  gizmo.exe [...] | tee.exe [options] <file_1> ... <file_n>\n\n"
 454                 L"Options:\n"
 455                 L"  -a --append  Append to the existing file, instead of truncating\n"
 456                 L"  -f --flush   Flush output file after each write operation\n"
 457                 L"  -i --ignore  Ignore the interrupt signal (SIGINT), e.g. CTRL+C\n"
 458                 L"  -d --delay   Add a small delay after each read operation\n\n");
 459         }
 460         if (versionString)
 461         {
 462             LocalFree(versionString);
 463         }
 464         return 0;
 465     }
 466
 467     /* Check output file name */
 468     if (argOff >= argc)
 469     {
 470         write_text(hStdErr, L"[tee] Error: Output file name is missing. Type \"tee --help\" for details!\n");
 471         return 1;
 472     }
 473
 474     /* Determine input type */
 475     const DWORD inputType = GetFileType(hStdIn);
 476     if (inputType == FILE_TYPE_UNKNOWN)
 477     {
 478         if (GetLastError() != NO_ERROR)
 479         {
 480             write_text(hStdErr, L"[tee] Operating system error: GetFileType(hStdIn) has failed!\n");
 481             return -1;
 482         }
 483     }
 484
 485     /* Validate output stream */
 486     if (GetFileType(hStdOut) == FILE_TYPE_UNKNOWN)
 487     {
 488         if (GetLastError() != NO_ERROR)
 489         {
 490             write_text(hStdErr, L"[tee] Operating system error: GetFileType(hStdOut) has failed!\n");
 491             return -1;
 492         }
 493     }
 494
 495     /* Open output file(s) */
 496     while ((argOff < argc) && (fileCount < ARRAYSIZE(hMyFiles)))
 497     {
 498         const wchar_t* const fileName = argv[argOff++];
 499         if (!is_null_device(fileName))
 500         {
 501             const HANDLE hFile = CreateFileW(fileName, GENERIC_WRITE, FILE_SHARE_READ, NULL, options.append ? OPEN_ALWAYS : CREATE_ALWAYS, 0U, NULL);
 502             if ((hMyFiles[fileCount++] = hFile) == INVALID_HANDLE_VALUE)
 503             {
 504                 WRITE_TEXT(L"[tee] Error: Failed to open the output file \"", fileName, L"\" for writing!\n");
 505                 goto cleanup;
 506             }
 507             else if (options.append)
 508             {
 509                 LARGE_INTEGER offset = { .QuadPart = 0LL };
 510                 if (!SetFilePointerEx(hFile, offset, NULL, FILE_END))
 511                 {
 512                     write_text(hStdErr, L"[tee] Error: Failed to move the file pointer to the end of the file!\n");
 513                     goto cleanup;
 514                 }
 515             }
 516         }
 517     }
 518
 519     /* Check output file name */
 520     if (argOff < argc)
 521     {
 522         write_text(hStdErr, L"[tee] Warning: Too many input files, ignoring excess files!\n");
 523     }
 524
 525     /* Determine number of outputs */
 526     const DWORD outputCount = fileCount + 1U;
 527
 528     /* Start threads */
 529     for (DWORD threadId = 0; threadId < outputCount; ++threadId)
 530     {
 531         threadData[threadId].hOutput = (threadId > 0U) ? hMyFiles[threadId - 1U] : hStdOut;
 532         threadData[threadId].hError = hStdErr;
 533         threadData[threadId].flush = options.flush && (!is_terminal(threadData[threadId].hOutput));
 534         if (!(hThreads[threadCount++] = CreateThread(NULL, 0U, writer_thread_start_routine, (LPVOID)&threadData[threadId], 0U, NULL)))
 535         {
 536             write_text(hStdErr, L"[tee] Operating system error: CreateThread() has failed!\n");
 537             goto cleanup;
 538         }
 539     }
 540
 541     /* Process all input from STDIN stream */
 542     do
 543     {
 544         ASSERT(myIndex < BUFFERS, hStdErr, L"Current buffer index is out of range!");
 545
 546         AcquireSRWLockExclusive(&g_rwLocks[myIndex]);
 547
 548         while (g_pending[myIndex])
 549         {
 550             if (!SleepConditionVariableSRW(&g_condAllDone[myIndex], &g_rwLocks[myIndex], INFINITE, 0U))
 551             {
 552                 ReleaseSRWLockExclusive(&g_rwLocks[myIndex]);
 553                 write_text(hStdErr, L"[tee] Operating system error: SleepConditionVariableSRW() has failed!\n");
 554                 TerminateProcess(GetCurrentProcess(), 1U);
 555             }
 556         }
 557
 558         if (!ReadFile(hStdIn, g_buffer[myIndex], BUFFER_SIZE, &g_bytesTotal[myIndex], NULL))
 559         {
 560             const DWORD error = GetLastError();
 561             ReleaseSRWLockExclusive(&g_rwLocks[myIndex]);
 562             if (error != ERROR_BROKEN_PIPE)
 563             {
 564                 write_text(hStdErr, L"[tee] I/O error: Failed to read input data!\n");
 565                 goto cleanup;
 566             }
 567             break;
 568         }
 569
 570         if (!g_bytesTotal[myIndex])
 571         {
 572             ReleaseSRWLockExclusive(&g_rwLocks[myIndex]);
 573             if (inputType == FILE_TYPE_PIPE)
 574             {
 575                 continue; /*pipes may return zero bytes, even when more data can become available later!*/
 576             }
 577             break;
 578         }
 579
 580         g_pending[myIndex] = myFlag ? POS_LONG(threadCount) : NEG_LONG(threadCount);
 581
 582         ReleaseSRWLockExclusive(&g_rwLocks[myIndex]);
 583         WakeAllConditionVariable(&g_condIsReady[myIndex]);
 584
 585         INCREMENT_INDEX(myIndex, myFlag);
 586
 587         if (options.delay)
 588         {
 589             Sleep(1U);
 590         }
 591     }
 592     while ((!g_stop) || options.ignore);
 593
 594     exitCode = 0;
 595
 596 cleanup:
 597
 598     /* Stop the worker threads */
 599     AcquireSRWLockExclusive(&g_rwLocks[myIndex]);
 600     g_bytesTotal[myIndex] = MAXDWORD;
 601     g_pending[myIndex] = myFlag ? MAXLONG : MINLONG;
 602     ReleaseSRWLockExclusive(&g_rwLocks[myIndex]);
 603     WakeAllConditionVariable(&g_condIsReady[myIndex]);
 604
 605     /* Wait for worker threads to exit */
 606     const DWORD pendingThreads = count_handles(hThreads, ARRAYSIZE(hThreads));
 607     if (pendingThreads > 0U)
 608     {
 609         const DWORD result = WaitForMultipleObjects(pendingThreads, hThreads, TRUE, 10000U);
 610         if (!((result >= WAIT_OBJECT_0) && (result < WAIT_OBJECT_0 + pendingThreads)))
 611         {
 612             for (DWORD threadId = 0U; threadId < pendingThreads; ++threadId)
 613             {
 614                 if (WaitForSingleObject(hThreads[threadId], 125U) != WAIT_OBJECT_0)
 615                 {
 616                     write_text(hStdErr, L"[tee] Internal error: Worker thread did not exit cleanly!\n");
 617                     TerminateThread(hThreads[threadId], 1U);
 618                 }
 619             }
 620         }
 621     }
 622
 623     /* Flush the output file */
 624     if (options.flush)
 625     {
 626         for (size_t fileIndex = 0U; fileIndex < ARRAYSIZE(hMyFiles); ++fileIndex)
 627         {
 628             if (hMyFiles[fileIndex] != INVALID_HANDLE_VALUE)
 629             {
 630                 FlushFileBuffers(hMyFiles[fileIndex]);
 631             }
 632         }
 633     }
 634
 635     /* Close worker threads */
 636     for (DWORD threadId = 0U; threadId < ARRAYSIZE(hThreads); ++threadId)
 637     {
 638         CLOSE_HANDLE(hThreads[threadId]);
 639     }
 640
 641     /* Close the output file(s) */
 642     for (size_t fileIndex = 0U; fileIndex < ARRAYSIZE(hMyFiles); ++fileIndex)
 643     {
 644         CLOSE_HANDLE(hMyFiles[fileIndex]);
 645     }
 646
 647     /* Exit */
 648     return exitCode;
 649 }
 650
 651 // --------------------------------------------------------------------------
 652 // CRT Startup
 653 // --------------------------------------------------------------------------
 654
 655 #ifndef _DEBUG
 656 #pragma warning(disable: 4702)
 657
 658 int _startup(void)
 659 {
 660     SetErrorMode(SEM_FAILCRITICALERRORS);
 661
 662     int nArgs;
 663     LPWSTR *const szArglist = CommandLineToArgvW(GetCommandLineW(), &nArgs);
 664     if (!szArglist)
 665     {
 666         OutputDebugStringA("[tee-win32] System error: Failed to initialize command-line arguments!\n");
 667         ExitProcess((UINT)-1);
 668     }
 669
 670     const int retval = wmain(nArgs, szArglist);
 671     LocalFree(szArglist);
 672     ExitProcess((UINT)retval);
 673
 674     return 0;
 675 }
 676
 677 #endif