fstester/setter/win32.c

/****************************************************************************
The Disc Image Chef
-----------------------------------------------------------------------------

Filename       : win32.c
Author(s)      : Natalia Portillo

Component      : fstester.setter.win32

--[ Description ] -----------------------------------------------------------

Contains 32-bit and 64-bit Windows code

--[ License ] ---------------------------------------------------------------
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as
     published by the Free Software Foundation, either version 3 of the
     License, or (at your option) any later version.

     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warraty of
     MERCHANTIBILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.

-----------------------------------------------------------------------------
Copyright (C) 2011-2018 Natalia Portillo
*****************************************************************************/

#if defined(__WINDOWS__) || defined(__TOS_WIN__) || defined(__WIN32__) || defined(_WIN64) || defined(_WIN32) ||        \
    defined(__NT__)

#include "win32.h"

#include "consts.h"
#include "defs.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>

void GetOsInfo()
{
    OSVERSIONINFO verInfo;
    BOOL          ret;
    DWORD         error;

    verInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    ret                         = GetVersionEx(&verInfo);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d querying Windows version.\n", error);
        return;
    }

    printf("OS information:\n");

    if(verInfo.dwPlatformId == VER_PLATFORM_WIN32s)
    { printf("\tRunning under Windows %d.%d using Win32s.\n", verInfo.dwMajorVersion, verInfo.dwMinorVersion); }
    else if(verInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
    {
        if(verInfo.dwMinorVersion == 10)
        {
            if(verInfo.dwBuildNumber == 2222) { printf("\tRunning under Windows 98 SE"); }
            else
            {
                printf("\tRunning under Windows 98");
            }
        }
        else if(verInfo.dwMinorVersion == 90)
        {
            printf("\tRunning under Windows Me");
        }
        else if(verInfo.dwMinorVersion < 10)
        {
            printf("\tRunning under Windows 95");
        }
        else
        {
            printf("\tRunning under Windows");
        }

        if(verInfo.dwBuildNumber > 0)
        {
            if(strlen(verInfo.szCSDVersion) > 0)
            {
                printf(" version %d.%02d.%d %s.\n",
                       verInfo.dwMajorVersion,
                       verInfo.dwMinorVersion,
                       verInfo.dwBuildNumber,
                       verInfo.szCSDVersion);
            }
            else
            {
                printf(" version %d.%02d.%d.\n", verInfo.dwMajorVersion, verInfo.dwMinorVersion, verInfo.dwBuildNumber);
            }
        }
        else
        {
            if(strlen(verInfo.szCSDVersion) > 0)
            {
                printf(" version %d.%02d %s.\n", verInfo.dwMajorVersion, verInfo.dwMinorVersion, verInfo.szCSDVersion);
            }
            else
            {
                printf(" version %d.%02d.\n", verInfo.dwMajorVersion, verInfo.dwMinorVersion);
            }
        }
    }
    else if(verInfo.dwPlatformId == VER_PLATFORM_WIN32_NT)
    {
        switch(verInfo.dwMajorVersion)
        {
            case 5:
                switch(verInfo.dwMinorVersion)
                {
                    case 0: printf("\tRunning under Windows 2000"); break;
                    case 1: printf("\tRunning under Windows XP"); break;
                    case 2: printf("\tRunning under Windows Server 2003"); break;
                    default: printf("\tRunning under Windows NT");
                }
                break;
            case 6:
                switch(verInfo.dwMinorVersion)
                {
                    case 0: printf("\tRunning under Windows Vista"); break;
                    case 1: printf("\tRunning under Windows 7"); break;
                    case 2: printf("\tRunning under Windows 8"); break;
                    case 3: printf("\tRunning under Windows 8.1"); break;
                    default: printf("\tRunning under Windows NT"); break;
                }
                break;
            case 10: printf("\tRunning under Windows 10"); break;
            default: printf("\tRunning under Windows NT"); break;
        }

        if(verInfo.dwMinorVersion < 10) { verInfo.dwMinorVersion = verInfo.dwMinorVersion * 10; }

        if(verInfo.dwBuildNumber > 0)
        {
            if(strlen(verInfo.szCSDVersion) > 0)
            {
                printf(" version %d.%02d.%d %s.\n",
                       verInfo.dwMajorVersion,
                       verInfo.dwMinorVersion,
                       verInfo.dwBuildNumber,
                       verInfo.szCSDVersion);
            }
            else
            {
                printf(" version %d.%02d.%d.\n", verInfo.dwMajorVersion, verInfo.dwMinorVersion, verInfo.dwBuildNumber);
            }
        }
        else
        {
            if(strlen(verInfo.szCSDVersion) > 0)
            {
                printf(" version %d.%02d %s.\n", verInfo.dwMajorVersion, verInfo.dwMinorVersion, verInfo.szCSDVersion);
            }
            else
            {
                printf(" version %d.%02d.\n", verInfo.dwMajorVersion, verInfo.dwMinorVersion);
            }
        }
    }
}

void GetVolumeInfo(const char *path, size_t *clusterSize)
{
    BOOL           ret;
    DWORD          error;
    LPTSTR         lpVolumeNameBuffer;
    DWORD          dwMaximumComponentLength;
    DWORD          dwFileSystemFlags;
    DWORD          dwMaxNameSize = MAX_PATH + 1;
    LPTSTR         lpFileSystemNameBuffer;
    LPTSTR         lpRootPathName;
    size_t         pathSize = strlen(path);
    DWORD          dwSectorsPerCluster;
    DWORD          dwBytesPerSector;
    DWORD          dwNumberOfFreeClusters;
    DWORD          dwTotalNumberOfClusters;
    OSVERSIONINFO  verInfo;
    ULARGE_INTEGER qwFreeBytesAvailableToCaller;
    ULARGE_INTEGER qwTotalNumberOfBytes;
    ULARGE_INTEGER qwTotalNumberOfFreeBytes;

    *clusterSize = 0;

    printf("Volume information:\n");
    printf("\tPath: %s\n", path);

    lpVolumeNameBuffer = malloc(dwMaxNameSize);

    if(lpVolumeNameBuffer == NULL)
    {
        printf("Could not allocate memory.\n");
        return;
    }

    lpFileSystemNameBuffer = malloc(dwMaxNameSize);

    if(lpFileSystemNameBuffer == NULL)
    {
        printf("Could not allocate memory.\n");
        free(lpVolumeNameBuffer);
        return;
    }

    lpRootPathName = malloc(dwMaxNameSize);

    if(lpRootPathName == NULL)
    {
        printf("Could not allocate memory.\n");
        free(lpVolumeNameBuffer);
        free(lpFileSystemNameBuffer);
        return;
    }

    memset(lpRootPathName, 0x00, MAX_PATH);
    strcpy(lpRootPathName, path);

    if(path[pathSize - 1] != '\\') { lpRootPathName[pathSize] = '\\'; }

    ret = GetVolumeInformation(lpRootPathName,
                               lpVolumeNameBuffer,
                               dwMaxNameSize,
                               NULL,
                               &dwMaximumComponentLength,
                               &dwFileSystemFlags,
                               lpFileSystemNameBuffer,
                               dwMaxNameSize);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d querying volume information.\n", error);
        free(lpVolumeNameBuffer);
        free(lpFileSystemNameBuffer);
        free(lpRootPathName);
        return;
    }

    printf("\tFilesystem: %s\n", lpFileSystemNameBuffer);
    printf("\tVolume name: %s\n", lpVolumeNameBuffer);
    printf("\tMaximum component size: %d\n", dwMaximumComponentLength);

    if(dwFileSystemFlags > 0)
    {
        printf("\tFlags:\n");

        if(dwFileSystemFlags & FILE_CASE_PRESERVED_NAMES)
        {
            printf("\t\tVolume preserves file name case.\n");
            dwFileSystemFlags -= FILE_CASE_PRESERVED_NAMES;
        }

        if(dwFileSystemFlags & FILE_CASE_SENSITIVE_SEARCH)
        {
            printf("\t\tVolume supports case sensitiveness.\n");
            dwFileSystemFlags -= FILE_CASE_SENSITIVE_SEARCH;
        }

        if(dwFileSystemFlags & FILE_DAX_VOLUME)
        {
            printf("\t\tDirect access volume.\n");
            dwFileSystemFlags -= FILE_DAX_VOLUME;
        }

        if(dwFileSystemFlags & FILE_FILE_COMPRESSION)
        {
            printf("\t\tVolume supports per-file compression.\n");
            dwFileSystemFlags -= FILE_FILE_COMPRESSION;
        }

        if(dwFileSystemFlags & FILE_NAMED_STREAMS)
        {
            printf("\t\tVolume supports Alternate Data Streams.\n");
            dwFileSystemFlags -= FILE_NAMED_STREAMS;
        }

        if(dwFileSystemFlags & FILE_PERSISTENT_ACLS)
        {
            printf("\t\tVolume supports persistent Access Control Lists.\n");
            dwFileSystemFlags -= FILE_PERSISTENT_ACLS;
        }

        if(dwFileSystemFlags & FILE_READ_ONLY_VOLUME)
        {
            printf("\t\tVolume is read-only.\n");
            dwFileSystemFlags -= FILE_READ_ONLY_VOLUME;
        }

        if(dwFileSystemFlags & FILE_SEQUENTIAL_WRITE_ONCE)
        {
            printf("\t\tVolume supports a single sequential write.\n");
            dwFileSystemFlags -= FILE_SEQUENTIAL_WRITE_ONCE;
        }

        if(dwFileSystemFlags & FILE_SUPPORTS_ENCRYPTION)
        {
            printf("\t\tVolume supports per-file encryption.\n");
            dwFileSystemFlags -= FILE_SUPPORTS_ENCRYPTION;
        }

        if(dwFileSystemFlags & FILE_SUPPORTS_EXTENDED_ATTRIBUTES)
        {
            printf("\t\tVolume supports extended attributes.\n");
            dwFileSystemFlags -= FILE_SUPPORTS_EXTENDED_ATTRIBUTES;
        }

        if(dwFileSystemFlags & FILE_SUPPORTS_HARD_LINKS)
        {
            printf("\t\tVolume supports hard links.\n");
            dwFileSystemFlags -= FILE_SUPPORTS_HARD_LINKS;
        }

        if(dwFileSystemFlags & FILE_SUPPORTS_OBJECT_IDS)
        {
            printf("\t\tVolume supports object IDs.\n");
            dwFileSystemFlags -= FILE_SUPPORTS_OBJECT_IDS;
        }

        if(dwFileSystemFlags & FILE_SUPPORTS_OPEN_BY_FILE_ID)
        {
            printf("\t\tVolume can open files by ID.\n");
            dwFileSystemFlags -= FILE_SUPPORTS_OPEN_BY_FILE_ID;
        }

        if(dwFileSystemFlags & FILE_SUPPORTS_REPARSE_POINTS)
        {
            printf("\t\tVolume supports reparse points.\n");
            dwFileSystemFlags -= FILE_SUPPORTS_REPARSE_POINTS;
        }

        if(dwFileSystemFlags & FILE_SUPPORTS_SPARSE_FILES)
        {
            printf("\t\tVolume supports sparse files.\n");
            dwFileSystemFlags -= FILE_SUPPORTS_SPARSE_FILES;
        }

        if(dwFileSystemFlags & FILE_SUPPORTS_TRANSACTIONS)
        {
            printf("\t\tVolume supports transactions.\n");
            dwFileSystemFlags -= FILE_SUPPORTS_TRANSACTIONS;
        }

        if(dwFileSystemFlags & FILE_SUPPORTS_USN_JOURNAL)
        {
            printf("\t\tVolume has an USN journal.\n");
            dwFileSystemFlags -= FILE_SUPPORTS_USN_JOURNAL;
        }

        if(dwFileSystemFlags & FILE_UNICODE_ON_DISK)
        {
            printf("\t\tVolume stores filenames as Unicode.\n");
            dwFileSystemFlags -= FILE_UNICODE_ON_DISK;
        }

        if(dwFileSystemFlags & FILE_VOLUME_IS_COMPRESSED)
        {
            printf("\t\tVolume is compressed.\n");
            dwFileSystemFlags -= FILE_VOLUME_IS_COMPRESSED;
        }

        if(dwFileSystemFlags & FILE_VOLUME_QUOTAS)
        {
            printf("\t\tVolume supports user quotas.\n");
            dwFileSystemFlags -= FILE_VOLUME_QUOTAS;
        }

        if(dwFileSystemFlags > 0) { printf("Unknown flags: 0x%08x.\n", dwFileSystemFlags); }
    }

    free(lpVolumeNameBuffer);
    free(lpFileSystemNameBuffer);

    ret = GetDiskFreeSpace(
        lpRootPathName, &dwSectorsPerCluster, &dwBytesPerSector, &dwNumberOfFreeClusters, &dwTotalNumberOfClusters);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d querying volume space.\n", error);
        free(lpRootPathName);
        return;
    }

    *clusterSize = dwSectorsPerCluster * dwBytesPerSector;
    printf("\tBytes per sector: %u\n", dwBytesPerSector);
    printf("\tSectors per cluster: %u (%u bytes)\n", dwSectorsPerCluster, *clusterSize);

    verInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    ret                         = GetVersionEx(&verInfo);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d querying Windows version.\n", error);
        free(lpRootPathName);
        return;
    }

    if((verInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS && verInfo.dwBuildNumber >= 1000) ||
       verInfo.dwPlatformId == VER_PLATFORM_WIN32_NT)
    {
        ret = GetDiskFreeSpaceEx(
            lpRootPathName, &qwFreeBytesAvailableToCaller, &qwTotalNumberOfBytes, &qwTotalNumberOfFreeBytes);

        if(!ret)
        {
            error = GetLastError();
            printf("Error %d querying extended volume space.\n", error);
            free(lpRootPathName);
            return;
        }

        printf("\tVolume size: %Lu bytes\n", qwTotalNumberOfBytes);
        printf("\tVolume free: %Lu bytes\n", qwTotalNumberOfFreeBytes);
    }
    else
    {
        qwTotalNumberOfBytes.QuadPart     = dwTotalNumberOfClusters;
        qwTotalNumberOfFreeBytes.QuadPart = dwNumberOfFreeClusters;
        qwTotalNumberOfBytes.QuadPart *= *clusterSize;
        qwTotalNumberOfFreeBytes.QuadPart *= *clusterSize;

        printf("\tClusters: %lu (%Lu bytes)\n", dwTotalNumberOfClusters, qwTotalNumberOfBytes);
        printf("\tFree clusters: %lu (%Lu bytes)\n", dwNumberOfFreeClusters, qwTotalNumberOfFreeBytes);
    }

    free(lpRootPathName);
}

void FileAttributes(const char *path)
{
    BOOL          ret;
    DWORD         error;
    LPTSTR        lpRootPathName;
    DWORD         dwMaxNameSize = MAX_PATH + 1;
    size_t        pathSize      = strlen(path);
    HANDLE        h;
    DWORD         dwNumberOfBytesWritten;
    DWORD         rc, wRc, cRc;
    OSVERSIONINFO verInfo;
    DWORD         defaultCompression = COMPRESSION_FORMAT_DEFAULT;

    lpRootPathName = malloc(dwMaxNameSize);

    if(lpRootPathName == NULL)
    {
        printf("Could not allocate memory.\n");
        return;
    }

    memset(lpRootPathName, 0x00, MAX_PATH);
    strcpy(lpRootPathName, path);

    if(path[pathSize - 1] != '\\') { lpRootPathName[pathSize] = '\\'; }

    ret = SetCurrentDirectory(lpRootPathName);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d changing to specified path.\n", error);
        return;
    }

    ret = CreateDirectory("ATTRS", NULL);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d creating working directory.\n", error);
        return;
    }

    ret = SetCurrentDirectory("ATTRS");

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d changing to working directory.\n", error);
        return;
    }

    verInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    ret                         = GetVersionEx(&verInfo);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d querying Windows version.\n", error);
        free(lpRootPathName);
        return;
    }

    printf("Creating attributes files.\n");

    h   = CreateFile("NONE", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)noAttributeText, strlen(noAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with no attributes: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "NONE", rc, wRc, cRc);

    h   = CreateFile("ARCHIVE", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_ARCHIVE, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with archived attribute: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "ARCHIVE", rc, wRc, cRc);

    h   = CreateFile("ENCRYPT", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_ENCRYPTED, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tEncrypted file: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "ENCRYPT", rc, wRc, cRc);

    h   = CreateFile("HIDDEN", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_HIDDEN, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)hiddenAttributeText, strlen(hiddenAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with hidden attribute: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "HIDDEN", rc, wRc, cRc);

    h   = CreateFile("OFFLINE", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_OFFLINE, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile is available offline: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "OFFLINE", rc, wRc, cRc);

    h   = CreateFile("READONLY", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_READONLY, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret =
            WriteFile(h, (LPCVOID)readonlyAttributeText, strlen(readonlyAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with read-only attribute: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "READONLY", rc, wRc, cRc);

    h   = CreateFile("SYSTEM", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_SYSTEM, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)systemAttributeText, strlen(systemAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with system attribute: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "SYSTEM", rc, wRc, cRc);

    h   = CreateFile("TEMPORAR", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_TEMPORARY, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(
            h, (LPCVOID)temporaryAttributeText, strlen(temporaryAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tTemporary file: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "TEMPORAR", rc, wRc, cRc);

    h   = CreateFile("EA",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_ENCRYPTED | FILE_ATTRIBUTE_ARCHIVE,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf(
        "\tEncrypted file with archived attribute: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "EA", rc, wRc, cRc);

    h   = CreateFile("HA",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_ARCHIVE,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)hiddenAttributeText, strlen(hiddenAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf(
        "\tFile with hidden and archived attribute: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "HA", rc, wRc, cRc);

    h   = CreateFile("OA",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_ARCHIVE,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with archived attribute is available offline: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "OA",
           rc,
           wRc,
           cRc);

    h   = CreateFile("RA",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_ARCHIVE,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)readonlyAttributeText, strlen(readonlyAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with read-only and archived attribute: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "RA",
           rc,
           wRc,
           cRc);

    h   = CreateFile("SA",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_ARCHIVE,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)systemAttributeText, strlen(systemAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf(
        "\tFile with system and archived attribute: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "SA", rc, wRc, cRc);

    h   = CreateFile("TA",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_TEMPORARY | FILE_ATTRIBUTE_ARCHIVE,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)temporaryAttributeText, strlen(temporaryAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf(
        "\tTemporary file with archived attribute: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "TA", rc, wRc, cRc);

    h   = CreateFile("HE",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_ENCRYPTED,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)hiddenAttributeText, strlen(hiddenAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tEncrypted file with hidden attribute: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "HE", rc, wRc, cRc);

    h   = CreateFile("OE",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_ENCRYPTED,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tEncrypted file is available offline: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "OE", rc, wRc, cRc);

    h   = CreateFile("RE",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_ENCRYPTED,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret =
            WriteFile(h, (LPCVOID)readonlyAttributeText, strlen(readonlyAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tEncrypted file with read-only attribute: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "REREADONLY",
           rc,
           wRc,
           cRc);

    h   = CreateFile("TE",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_TEMPORARY | FILE_ATTRIBUTE_ENCRYPTED,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(
            h, (LPCVOID)temporaryAttributeText, strlen(temporaryAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tEncrypted temporary file: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "TE", rc, wRc, cRc);

    h   = CreateFile("OH",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_HIDDEN,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)hiddenAttributeText, strlen(hiddenAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with hidden attribute that is available offline: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "OH",
           rc,
           wRc,
           cRc);

    h   = CreateFile("RH",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret =
            WriteFile(h, (LPCVOID)readonlyAttributeText, strlen(readonlyAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)hiddenAttributeText, strlen(hiddenAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with system and read-only attributes: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "RH",
           rc,
           wRc,
           cRc);

    h   = CreateFile("SH",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)systemAttributeText, strlen(systemAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)hiddenAttributeText, strlen(hiddenAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf(
        "\tFile with system and hidden attributes: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "SH", rc, wRc, cRc);

    h   = CreateFile("TH",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_TEMPORARY | FILE_ATTRIBUTE_HIDDEN,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(
            h, (LPCVOID)temporaryAttributeText, strlen(temporaryAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)hiddenAttributeText, strlen(hiddenAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tTemporary file with hidden attribute: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "TH", rc, wRc, cRc);

    h   = CreateFile("RO",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_OFFLINE,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret =
            WriteFile(h, (LPCVOID)readonlyAttributeText, strlen(readonlyAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with read-only attribute that is available offline: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "RO",
           rc,
           wRc,
           cRc);

    h   = CreateFile("SO",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_OFFLINE,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)systemAttributeText, strlen(systemAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with system attribute that is available offline: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "SO",
           rc,
           wRc,
           cRc);

    h   = CreateFile("TO",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_TEMPORARY | FILE_ATTRIBUTE_OFFLINE,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(
            h, (LPCVOID)temporaryAttributeText, strlen(temporaryAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf(
        "\tTemporary file that is available offline: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "TO", rc, wRc, cRc);

    h   = CreateFile("SR",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)systemAttributeText, strlen(systemAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)readonlyAttributeText, strlen(readonlyAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with system and read-only attributes: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "SR",
           rc,
           wRc,
           cRc);

    h   = CreateFile("TR",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_TEMPORARY | FILE_ATTRIBUTE_READONLY,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(
            h, (LPCVOID)temporaryAttributeText, strlen(temporaryAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)readonlyAttributeText, strlen(readonlyAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf(
        "\tTemporary file with read-only attribute: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "TR", rc, wRc, cRc);

    h   = CreateFile("ST",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_TEMPORARY,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)systemAttributeText, strlen(systemAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)temporaryAttributeText, strlen(temporaryAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tTemporary file with system attribute: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "ST", rc, wRc, cRc);

    h   = CreateFile("HAE",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_ENCRYPTED,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)hiddenAttributeText, strlen(hiddenAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tEncrypted file with hiden and archive attributes: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "HAE",
           rc,
           wRc,
           cRc);

    h   = CreateFile("OAE",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_ENCRYPTED,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tEncrypted file with archive attribute that is available offline: name = \"%s\", rc = %d, wRc = %d, cRc = "
           "%d\n",
           "OAE",
           rc,
           wRc,
           cRc);

    h   = CreateFile("RAE",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_ENCRYPTED,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret =
            WriteFile(h, (LPCVOID)readonlyAttributeText, strlen(readonlyAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tEncrypted file with archive and read-only attributes: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "RAE",
           rc,
           wRc,
           cRc);

    h   = CreateFile("TAE",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_TEMPORARY | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_ENCRYPTED,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(
            h, (LPCVOID)temporaryAttributeText, strlen(temporaryAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tEncrypted file with archive attribute that is available offline: name = \"%s\", rc = %d, wRc = %d, cRc = "
           "%d\n",
           "TAE",
           rc,
           wRc,
           cRc);

    h   = CreateFile("OAH",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_HIDDEN,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)hiddenAttributeText, strlen(hiddenAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with archive and hidden attributes that is available offline: name = \"%s\", rc = %d, wRc = %d, cRc "
           "= %d\n",
           "OAH",
           rc,
           wRc,
           cRc);

    h   = CreateFile("RAH",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_HIDDEN,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret =
            WriteFile(h, (LPCVOID)readonlyAttributeText, strlen(readonlyAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)hiddenAttributeText, strlen(hiddenAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with read-only, hidden and archive attributes: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "RAH",
           rc,
           wRc,
           cRc);

    h   = CreateFile("SAH",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_HIDDEN,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)systemAttributeText, strlen(systemAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)hiddenAttributeText, strlen(hiddenAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with system, archive and hidden attributes: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "SAH",
           rc,
           wRc,
           cRc);

    h   = CreateFile("TAH",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_TEMPORARY | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_HIDDEN,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(
            h, (LPCVOID)temporaryAttributeText, strlen(temporaryAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)hiddenAttributeText, strlen(hiddenAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tTemporary file with archive and hidden attributes: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "TAH",
           rc,
           wRc,
           cRc);

    h   = CreateFile("EAO",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_ENCRYPTED | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_OFFLINE,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)encryptedAttributeText, strlen(systemAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tEncrypted file with archive attribute that is available offline: name = \"%s\", rc = %d, wRc = %d, cRc = "
           "%d\n",
           "EAO",
           rc,
           wRc,
           cRc);

    h   = CreateFile("RAO",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_OFFLINE,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret =
            WriteFile(h, (LPCVOID)readonlyAttributeText, strlen(readonlyAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with read-only and archive attributes that is available offline: name = \"%s\", rc = %d, wRc = %d, "
           "cRc = %d\n",
           "RAO",
           rc,
           wRc,
           cRc);

    h   = CreateFile("SAO",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_OFFLINE,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)systemAttributeText, strlen(systemAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with system and archive attributes that is available offline: name = \"%s\", rc = %d, wRc = %d, cRc "
           "= %d\n",
           "SAO",
           rc,
           wRc,
           cRc);

    h   = CreateFile("TAO",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_TEMPORARY | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_OFFLINE,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(
            h, (LPCVOID)temporaryAttributeText, strlen(temporaryAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tTemporary file with archive attribute that is available offline: name = \"%s\", rc = %d, wRc = %d, cRc = "
           "%d\n",
           "TAO",
           rc,
           wRc,
           cRc);

    h   = CreateFile("EAR",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_ENCRYPTED | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_READONLY,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)readonlyAttributeText, strlen(readonlyAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tEncrypted file with archive and read-only attributes: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "EAR",
           rc,
           wRc,
           cRc);

    h   = CreateFile("OAR",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_READONLY,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)readonlyAttributeText, strlen(readonlyAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with read-only and archive attributes that is available offline: name = \"%s\", rc = %d, wRc = %d, "
           "cRc = %d\n",
           "OAR",
           rc,
           wRc,
           cRc);

    h   = CreateFile("TAR",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_TEMPORARY | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_READONLY,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(
            h, (LPCVOID)temporaryAttributeText, strlen(temporaryAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)readonlyAttributeText, strlen(readonlyAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tTemporary file with archive and read-only attributes: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "TAR",
           rc,
           wRc,
           cRc);

    h   = CreateFile("TAS",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_TEMPORARY | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_SYSTEM,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(
            h, (LPCVOID)temporaryAttributeText, strlen(temporaryAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)systemAttributeText, strlen(systemAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tTemporary file with archive and system attributes: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "TAS",
           rc,
           wRc,
           cRc);

    h   = CreateFile("OAEH",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_ENCRYPTED | FILE_ATTRIBUTE_HIDDEN,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)hiddenAttributeText, strlen(hiddenAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tEncrypted file with archive and hidden attributes that is available offline: name = \"%s\", rc = %d, wRc "
           "= %d, cRc = %d\n",
           "OAEH",
           rc,
           wRc,
           cRc);

    h   = CreateFile("RAEH",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_ENCRYPTED | FILE_ATTRIBUTE_HIDDEN,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret =
            WriteFile(h, (LPCVOID)readonlyAttributeText, strlen(readonlyAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)hiddenAttributeText, strlen(hiddenAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf(
        "\tEncrypted file with read-only, archive and hidden attributes: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
        "RAEH",
        rc,
        wRc,
        cRc);

    h   = CreateFile("TAEH",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_TEMPORARY | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_ENCRYPTED | FILE_ATTRIBUTE_HIDDEN,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(
            h, (LPCVOID)temporaryAttributeText, strlen(temporaryAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)hiddenAttributeText, strlen(hiddenAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf(
        "\tEncrypted temporary file with hidden and archive attributes: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
        "TAEH",
        rc,
        wRc,
        cRc);

    h   = CreateFile("RAEO",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_ENCRYPTED | FILE_ATTRIBUTE_OFFLINE,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret =
            WriteFile(h, (LPCVOID)readonlyAttributeText, strlen(readonlyAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tEncrypted file with read-only and archive attributes that is available offline: name = \"%s\", rc = %d, "
           "wRc = %d, cRc = %d\n",
           "RAEO",
           rc,
           wRc,
           cRc);

    h   = CreateFile("TAEO",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_TEMPORARY | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_ENCRYPTED |
                       FILE_ATTRIBUTE_OFFLINE,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(
            h, (LPCVOID)temporaryAttributeText, strlen(temporaryAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tEncrypted temporary file with archive attribute that is available offline: name = \"%s\", rc = %d, wRc = "
           "%d, cRc = %d\n",
           "TAEO",
           rc,
           wRc,
           cRc);

    h   = CreateFile("TAER",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_TEMPORARY | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_ENCRYPTED |
                       FILE_ATTRIBUTE_READONLY,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(
            h, (LPCVOID)temporaryAttributeText, strlen(temporaryAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)readonlyAttributeText, strlen(readonlyAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tEncrypted temporary file with archive and read-only attributes: name = \"%s\", rc = %d, wRc = %d, cRc = "
           "%d\n",
           "TAER",
           rc,
           wRc,
           cRc);

    h   = CreateFile("RAEH",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_ENCRYPTED | FILE_ATTRIBUTE_HIDDEN |
                       FILE_ATTRIBUTE_OFFLINE,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret =
            WriteFile(h, (LPCVOID)readonlyAttributeText, strlen(readonlyAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)hiddenAttributeText, strlen(hiddenAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf(
        "\tEncrypted file with read-only, archive and hidden attributes: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
        "RAEH",
        rc,
        wRc,
        cRc);

    h   = CreateFile("TAEH",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_TEMPORARY | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_ENCRYPTED |
                       FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_OFFLINE,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(
            h, (LPCVOID)temporaryAttributeText, strlen(temporaryAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)encryptedAttributeText, strlen(encryptedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)hiddenAttributeText, strlen(hiddenAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf(
        "\tEncrypted temporary file with archive and hidden attributes: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
        "TAEH",
        rc,
        wRc,
        cRc);

    h   = CreateFile("AHORST",
                   GENERIC_READ | GENERIC_WRITE,
                   0,
                   NULL,
                   CREATE_ALWAYS,
                   FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_READONLY |
                       FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_TEMPORARY,
                   NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret =
            WriteFile(h, (LPCVOID)archivedAttributeText, strlen(archivedAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)hiddenAttributeText, strlen(hiddenAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)offlineAttributeText, strlen(offlineAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret =
            WriteFile(h, (LPCVOID)readonlyAttributeText, strlen(readonlyAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(h, (LPCVOID)systemAttributeText, strlen(systemAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }
        ret = WriteFile(
            h, (LPCVOID)temporaryAttributeText, strlen(temporaryAttributeText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with all attributes: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "AHORST", rc, wRc, cRc);

    if(verInfo.dwPlatformId == VER_PLATFORM_WIN32_NT)
    {
        h   = CreateFile("COMPRESS", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        rc  = 0;
        wRc = 0;
        cRc = 0;
        if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
        else
        {
            ret = WriteFile(
                h, (LPCVOID)compressedAttributeText, strlen(compressedAttributeText), &dwNumberOfBytesWritten, NULL);
            if(!ret) { wRc = GetLastError(); }

            ret = DeviceIoControl(
                h, FSCTL_SET_COMPRESSION, &defaultCompression, sizeof(DWORD), NULL, 0, &dwNumberOfBytesWritten, NULL);

            if(!ret) { rc = GetLastError(); }

            ret = CloseHandle(h);
            if(!ret) { cRc = GetLastError(); }
        }
        printf("\tFile is compressed: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "COMPRESS", rc, wRc, cRc);
    }
}

void FilePermissions(const char *path) { /* Do nothing, not supported by target operating system */ }

// TODO: It is not working properly
void ExtendedAttributes(const char *path)
{
    /*
        BOOL ret;
        DWORD error;
        OSVERSIONINFO verInfo;
        HINSTANCE ntdll;
        void *func;
        DWORD dwNumberOfBytesWritten;
        DWORD rc, wRc, cRc;
        char   message[300];
        IO_STATUS_BLOCK eaStatus;
        HANDLE h;
        LPTSTR lpRootPathName;
        DWORD dwMaxNameSize = MAX_PATH + 1;
        size_t pathSize = strlen(path);
        PVOID eaData;

        verInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
        ret = GetVersionEx(&verInfo);

        if(!ret)
        {
            error = GetLastError();
            printf("Error %d querying Windows version.\n", error);
            return;
        }

        if(verInfo.dwPlatformId != VER_PLATFORM_WIN32_NT)
        {
            // Not supported on Windows 9x
            return;
        }

        lpRootPathName = malloc(dwMaxNameSize);

        if(lpRootPathName == NULL)
        {
            printf("Could not allocate memory.\n");
            return;
        }

        memset(lpRootPathName, 0x00, MAX_PATH);
        strcpy(lpRootPathName, path);

        if(path[pathSize - 1] != '\\')
        {
            lpRootPathName[pathSize] = '\\';
        }

        ret = SetCurrentDirectory(lpRootPathName);

        if(!ret)
        {
            error = GetLastError();
            printf("Error %d changing to specified path.\n", error);
            return;
        }

        ret = CreateDirectory("XATTRS", NULL);

        if(!ret)
        {
            error = GetLastError();
            printf("Error %d creating working directory.\n", error);
            return;
        }

        ret = SetCurrentDirectory("XATTRS");

        if(!ret)
        {
            error = GetLastError();
            printf("Error %d changing to working directory.\n", error);
            return;
        }

        ntdll = LoadLibrary("ntdll.dll");

        if(ntdll == NULL)
        {
            error = GetLastError();
            printf("Error %d loading NTDLL.DLL.\n", error);
            return;
        }

        func = GetProcAddress(ntdll, "NtSetEaFile");

        if(func == NULL)
        {
            error = GetLastError();
            printf("Error %d finding NtSetEaFile.\n", error);
            return;
        }

        NtSetEaFile = func;

        printf("Creating files with extended attributes.\n");

        h = CreateFile("COMMENTS", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, CREATE_ALWAYS,
       FILE_ATTRIBUTE_NORMAL, NULL); rc = 0; wRc = 0; cRc = 0; if(h == INVALID_HANDLE_VALUE)
        {
            rc = GetLastError();
        }
        else
        {
            memset(&message, 0, 300);
            sprintf(&message, "This files has an optional .COMMENTS EA\n");
            ret = WriteFile(h, &message, strlen(message), &dwNumberOfBytesWritten, NULL);
            if(!ret)
            {
                wRc = GetLastError();
            }

            eaData = malloc(sizeof(CommentsEA));
            memcpy(eaData, &CommentsEA, sizeof(CommentsEA));

            rc = NtSetEaFile(h, &eaStatus, eaData, sizeof(CommentsEA));
            ret = CloseHandle(h);
            if(!ret)
            {
                cRc = GetLastError();
            }
            free(eaData);
        }

        printf("\tFile with comments = \"%s\", rc = 0x%08x, wRc = %d, cRc = %d\n", "COMMENTS", rc, wRc, cRc);

        h = CreateFile("COMMENTS.CRT", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
       CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); rc = 0; wRc = 0; cRc = 0; if(h == INVALID_HANDLE_VALUE)
        {
            rc = GetLastError();
        }
        else
        {
            memset(&message, 0, 300);
            sprintf(&message, "This files has a critical .COMMENTS EA\n");
            ret = WriteFile(h, &message, strlen(message), &dwNumberOfBytesWritten, NULL);
            if(!ret)
            {
                wRc = GetLastError();
            }

            eaData = malloc(sizeof(CommentsEACritical));
            memcpy(eaData, &CommentsEACritical, sizeof(CommentsEACritical));

            rc = NtSetEaFile(h, &eaStatus, eaData, sizeof(CommentsEACritical));
            ret = CloseHandle(h);
            if(!ret)
            {
                cRc = GetLastError();
            }
            free(eaData);
        }

        printf("\tFile with comments = \"%s\", rc = 0x%08x, wRc = %d, cRc = %d\n", "COMMENTS.CRT", rc, wRc, cRc);

            h = CreateFile("ICON", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, CREATE_ALWAYS,
       FILE_ATTRIBUTE_NORMAL, NULL); rc = 0; wRc = 0; cRc = 0; if(h == INVALID_HANDLE_VALUE)
        {
            rc = GetLastError();
        }
        else
        {
            memset(&message, 0, 300);
            sprintf(&message, "This files has an optional .ICON EA\n");
            ret = WriteFile(h, &message, strlen(message), &dwNumberOfBytesWritten, NULL);
            if(!ret)
            {
                wRc = GetLastError();
            }

            eaData = malloc(sizeof(IconEA));
            memcpy(eaData, &IconEA, sizeof(IconEA));

            rc = NtSetEaFile(h, &eaStatus, eaData, sizeof(IconEA));
            ret = CloseHandle(h);
            if(!ret)
            {
                cRc = GetLastError();
            }
            free(eaData);
        }

        printf("\tFile with icon = \"%s\", rc = 0x%08x, wRc = %d, cRc = %d\n", "ICON", rc, wRc, cRc);

        FreeLibrary(ntdll);
    */
}

void ResourceFork(const char *path)
{
    BOOL          ret;
    DWORD         error;
    LPTSTR        lpRootPathName;
    DWORD         dwMaxNameSize = MAX_PATH + 1;
    size_t        pathSize      = strlen(path);
    HANDLE        h;
    DWORD         dwNumberOfBytesWritten;
    DWORD         rc, wRc, cRc;
    OSVERSIONINFO verInfo;
    int           maxLoop, i;

    verInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    ret                         = GetVersionEx(&verInfo);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d querying Windows version.\n", error);
        return;
    }

    if(verInfo.dwPlatformId != VER_PLATFORM_WIN32_NT)
    {
        // Not supported on Windows 9x
        return;
    }

    lpRootPathName = malloc(dwMaxNameSize);

    if(lpRootPathName == NULL)
    {
        printf("Could not allocate memory.\n");
        return;
    }

    memset(lpRootPathName, 0x00, MAX_PATH);
    strcpy(lpRootPathName, path);

    if(path[pathSize - 1] != '\\') { lpRootPathName[pathSize] = '\\'; }

    ret = SetCurrentDirectory(lpRootPathName);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d changing to specified path.\n", error);
        return;
    }

    ret = CreateDirectory("ADS", NULL);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d creating working directory.\n", error);
        return;
    }

    ret = SetCurrentDirectory("ADS");

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d changing to working directory.\n", error);
        return;
    }

    printf("Creating alternate data streams.\n");

    h   = CreateFile("TINY:ADS", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)tinyAdsText, strlen(tinyAdsText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with tiny alternate data stream: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "TINY:ADS",
           rc,
           wRc,
           cRc);

    maxLoop = (4095 - strlen(smallAdsText)) / strlen(smallAdsRepeatText);
    h   = CreateFile("SMALL:ADS", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)smallAdsText, strlen(smallAdsText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        for(i = 0; i < maxLoop; i++)
        {
            ret = WriteFile(h, (LPCVOID)smallAdsRepeatText, strlen(smallAdsRepeatText), &dwNumberOfBytesWritten, NULL);
            if(!ret)
            {
                wRc = GetLastError();
                break;
            }
        }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with small alternate data stream: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "SMALL:ADS",
           rc,
           wRc,
           cRc);

    maxLoop = (65535 - strlen(mediumAdsText)) / strlen(mediumAdsRepeatText);
    h   = CreateFile("MEDIUM:ADS", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)mediumAdsText, strlen(mediumAdsText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        for(i = 0; i < maxLoop; i++)
        {
            ret =
                WriteFile(h, (LPCVOID)mediumAdsRepeatText, strlen(mediumAdsRepeatText), &dwNumberOfBytesWritten, NULL);
            if(!ret)
            {
                wRc = GetLastError();
                break;
            }
        }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with medium alternate data stream: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "MEDIUM:ADS",
           rc,
           wRc,
           cRc);

    maxLoop = (67584 - strlen(bigAdsText)) / strlen(bigAdsRepeatText);
    h       = CreateFile("BIG:ADS", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc      = 0;
    wRc     = 0;
    cRc     = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)bigAdsText, strlen(bigAdsText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        for(i = 0; i < maxLoop; i++)
        {
            ret = WriteFile(h, (LPCVOID)bigAdsRepeatText, strlen(bigAdsRepeatText), &dwNumberOfBytesWritten, NULL);
            if(!ret)
            {
                wRc = GetLastError();
                break;
            }
        }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf(
        "\tFile with big alternate data stream: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", "BIG:ADS", rc, wRc, cRc);

    h   = CreateFile("MULTIPLE:ADS", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)tinyAdsText, strlen(tinyAdsText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with tiny alternate data stream: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "MULTIPLE:ADS",
           rc,
           wRc,
           cRc);

    maxLoop = (4095 - strlen(smallAdsText)) / strlen(smallAdsRepeatText);
    h   = CreateFile("MULTIPLE:ADS", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)smallAdsText, strlen(smallAdsText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        for(i = 0; i < maxLoop; i++)
        {
            ret = WriteFile(h, (LPCVOID)smallAdsRepeatText, strlen(smallAdsRepeatText), &dwNumberOfBytesWritten, NULL);
            if(!ret)
            {
                wRc = GetLastError();
                break;
            }
        }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with small alternate data stream: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "MULTIPLE:ADS",
           rc,
           wRc,
           cRc);

    maxLoop = (65535 - strlen(mediumAdsText)) / strlen(mediumAdsRepeatText);
    h   = CreateFile("MULTIPLE:ADS", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)mediumAdsText, strlen(mediumAdsText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        for(i = 0; i < maxLoop; i++)
        {
            ret =
                WriteFile(h, (LPCVOID)mediumAdsRepeatText, strlen(mediumAdsRepeatText), &dwNumberOfBytesWritten, NULL);
            if(!ret)
            {
                wRc = GetLastError();
                break;
            }
        }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with medium alternate data stream: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "MULTIPLE:ADS",
           rc,
           wRc,
           cRc);

    maxLoop = (67584 - strlen(bigAdsText)) / strlen(bigAdsRepeatText);
    h   = CreateFile("MULTIPLE:ADS", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        ret = WriteFile(h, (LPCVOID)bigAdsText, strlen(bigAdsText), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        for(i = 0; i < maxLoop; i++)
        {
            ret = WriteFile(h, (LPCVOID)bigAdsRepeatText, strlen(bigAdsRepeatText), &dwNumberOfBytesWritten, NULL);
            if(!ret)
            {
                wRc = GetLastError();
                break;
            }
        }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile with medium alternate data stream: name = \"%s\", rc = %d, wRc = %d, cRc = %d\n",
           "MULTIPLE:ADS",
           rc,
           wRc,
           cRc);
}

void Filenames(const char *path)
{
    BOOL   ret;
    DWORD  error;
    LPTSTR lpRootPathName;
    DWORD  dwMaxNameSize = MAX_PATH + 1;
    size_t pathSize      = strlen(path);
    HANDLE h;
    DWORD  dwNumberOfBytesWritten;
    DWORD  rc, wRc, cRc;
    char   message[300];
    int    pos = 0;

    lpRootPathName = malloc(dwMaxNameSize);

    if(lpRootPathName == NULL)
    {
        printf("Could not allocate memory.\n");
        return;
    }

    memset(lpRootPathName, 0x00, MAX_PATH);
    strcpy(lpRootPathName, path);

    if(path[pathSize - 1] != '\\') { lpRootPathName[pathSize] = '\\'; }

    ret = SetCurrentDirectory(lpRootPathName);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d changing to specified path.\n", error);
        return;
    }

    ret = CreateDirectory("FILENAME", NULL);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d creating working directory.\n", error);
        return;
    }

    ret = SetCurrentDirectory("FILENAME");

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d changing to working directory.\n", error);
        return;
    }

    printf("Creating files with different filenames.\n");

    for(pos = 0; filenames[pos]; pos++)
    {
        h = CreateFile(
            filenames[pos], GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        rc  = 0;
        wRc = 0;
        cRc = 0;

        if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
        else
        {
            memset(&message, 0, 300);
            sprintf(&message, FILENAME_FORMAT, filenames[pos]);

            ret = WriteFile(h, &message, strlen(message), &dwNumberOfBytesWritten, NULL);
            if(!ret) { wRc = GetLastError(); }

            ret = CloseHandle(h);
            if(!ret) { cRc = GetLastError(); }
        }

        printf("\tFile name = \"%s\", rc = %d, wRc = %d, cRc = %d\n", filenames[pos], rc, wRc, cRc);
    }
}

void Timestamps(const char *path)
{
    char     message[300];
    BOOL     ret;
    DWORD    error;
    LPTSTR   lpRootPathName;
    DWORD    dwMaxNameSize = MAX_PATH + 1;
    size_t   pathSize      = strlen(path);
    FILETIME ftCreationTime;
    FILETIME ftLastAccessTime;
    FILETIME ftLastWriteTime;
    HANDLE   h;
    DWORD    rc, wRc, cRc, tRc;
    DWORD    dwNumberOfBytesWritten;

    lpRootPathName = malloc(dwMaxNameSize);

    if(lpRootPathName == NULL)
    {
        printf("Could not allocate memory.\n");
        return;
    }

    memset(lpRootPathName, 0x00, MAX_PATH);
    strcpy(lpRootPathName, path);

    if(path[pathSize - 1] != '\\') { lpRootPathName[pathSize] = '\\'; }

    ret = SetCurrentDirectory(lpRootPathName);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d changing to specified path.\n", error);
        return;
    }

    ret = CreateDirectory("TIMES", NULL);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d creating working directory.\n", error);
        return;
    }

    ret = SetCurrentDirectory("TIMES");

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d changing to working directory.\n", error);
        return;
    }

    printf("Creating timestamped files.\n");

    h   = CreateFile("MAXCTIME", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        memset(&message, 0, 300);
        sprintf((char *)message, DATETIME_FORMAT, MAXDATETIME, "creation");
        ftCreationTime.dwHighDateTime = MAXTIMESTAMP;
        ftCreationTime.dwLowDateTime  = MAXTIMESTAMP;

        ret = WriteFile(h, &message, strlen(message), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = SetFileTime(h, &ftCreationTime, NULL, NULL);
        if(!ret) { tRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile name = \"%s\", rc = %d, wRc = %d, cRc = %d, tRc = %d\n", "MAXCTIME", rc, wRc, cRc, tRc);

    h   = CreateFile("MAXATIME", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        memset(&message, 0, 300);
        sprintf((char *)message, DATETIME_FORMAT, MAXDATETIME, "access");
        ftLastAccessTime.dwHighDateTime = MAXTIMESTAMP;
        ftLastAccessTime.dwLowDateTime  = MAXTIMESTAMP;

        ret = WriteFile(h, &message, strlen(message), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = SetFileTime(h, NULL, &ftLastAccessTime, NULL);
        if(!ret) { tRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile name = \"%s\", rc = %d, wRc = %d, cRc = %d, tRc = %d\n", "MAXATIME", rc, wRc, cRc, tRc);

    h   = CreateFile("MAXMTIME", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        memset(&message, 0, 300);
        sprintf((char *)message, DATETIME_FORMAT, MAXDATETIME, "modification");
        ftLastWriteTime.dwHighDateTime = MAXTIMESTAMP;
        ftLastWriteTime.dwLowDateTime  = MAXTIMESTAMP;

        ret = WriteFile(h, &message, strlen(message), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = SetFileTime(h, NULL, NULL, &ftLastWriteTime);
        if(!ret) { tRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile name = \"%s\", rc = %d, wRc = %d, cRc = %d, tRc = %d\n", "MAXMTIME", rc, wRc, cRc, tRc);

    h   = CreateFile("MINCTIME", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        memset(&message, 0, 300);
        sprintf((char *)message, DATETIME_FORMAT, MINDATETIME, "creation");
        ftCreationTime.dwHighDateTime = MINTIMESTAMP;
        ftCreationTime.dwLowDateTime  = MINTIMESTAMP;

        ret = WriteFile(h, &message, strlen(message), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = SetFileTime(h, &ftCreationTime, NULL, NULL);
        if(!ret) { tRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile name = \"%s\", rc = %d, wRc = %d, cRc = %d, tRc = %d\n", "MINCTIME", rc, wRc, cRc, tRc);

    h   = CreateFile("MINATIME", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        memset(&message, 0, 300);
        sprintf((char *)message, DATETIME_FORMAT, MINDATETIME, "access");
        ftLastAccessTime.dwHighDateTime = MINTIMESTAMP;
        ftLastAccessTime.dwLowDateTime  = MINTIMESTAMP;

        ret = WriteFile(h, &message, strlen(message), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = SetFileTime(h, NULL, &ftLastAccessTime, NULL);
        if(!ret) { tRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile name = \"%s\", rc = %d, wRc = %d, cRc = %d, tRc = %d\n", "MINATIME", rc, wRc, cRc, tRc);

    h   = CreateFile("MINMTIME", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        memset(&message, 0, 300);
        sprintf((char *)message, DATETIME_FORMAT, MINDATETIME, "modification");
        ftLastWriteTime.dwHighDateTime = MINTIMESTAMP;
        ftLastWriteTime.dwLowDateTime  = MINTIMESTAMP;

        ret = WriteFile(h, &message, strlen(message), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = SetFileTime(h, NULL, NULL, &ftLastWriteTime);
        if(!ret) { tRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile name = \"%s\", rc = %d, wRc = %d, cRc = %d, tRc = %d\n", "MINMTIME", rc, wRc, cRc, tRc);

    h   = CreateFile("Y1KCTIME", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        memset(&message, 0, 300);
        sprintf((char *)message, DATETIME_FORMAT, Y1KDATETIME, "creation");
        ftCreationTime.dwHighDateTime = TIMESTAMP_HI;
        ftCreationTime.dwLowDateTime  = Y1KTIMESTAMP_LO;

        ret = WriteFile(h, &message, strlen(message), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = SetFileTime(h, &ftCreationTime, NULL, NULL);
        if(!ret) { tRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile name = \"%s\", rc = %d, wRc = %d, cRc = %d, tRc = %d\n", "Y1KCTIME", rc, wRc, cRc, tRc);

    h   = CreateFile("Y1KATIME", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        memset(&message, 0, 300);
        sprintf((char *)message, DATETIME_FORMAT, Y1KDATETIME, "access");
        ftLastAccessTime.dwHighDateTime = TIMESTAMP_HI;
        ftLastAccessTime.dwLowDateTime  = Y1KTIMESTAMP_LO;

        ret = WriteFile(h, &message, strlen(message), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = SetFileTime(h, NULL, &ftLastAccessTime, NULL);
        if(!ret) { tRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile name = \"%s\", rc = %d, wRc = %d, cRc = %d, tRc = %d\n", "Y1KATIME", rc, wRc, cRc, tRc);

    h   = CreateFile("Y1KMTIME", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        memset(&message, 0, 300);
        sprintf((char *)message, DATETIME_FORMAT, Y1KDATETIME, "modification");
        ftLastWriteTime.dwHighDateTime = TIMESTAMP_HI;
        ftLastWriteTime.dwLowDateTime  = Y1KTIMESTAMP_LO;

        ret = WriteFile(h, &message, strlen(message), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = SetFileTime(h, NULL, NULL, &ftLastWriteTime);
        if(!ret) { tRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile name = \"%s\", rc = %d, wRc = %d, cRc = %d, tRc = %d\n", "Y1KMTIME", rc, wRc, cRc, tRc);

    h   = CreateFile("Y2KCTIME", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        memset(&message, 0, 300);
        sprintf((char *)message, DATETIME_FORMAT, Y2KDATETIME, "creation");
        ftCreationTime.dwHighDateTime = TIMESTAMP_HI;
        ftCreationTime.dwLowDateTime  = Y2KTIMESTAMP_LO;

        ret = WriteFile(h, &message, strlen(message), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = SetFileTime(h, &ftCreationTime, NULL, NULL);
        if(!ret) { tRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile name = \"%s\", rc = %d, wRc = %d, cRc = %d, tRc = %d\n", "Y2KCTIME", rc, wRc, cRc, tRc);

    h   = CreateFile("Y2KATIME", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        memset(&message, 0, 300);
        sprintf((char *)message, DATETIME_FORMAT, Y2KDATETIME, "access");
        ftLastAccessTime.dwHighDateTime = TIMESTAMP_HI;
        ftLastAccessTime.dwLowDateTime  = Y2KTIMESTAMP_LO;

        ret = WriteFile(h, &message, strlen(message), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = SetFileTime(h, NULL, &ftLastAccessTime, NULL);
        if(!ret) { tRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile name = \"%s\", rc = %d, wRc = %d, cRc = %d, tRc = %d\n", "Y2KATIME", rc, wRc, cRc, tRc);

    h   = CreateFile("Y2KMTIME", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        memset(&message, 0, 300);
        sprintf((char *)message, DATETIME_FORMAT, Y1KDATETIME, "modification");
        ftLastWriteTime.dwHighDateTime = TIMESTAMP_HI;
        ftLastWriteTime.dwLowDateTime  = Y2KTIMESTAMP_LO;

        ret = WriteFile(h, &message, strlen(message), &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = SetFileTime(h, NULL, NULL, &ftLastWriteTime);
        if(!ret) { tRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
    }
    printf("\tFile name = \"%s\", rc = %d, wRc = %d, cRc = %d, tRc = %d\n", "Y2KMTIME", rc, wRc, cRc, tRc);
}

void DirectoryDepth(const char *path)
{
    BOOL   ret;
    DWORD  error;
    LPTSTR lpRootPathName;
    DWORD  dwMaxNameSize = MAX_PATH + 1;
    size_t pathSize      = strlen(path);
    char   filename[9];
    long   pos = 2;

    lpRootPathName = malloc(dwMaxNameSize);

    if(lpRootPathName == NULL)
    {
        printf("Could not allocate memory.\n");
        return;
    }

    memset(lpRootPathName, 0x00, MAX_PATH);
    strcpy(lpRootPathName, path);

    if(path[pathSize - 1] != '\\') { lpRootPathName[pathSize] = '\\'; }

    ret = SetCurrentDirectory(lpRootPathName);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d changing to specified path.\n", error);
        return;
    }

    ret = CreateDirectory("DEPTH", NULL);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d creating working directory.\n", error);
        return;
    }

    ret = SetCurrentDirectory("DEPTH");

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d changing to working directory.\n", error);
        return;
    }

    printf("Creating deepest directory tree.\n");

    while(ret)
    {
        memset(&filename, 0, 9);
        sprintf(&filename, "%08d", pos);
        ret = CreateDirectory(filename, NULL);

        if(ret) ret = SetCurrentDirectory(filename);

        pos++;
    }

    printf("\tCreated %d levels of directory hierarchy\n", pos);
}

void Fragmentation(const char *path, size_t clusterSize)
{
    size_t         halfCluster             = clusterSize / 2;
    size_t         quarterCluster          = clusterSize / 4;
    size_t         twoCluster              = clusterSize * 2;
    size_t         threeQuartersCluster    = halfCluster + quarterCluster;
    size_t         twoAndThreeQuartCluster = threeQuartersCluster + twoCluster;
    unsigned char *buffer;
    long           i;
    BOOL           ret;
    DWORD          error;
    LPTSTR         lpRootPathName;
    DWORD          dwMaxNameSize = MAX_PATH + 1;
    size_t         pathSize      = strlen(path);
    HANDLE         h;
    DWORD          rc, wRc, cRc, tRc;
    DWORD          dwNumberOfBytesWritten;

    lpRootPathName = malloc(dwMaxNameSize);

    if(lpRootPathName == NULL)
    {
        printf("Could not allocate memory.\n");
        return;
    }

    memset(lpRootPathName, 0x00, MAX_PATH);
    strcpy(lpRootPathName, path);

    if(path[pathSize - 1] != '\\') { lpRootPathName[pathSize] = '\\'; }

    ret = SetCurrentDirectory(lpRootPathName);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d changing to specified path.\n", error);
        return;
    }

    ret = CreateDirectory("FRAGS", NULL);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d creating working directory.\n", error);
        return;
    }

    ret = SetCurrentDirectory("FRAGS");

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d changing to working directory.\n", error);
        return;
    }

    h   = CreateFile("HALFCLST", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        buffer = malloc(halfCluster);
        memset(buffer, 0, halfCluster);

        for(i = 0; i < halfCluster; i++) buffer[i] = clauniaBytes[i % CLAUNIA_SIZE];

        ret = WriteFile(h, buffer, halfCluster, &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
        free(buffer);
    }

    printf("\tFile name = \"%s\", size = %d, rc = %d, wRc = %d, cRc = %d\n", "HALFCLST", halfCluster, rc, wRc, cRc);

    h   = CreateFile("QUARCLST", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        buffer = malloc(quarterCluster);
        memset(buffer, 0, quarterCluster);

        for(i = 0; i < quarterCluster; i++) buffer[i] = clauniaBytes[i % CLAUNIA_SIZE];

        ret = WriteFile(h, buffer, quarterCluster, &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
        free(buffer);
    }

    printf("\tFile name = \"%s\", size = %d, rc = %d, wRc = %d, cRc = %d\n", "QUARCLST", quarterCluster, rc, wRc, cRc);

    h   = CreateFile("TWOCLST", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        buffer = malloc(twoCluster);
        memset(buffer, 0, twoCluster);

        for(i = 0; i < twoCluster; i++) buffer[i] = clauniaBytes[i % CLAUNIA_SIZE];

        ret = WriteFile(h, buffer, twoCluster, &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
        free(buffer);
    }

    printf("\tFile name = \"%s\", size = %d, rc = %d, wRc = %d, cRc = %d\n", "TWOCLST", twoCluster, rc, wRc, cRc);

    h   = CreateFile("TRQTCLST", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        buffer = malloc(threeQuartersCluster);
        memset(buffer, 0, threeQuartersCluster);

        for(i = 0; i < threeQuartersCluster; i++) buffer[i] = clauniaBytes[i % CLAUNIA_SIZE];

        ret = WriteFile(h, buffer, threeQuartersCluster, &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
        free(buffer);
    }

    printf("\tFile name = \"%s\", size = %d, rc = %d, wRc = %d, cRc = %d\n",
           "TRQTCLST",
           threeQuartersCluster,
           rc,
           wRc,
           cRc);

    h   = CreateFile("TWTQCLST", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        buffer = malloc(twoAndThreeQuartCluster);
        memset(buffer, 0, twoAndThreeQuartCluster);

        for(i = 0; i < twoAndThreeQuartCluster; i++) buffer[i] = clauniaBytes[i % CLAUNIA_SIZE];

        ret = WriteFile(h, buffer, twoAndThreeQuartCluster, &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
        free(buffer);
    }

    printf("\tFile name = \"%s\", size = %d, rc = %d, wRc = %d, cRc = %d\n",
           "TWTQCLST",
           twoAndThreeQuartCluster,
           rc,
           wRc,
           cRc);

    h   = CreateFile("TWO1", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        buffer = malloc(twoCluster);
        memset(buffer, 0, twoCluster);

        for(i = 0; i < twoCluster; i++) buffer[i] = clauniaBytes[i % CLAUNIA_SIZE];

        ret = WriteFile(h, buffer, twoCluster, &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
        free(buffer);
    }

    printf("\tFile name = \"%s\", size = %d, rc = %d, wRc = %d, cRc = %d\n", "TWO1", twoCluster, rc, wRc, cRc);

    h   = CreateFile("TWO2", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        buffer = malloc(twoCluster);
        memset(buffer, 0, twoCluster);

        for(i = 0; i < twoCluster; i++) buffer[i] = clauniaBytes[i % CLAUNIA_SIZE];

        ret = WriteFile(h, buffer, twoCluster, &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
        free(buffer);
    }

    printf("\tFile name = \"%s\", size = %d, rc = %d, wRc = %d, cRc = %d\n", "TWO2", twoCluster, rc, wRc, cRc);

    h   = CreateFile("TWO3", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        buffer = malloc(twoCluster);
        memset(buffer, 0, twoCluster);

        for(i = 0; i < twoCluster; i++) buffer[i] = clauniaBytes[i % CLAUNIA_SIZE];

        ret = WriteFile(h, buffer, twoCluster, &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
        free(buffer);
    }

    printf("\tDeleting \"TWO2\".\n");
    ret = DeleteFile("TWO2");
    if(!ret) { rc = GetLastError(); }

    printf("\tFile name = \"%s\", size = %d, rc = %d, wRc = %d, cRc = %d\n", "TWO3", twoCluster, rc, wRc, cRc);

    h   = CreateFile("FRAGTHRQ", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        buffer = malloc(threeQuartersCluster);
        memset(buffer, 0, threeQuartersCluster);

        for(i = 0; i < threeQuartersCluster; i++) buffer[i] = clauniaBytes[i % CLAUNIA_SIZE];

        ret = WriteFile(h, buffer, threeQuartersCluster, &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
        free(buffer);
    }

    printf("\tDeleting \"TWO1\".\n");
    ret = DeleteFile("TWO1");
    if(!ret) { rc = GetLastError(); }
    printf("\tDeleting \"TWO3\".\n");
    ret = DeleteFile("TWO3");
    if(!ret) { rc = GetLastError(); }

    printf("\tFile name = \"%s\", size = %d, rc = %d, wRc = %d, cRc = %d\n",
           "FRAGTHRQ",
           threeQuartersCluster,
           rc,
           wRc,
           cRc);

    h   = CreateFile("FRAGSIXQ", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    tRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        buffer = malloc(twoAndThreeQuartCluster);
        memset(buffer, 0, twoAndThreeQuartCluster);

        for(i = 0; i < twoAndThreeQuartCluster; i++) buffer[i] = clauniaBytes[i % CLAUNIA_SIZE];

        ret = WriteFile(h, buffer, twoAndThreeQuartCluster, &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
        free(buffer);
    }

    printf("\tFile name = \"%s\", size = %d, rc = %d, wRc = %d, cRc = %d\n",
           "FRAGSIXQ",
           twoAndThreeQuartCluster,
           rc,
           wRc,
           cRc);
}

void Sparse(const char *path)
{
    BOOL                       ret;
    DWORD                      error;
    LPTSTR                     lpVolumeNameBuffer;
    DWORD                      dwMaximumComponentLength;
    DWORD                      dwFileSystemFlags;
    DWORD                      dwMaxNameSize = MAX_PATH + 1;
    LPTSTR                     lpFileSystemNameBuffer;
    LPTSTR                     lpRootPathName;
    size_t                     pathSize = strlen(path);
    DWORD                      rc, wRc, cRc, sRc, zRc;
    FILE_ZERO_DATA_INFORMATION zeroData;
    HANDLE                     h;
    unsigned char *            buffer;
    int                        i;
    DWORD                      dwNumberOfBytesWritten;

    lpVolumeNameBuffer = malloc(dwMaxNameSize);

    if(lpVolumeNameBuffer == NULL)
    {
        printf("Could not allocate memory.\n");
        return;
    }

    lpFileSystemNameBuffer = malloc(dwMaxNameSize);

    if(lpFileSystemNameBuffer == NULL)
    {
        printf("Could not allocate memory.\n");
        free(lpVolumeNameBuffer);
        return;
    }

    lpRootPathName = malloc(dwMaxNameSize);

    if(lpRootPathName == NULL)
    {
        printf("Could not allocate memory.\n");
        free(lpVolumeNameBuffer);
        free(lpFileSystemNameBuffer);
        return;
    }

    memset(lpRootPathName, 0x00, MAX_PATH);
    strcpy(lpRootPathName, path);

    if(path[pathSize - 1] != '\\') { lpRootPathName[pathSize] = '\\'; }

    ret = GetVolumeInformation(lpRootPathName,
                               lpVolumeNameBuffer,
                               dwMaxNameSize,
                               NULL,
                               &dwMaximumComponentLength,
                               &dwFileSystemFlags,
                               lpFileSystemNameBuffer,
                               dwMaxNameSize);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d querying volume information.\n", error);
        free(lpVolumeNameBuffer);
        free(lpFileSystemNameBuffer);
        free(lpRootPathName);
        return;
    }

    free(lpVolumeNameBuffer);
    free(lpFileSystemNameBuffer);

    if(!(dwFileSystemFlags & FILE_SUPPORTS_SPARSE_FILES))
    {
        free(lpRootPathName);
        return;
    }

    ret = SetCurrentDirectory(lpRootPathName);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d changing to specified path.\n", error);
        return;
    }

    ret = CreateDirectory("SPARSE", NULL);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d creating working directory.\n", error);
        return;
    }

    ret = SetCurrentDirectory("SPARSE");

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d changing to working directory.\n", error);
        return;
    }

    free(lpRootPathName);

    printf("Creating sparse files.\n");

    h   = CreateFile("SMALL", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    sRc = 0;
    zRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        buffer = malloc(4096 * 3);
        memset(buffer, 0, 4096 * 3);

        for(i = 0; i < 4096 * 3; i++) buffer[i] = clauniaBytes[i % CLAUNIA_SIZE];

        ret = WriteFile(h, buffer, 4096 * 3, &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = DeviceIoControl(h, FSCTL_SET_SPARSE, NULL, 0, NULL, 0, &dwNumberOfBytesWritten, NULL);
        if(!ret)
        {
            sRc = GetLastError();
            if(sRc == 1)
            {
                sRc = 0;
                ret = DeviceIoControl(h, FSCTL_SET_SPARSE_OLD, NULL, 0, NULL, 0, &dwNumberOfBytesWritten, NULL);
                if(!ret) { sRc = GetLastError(); }
            }
        }

        if(sRc == 0)
        {
            zeroData.FileOffset.QuadPart      = 4096;
            zeroData.BeyondFinalZero.QuadPart = 8192;

            ret = DeviceIoControl(h,
                                  FSCTL_SET_ZERO_DATA,
                                  &zeroData,
                                  sizeof(FILE_ZERO_DATA_INFORMATION),
                                  NULL,
                                  0,
                                  &dwNumberOfBytesWritten,
                                  NULL);
            if(!ret)
            {
                zRc = GetLastError();
                if(zRc == 1)
                {
                    zRc = 0;
                    ret = DeviceIoControl(h,
                                          FSCTL_SET_ZERO_DATA_OLD,
                                          &zeroData,
                                          sizeof(FILE_ZERO_DATA_INFORMATION),
                                          NULL,
                                          0,
                                          &dwNumberOfBytesWritten,
                                          NULL);
                    if(!ret) { zRc = GetLastError(); }
                }
            }
        }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
        free(buffer);
    }

    printf("\tFile name = \"%s\", size = %d, rc = %d, wRc = %d, cRc = %d, sRc = %d, zRc\n",
           "SMALL",
           4096 * 3,
           rc,
           wRc,
           cRc,
           sRc,
           zRc);

    h   = CreateFile("BIG", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    rc  = 0;
    wRc = 0;
    cRc = 0;
    sRc = 0;
    zRc = 0;
    if(h == INVALID_HANDLE_VALUE) { rc = GetLastError(); }
    else
    {
        buffer = malloc(4096 * 30);
        memset(buffer, 0, 4096 * 30);

        for(i = 0; i < 4096 * 30; i++) buffer[i] = clauniaBytes[i % CLAUNIA_SIZE];

        ret = WriteFile(h, buffer, 4096 * 30, &dwNumberOfBytesWritten, NULL);
        if(!ret) { wRc = GetLastError(); }

        ret = DeviceIoControl(h, FSCTL_SET_SPARSE, NULL, 0, NULL, 0, &dwNumberOfBytesWritten, NULL);
        if(!ret)
        {
            sRc = GetLastError();
            if(sRc == 1)
            {
                sRc = 0;
                ret = DeviceIoControl(h, FSCTL_SET_SPARSE_OLD, NULL, 0, NULL, 0, &dwNumberOfBytesWritten, NULL);
                if(!ret) { sRc = GetLastError(); }
            }
        }

        if(sRc == 0)
        {
            zeroData.FileOffset.QuadPart      = 32768;
            zeroData.BeyondFinalZero.QuadPart = 81920;

            ret = DeviceIoControl(h,
                                  FSCTL_SET_ZERO_DATA,
                                  &zeroData,
                                  sizeof(FILE_ZERO_DATA_INFORMATION),
                                  NULL,
                                  0,
                                  &dwNumberOfBytesWritten,
                                  NULL);
            if(!ret)
            {
                zRc = GetLastError();
                if(zRc == 1)
                {
                    zRc = 0;
                    ret = DeviceIoControl(h,
                                          FSCTL_SET_ZERO_DATA_OLD,
                                          &zeroData,
                                          sizeof(FILE_ZERO_DATA_INFORMATION),
                                          NULL,
                                          0,
                                          &dwNumberOfBytesWritten,
                                          NULL);
                    if(!ret) { zRc = GetLastError(); }
                }
            }
        }

        ret = CloseHandle(h);
        if(!ret) { cRc = GetLastError(); }
        free(buffer);
    }

    printf("\tFile name = \"%s\", size = %d, rc = %d, wRc = %d, cRc = %d, sRc = %d, zRc\n",
           "BIG",
           4096 * 30,
           rc,
           wRc,
           cRc,
           sRc,
           zRc);
}

void Links(const char *path)
{
    /*
        BOOL ret;
        DWORD error;
        OSVERSIONINFO verInfo;
        HINSTANCE kernel32;
        void *func;
        DWORD dwNumberOfBytesWritten;
        DWORD rc, wRc, cRc, lRc;
        char   message[300];
        HANDLE h;
        LPTSTR lpRootPathName;
        DWORD dwMaxNameSize = MAX_PATH + 1;
        size_t pathSize = strlen(path);

        verInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
        ret = GetVersionEx(&verInfo);

        if(!ret)
        {
            error = GetLastError();
            printf("Error %d querying Windows version.\n", error);
            return;
        }

        if(verInfo.dwPlatformId != VER_PLATFORM_WIN32_NT)
        {
            // Not supported on Windows 9x
            return;
        }

        lpRootPathName = malloc(dwMaxNameSize);

        if(lpRootPathName == NULL)
        {
            printf("Could not allocate memory.\n");
            return;
        }

        memset(lpRootPathName, 0x00, MAX_PATH);
        strcpy(lpRootPathName, path);

        if(path[pathSize - 1] != '\\')
        {
            lpRootPathName[pathSize] = '\\';
        }

        ret = SetCurrentDirectory(lpRootPathName);

        if(!ret)
        {
            error = GetLastError();
            printf("Error %d changing to specified path.\n", error);
            return;
        }

        ret = CreateDirectory("LINKS", NULL);

        if(!ret)
        {
            error = GetLastError();
            printf("Error %d creating working directory.\n", error);
            return;
        }

        ret = SetCurrentDirectory("LINKS");

        if(!ret)
        {
            error = GetLastError();
            printf("Error %d changing to working directory.\n", error);
            return;
        }

        kernel32 = LoadLibrary("kernel32.dll");

        if(kernel32 == NULL)
        {
            error = GetLastError();
            printf("Error %d loading KERNEL32.DLL.\n", error);
            return;
        }

        func = GetProcAddress(kernel32, "CreateSymbolicLinkA");

        if(func == NULL)
        {
            error = GetLastError();
            printf("Error %d finding CreateSymbolicLinkA.\n", error);
        }
        else
        {
            CreateSymbolicLinkA = func;
            printf("Creating symbolic links.\n");

            h = CreateFile("TARGET", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
       CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); rc = 0; wRc = 0; cRc = 0; lRc = 0; if(h == INVALID_HANDLE_VALUE)
            {
                rc = GetLastError();
            }
            else
            {
                memset(&message, 0, 300);
                sprintf(&message, "This file is the target of a symbolic link.\n");
                ret = WriteFile(h, &message, strlen(message), &dwNumberOfBytesWritten, NULL);
                if(!ret)
                {
                    wRc = GetLastError();
                }

                ret = CloseHandle(h);
                if(!ret)
                {
                    cRc = GetLastError();
                }

                ret = CreateSymbolicLinkA("SYMLINK", "TARGET", 0);
                if(!ret)
                {
                    cRc = GetLastError();
                }
            }

            printf("\tSymbolic link, rc = 0x%08x, wRc = %d, cRc = %d, lRc = %d\n", rc, wRc, cRc, lRc);
        }

        func = GetProcAddress(kernel32, "CreateHardLinkA");

        if(func == NULL)
        {
            error = GetLastError();
            printf("Error %d finding CreateHardLinkA.\n", error);
        }
        else
        {
            CreateSymbolicLinkA = func;
            printf("Creating hard links.\n");

            h = CreateFile("HARDTRGT", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
       CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); rc = 0; wRc = 0; cRc = 0; lRc = 0; if(h == INVALID_HANDLE_VALUE)
            {
                rc = GetLastError();
            }
            else
            {
                memset(&message, 0, 300);
                sprintf(&message, "This file is part of a hard link.\n");
                ret = WriteFile(h, &message, strlen(message), &dwNumberOfBytesWritten, NULL);
                if(!ret)
                {
                    wRc = GetLastError();
                }

                ret = CloseHandle(h);
                if(!ret)
                {
                    cRc = GetLastError();
                }

                ret = CreateSymbolicLinkA("HARDLINK", "HARDTRGT", NULL);
                if(!ret)
                {
                    cRc = GetLastError();
                }
            }

            printf("\tHard link, rc = 0x%08x, wRc = %d, cRc = %d, lRc = %d\n", rc, wRc, cRc, lRc);
        }

        FreeLibrary(kernel32);
    */
}

void MillionFiles(const char *path)
{
    char   filename[9];
    DWORD  pos = 0;
    HANDLE h;
    BOOL   ret;
    DWORD  error;
    LPTSTR lpRootPathName;
    DWORD  dwMaxNameSize = MAX_PATH + 1;
    size_t pathSize      = strlen(path);

    lpRootPathName = malloc(dwMaxNameSize);

    if(lpRootPathName == NULL)
    {
        printf("Could not allocate memory.\n");
        return;
    }

    memset(lpRootPathName, 0x00, MAX_PATH);
    strcpy(lpRootPathName, path);

    if(path[pathSize - 1] != '\\') { lpRootPathName[pathSize] = '\\'; }

    ret = SetCurrentDirectory(lpRootPathName);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d changing to specified path.\n", error);
        return;
    }

    ret = CreateDirectory("MILLION", NULL);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d creating working directory.\n", error);
        return;
    }

    ret = SetCurrentDirectory("MILLION");

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d changing to working directory.\n", error);
        return;
    }

    printf("Creating lots of files.\n");

    for(pos = 0; pos < 100000; pos++)
    {
        memset(&filename, 0, 9);
        sprintf(&filename, "%08Lu", pos);

        h = CreateFile(&filename, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        if(h == INVALID_HANDLE_VALUE) { break; }

        CloseHandle(h);
    }

    printf("\tCreated %Lu files\n", pos);
}

void DeleteFiles(const char *path)
{
    char   filename[9];
    DWORD  pos = 0;
    HANDLE h;
    BOOL   ret;
    DWORD  error;
    LPTSTR lpRootPathName;
    DWORD  dwMaxNameSize = MAX_PATH + 1;
    size_t pathSize      = strlen(path);

    lpRootPathName = malloc(dwMaxNameSize);

    if(lpRootPathName == NULL)
    {
        printf("Could not allocate memory.\n");
        return;
    }

    memset(lpRootPathName, 0x00, MAX_PATH);
    strcpy(lpRootPathName, path);

    if(path[pathSize - 1] != '\\') { lpRootPathName[pathSize] = '\\'; }

    ret = SetCurrentDirectory(lpRootPathName);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d changing to specified path.\n", error);
        return;
    }

    ret = CreateDirectory("DELETED", NULL);

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d creating working directory.\n", error);
        return;
    }

    ret = SetCurrentDirectory("DELETED");

    if(!ret)
    {
        error = GetLastError();
        printf("Error %d changing to working directory.\n", error);
        return;
    }

    printf("Creating and deleting files.\n");

    for(pos = 0; pos < 64; pos++)
    {
        memset(&filename, 0, 9);
        sprintf(&filename, "%X", pos);
        h = CreateFile(&filename, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        if(h == INVALID_HANDLE_VALUE) { break; }

        CloseHandle(h);
        DeleteFile(&filename);
    }
}

#endif