vtoyjump/vtoyjump/vtoyjump.c

   1 /******************************************************************************
   2 * vtoyjump.c
   3 *
   4 * Copyright (c) 2021, longpanda <admin@ventoy.net>
   5 *
   6 * This program is free software; you can redistribute it and/or
   7 * modify it under the terms of the GNU General Public License as
   8 * published by the Free Software Foundation; either version 3 of the
   9 * License, or (at your option) any later version.
  10 *
  11 * This program is distributed in the hope that it will be useful, but
  12 * WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 * General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
  18 *
  19 */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <Windows.h>
  25 #include <virtdisk.h>
  26 #include <winioctl.h>
  27 #include <VersionHelpers.h>
  28 #include "vtoyjump.h"
  29 #include "fat_filelib.h"
  30
  31 static ventoy_os_param g_os_param;
  32 static ventoy_windows_data g_windows_data;
  33 static UINT8 g_os_param_reserved[32];
  34 static INT g_system_bit = VTOY_BIT;
  35 static ventoy_guid g_ventoy_guid = VENTOY_GUID;
  36 static HANDLE g_vtoylog_mutex = NULL;
  37 static HANDLE g_vtoyins_mutex = NULL;
  38
  39 static BOOL g_wimboot_mode = FALSE;
  40
  41 static DWORD g_vtoy_disk_drive;
  42
  43 static CHAR g_prog_full_path[MAX_PATH];
  44 static CHAR g_prog_dir[MAX_PATH];
  45 static CHAR g_prog_name[MAX_PATH];
  46
  47 #define VTOY_PECMD_PATH      "X:\\Windows\\system32\\ventoy\\PECMD.EXE"
  48 #define ORG_PECMD_PATH       "X:\\Windows\\system32\\PECMD.EXE"
  49 #define ORG_PECMD_BK_PATH    "X:\\Windows\\system32\\VTOYJUMP.EXE"
  50
  51 #define WIMBOOT_FILE         "X:\\Windows\\system32\\vtoy_wimboot"
  52 #define WIMBOOT_DONE         "X:\\Windows\\system32\\vtoy_wimboot_done"
  53
  54 #define AUTO_RUN_BAT    "X:\\VentoyAutoRun.bat"
  55 #define AUTO_RUN_LOG    "X:\\VentoyAutoRun.log"
  56
  57 #define VTOY_AUTO_FILE   "X:\\_vtoy_auto_install"
  58
  59 #define LOG_FILE  "X:\\Windows\\system32\\ventoy.log"
  60 #define MUTEX_LOCK(hmutex)  if (hmutex != NULL) LockStatus = WaitForSingleObject(hmutex, INFINITE)
  61 #define MUTEX_UNLOCK(hmutex)  if (hmutex != NULL && WAIT_OBJECT_0 == LockStatus) ReleaseMutex(hmutex)
  62
  63 #define BREAK()  BreakAndLaunchCmd(__LINE__)
  64
  65 static void BreakAndLaunchCmd(int line)
  66 {
  67     STARTUPINFOA Si;
  68     PROCESS_INFORMATION Pi;
  69
  70     Log("Break at line:%d", line);
  71
  72     GetStartupInfoA(&Si);
  73     Si.dwFlags |= STARTF_USESHOWWINDOW;
  74     Si.wShowWindow = SW_NORMAL;
  75
  76     CreateProcessA(NULL, "cmd.exe", NULL, NULL, FALSE, 0, NULL, NULL, &Si, &Pi);
  77     WaitForSingleObject(Pi.hProcess, INFINITE);
  78 }
  79
  80 static const char * GetFileNameInPath(const char *fullpath)
  81 {
  82     int i;
  83
  84     if (strstr(fullpath, ":"))
  85     {
  86         for (i = (int)strlen(fullpath); i > 0; i--)
  87         {
  88             if (fullpath[i - 1] == '/' || fullpath[i - 1] == '\\')
  89             {
  90                 return fullpath + i;
  91             }
  92         }
  93     }
  94
  95     return fullpath;
  96 }
  97
  98 static int split_path_name(char *fullpath, char *dir, char *name)
  99 {
 100     CHAR ch;
 101     CHAR *Pos = NULL;
 102
 103     Pos = (CHAR *)GetFileNameInPath(fullpath);
 104
 105     strcpy_s(name, MAX_PATH, Pos);
 106
 107     ch = *(Pos - 1);
 108     *(Pos - 1) = 0;
 109     strcpy_s(dir, MAX_PATH, fullpath);
 110     *(Pos - 1) = ch;
 111
 112     return 0;
 113 }
 114
 115 static void TrimString(CHAR *String, BOOL TrimLeft)
 116 {
 117     CHAR *Pos1 = String;
 118     CHAR *Pos2 = String;
 119     size_t Len = strlen(String);
 120
 121     while (Len > 0)
 122     {
 123         if (String[Len - 1] != ' ' && String[Len - 1] != '\t')
 124         {
 125             break;
 126         }
 127         String[Len - 1] = 0;
 128         Len--;
 129     }
 130
 131     if (TrimLeft)
 132     {
 133         while (*Pos1 == ' ' || *Pos1 == '\t')
 134         {
 135             Pos1++;
 136         }
 137
 138         while (*Pos1)
 139         {
 140             *Pos2++ = *Pos1++;
 141         }
 142         *Pos2++ = 0;
 143     }
 144
 145     return;
 146 }
 147
 148 static int VentoyProcessRunCmd(const char *Fmt, ...)
 149 {
 150     int Len = 0;
 151     va_list Arg;
 152     STARTUPINFOA Si;
 153     PROCESS_INFORMATION Pi;
 154     char szBuf[1024] = { 0 };
 155
 156     va_start(Arg, Fmt);
 157     Len += vsnprintf_s(szBuf + Len, sizeof(szBuf)-Len, sizeof(szBuf)-Len, Fmt, Arg);
 158     va_end(Arg);
 159
 160     GetStartupInfoA(&Si);
 161     Si.dwFlags |= STARTF_USESHOWWINDOW;
 162     Si.wShowWindow = SW_HIDE;
 163
 164     Log("Process Run: <%s>", szBuf);
 165     CreateProcessA(NULL, szBuf, NULL, NULL, FALSE, 0, NULL, NULL, &Si, &Pi);
 166     WaitForSingleObject(Pi.hProcess, INFINITE);
 167
 168     return 0;
 169 }
 170
 171 static CHAR VentoyGetFirstFreeDriveLetter(BOOL Reverse)
 172 {
 173     int i;
 174     CHAR Letter = 'T';
 175     DWORD Drives;
 176
 177     Drives = GetLogicalDrives();
 178
 179     if (Reverse)
 180     {
 181         for (i = 25; i >= 2; i--)
 182         {
 183             if (0 == (Drives & (1 << i)))
 184             {
 185                 Letter = 'A' + i;
 186                 break;
 187             }
 188         }
 189     }
 190     else
 191     {
 192         for (i = 2; i < 26; i++)
 193         {
 194             if (0 == (Drives & (1 << i)))
 195             {
 196                 Letter = 'A' + i;
 197                 break;
 198             }
 199         }
 200     }
 201
 202     Log("FirstFreeDriveLetter %u %C:", Reverse, Letter);
 203     return Letter;
 204 }
 205
 206 void Log(const char *Fmt, ...)
 207 {
 208     va_list Arg;
 209     int Len = 0;
 210     FILE *File = NULL;
 211     SYSTEMTIME Sys;
 212     char szBuf[1024];
 213     DWORD LockStatus = 0;
 214     DWORD PID = GetCurrentProcessId();
 215
 216     GetLocalTime(&Sys);
 217     Len += sprintf_s(szBuf, sizeof(szBuf),
 218         "[%4d/%02d/%02d %02d:%02d:%02d.%03d] [%u] ",
 219         Sys.wYear, Sys.wMonth, Sys.wDay,
 220         Sys.wHour, Sys.wMinute, Sys.wSecond,
 221         Sys.wMilliseconds, PID);
 222
 223     va_start(Arg, Fmt);
 224     Len += vsnprintf_s(szBuf + Len, sizeof(szBuf)-Len, sizeof(szBuf)-Len, Fmt, Arg);
 225     va_end(Arg);
 226
 227     MUTEX_LOCK(g_vtoylog_mutex);
 228
 229     fopen_s(&File, LOG_FILE, "a+");
 230     if (File)
 231     {
 232         fwrite(szBuf, 1, Len, File);
 233         fwrite("\n", 1, 1, File);
 234         fclose(File);
 235     }
 236
 237     MUTEX_UNLOCK(g_vtoylog_mutex);
 238 }
 239
 240
 241 static int LoadNtDriver(const char *DrvBinPath)
 242 {
 243     int i;
 244     int rc = 0;
 245     BOOL Ret;
 246     DWORD Status;
 247     SC_HANDLE hServiceMgr;
 248     SC_HANDLE hService;
 249     char name[256] = { 0 };
 250
 251     for (i = (int)strlen(DrvBinPath) - 1; i >= 0; i--)
 252     {
 253         if (DrvBinPath[i] == '\\' || DrvBinPath[i] == '/')
 254         {
 255             sprintf_s(name, sizeof(name), "%s", DrvBinPath + i + 1);
 256             break;
 257         }
 258     }
 259
 260     Log("Load NT driver: %s %s", DrvBinPath, name);
 261
 262     hServiceMgr = OpenSCManagerA(NULL, NULL, SC_MANAGER_ALL_ACCESS);
 263     if (hServiceMgr == NULL)
 264     {
 265         Log("OpenSCManager failed Error:%u", GetLastError());
 266         return 1;
 267     }
 268
 269     Log("OpenSCManager OK");
 270
 271     hService = CreateServiceA(hServiceMgr,
 272         name,
 273         name,
 274         SERVICE_ALL_ACCESS,
 275         SERVICE_KERNEL_DRIVER,
 276         SERVICE_DEMAND_START,
 277         SERVICE_ERROR_NORMAL,
 278         DrvBinPath,
 279         NULL, NULL, NULL, NULL, NULL);
 280     if (hService == NULL)
 281     {
 282         Status = GetLastError();
 283         if (Status != ERROR_IO_PENDING && Status != ERROR_SERVICE_EXISTS)
 284         {
 285             Log("CreateService failed v %u", Status);
 286             CloseServiceHandle(hServiceMgr);
 287             return 1;
 288         }
 289
 290         hService = OpenServiceA(hServiceMgr, name, SERVICE_ALL_ACCESS);
 291         if (hService == NULL)
 292         {
 293             Log("OpenService failed %u", Status);
 294             CloseServiceHandle(hServiceMgr);
 295             return 1;
 296         }
 297     }
 298
 299     Log("CreateService imdisk OK");
 300
 301     Ret = StartServiceA(hService, 0, NULL);
 302     if (Ret)
 303     {
 304         Log("StartService OK");
 305     }
 306     else
 307     {
 308         Status = GetLastError();
 309         if (Status == ERROR_SERVICE_ALREADY_RUNNING)
 310         {
 311             rc = 0;
 312         }
 313         else
 314         {
 315             Log("StartService error  %u", Status);
 316             rc = 1;
 317         }
 318     }
 319
 320     CloseServiceHandle(hService);
 321     CloseServiceHandle(hServiceMgr);
 322
 323     Log("Load NT driver %s", rc ? "failed" : "success");
 324
 325     return rc;
 326 }
 327
 328 static int ReadWholeFile2Buf(const char *Fullpath, void **Data, DWORD *Size)
 329 {
 330     int rc = 1;
 331     DWORD FileSize;
 332     DWORD dwSize;
 333     HANDLE Handle;
 334     BYTE *Buffer = NULL;
 335
 336     Log("ReadWholeFile2Buf <%s>", Fullpath);
 337
 338     Handle = CreateFileA(Fullpath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
 339     if (Handle == INVALID_HANDLE_VALUE)
 340     {
 341         Log("Could not open the file<%s>, error:%u", Fullpath, GetLastError());
 342         goto End;
 343     }
 344
 345     FileSize = SetFilePointer(Handle, 0, NULL, FILE_END);
 346
 347     Buffer = malloc(FileSize);
 348     if (!Buffer)
 349     {
 350         Log("Failed to alloc memory size:%u", FileSize);
 351         goto End;
 352     }
 353
 354     SetFilePointer(Handle, 0, NULL, FILE_BEGIN);
 355     if (!ReadFile(Handle, Buffer, FileSize, &dwSize, NULL))
 356     {
 357         Log("ReadFile failed, dwSize:%u  error:%u", dwSize, GetLastError());
 358         goto End;
 359     }
 360
 361     *Data = Buffer;
 362     *Size = FileSize;
 363
 364     Log("Success read file size:%u", FileSize);
 365
 366     rc = 0;
 367
 368 End:
 369     SAFE_CLOSE_HANDLE(Handle);
 370
 371     return rc;
 372 }
 373
 374 static BOOL CheckPeHead(BYTE *Buffer, DWORD Size, DWORD Offset)
 375 {
 376     UINT32 PeOffset;
 377     BYTE *Head = NULL;
 378     DWORD End;
 379     ventoy_windows_data *pdata = NULL;
 380
 381     Head = Buffer + Offset;
 382     pdata = (ventoy_windows_data *)Head;
 383     Head += sizeof(ventoy_windows_data);
 384
 385     if (pdata->auto_install_script[0] && pdata->auto_install_len > 0)
 386     {
 387         End = Offset + sizeof(ventoy_windows_data) + pdata->auto_install_len + 60;
 388         if (End < Size)
 389         {
 390             Head += pdata->auto_install_len;
 391         }
 392     }
 393
 394     if (Head[0] != 'M' || Head[1] != 'Z')
 395     {
 396         return FALSE;
 397     }
 398
 399     PeOffset = *(UINT32 *)(Head + 60);
 400     if (*(UINT32 *)(Head + PeOffset) != 0x00004550)
 401     {
 402         return FALSE;
 403     }
 404
 405     return TRUE;
 406 }
 407
 408
 409 static BOOL CheckOsParam(ventoy_os_param *param)
 410 {
 411     UINT32 i;
 412     BYTE Sum = 0;
 413
 414     if (memcmp(&param->guid, &g_ventoy_guid, sizeof(ventoy_guid)))
 415     {
 416         return FALSE;
 417     }
 418
 419     for (i = 0; i < sizeof(ventoy_os_param); i++)
 420     {
 421         Sum += *((BYTE *)param + i);
 422     }
 423
 424     if (Sum)
 425     {
 426         return FALSE;
 427     }
 428
 429     if (param->vtoy_img_location_addr % 4096)
 430     {
 431         return FALSE;
 432     }
 433
 434     return TRUE;
 435 }
 436
 437 static int SaveBuffer2File(const char *Fullpath, void *Buffer, DWORD Length)
 438 {
 439     int rc = 1;
 440     DWORD dwSize;
 441     HANDLE Handle;
 442
 443     Log("SaveBuffer2File <%s> len:%u", Fullpath, Length);
 444
 445     Handle = CreateFileA(Fullpath, GENERIC_READ | GENERIC_WRITE,
 446         FILE_SHARE_READ | FILE_SHARE_WRITE, 0, CREATE_NEW, 0, 0);
 447     if (Handle == INVALID_HANDLE_VALUE)
 448     {
 449         Log("Could not create new file, error:%u", GetLastError());
 450         goto End;
 451     }
 452
 453     WriteFile(Handle, Buffer, Length, &dwSize, NULL);
 454
 455     rc = 0;
 456
 457 End:
 458     SAFE_CLOSE_HANDLE(Handle);
 459
 460     return rc;
 461 }
 462
 463 static int IsUTF8Encode(const char *src)
 464 {
 465     int i;
 466     const UCHAR *Byte = (const UCHAR *)src;
 467
 468     for (i = 0; i < MAX_PATH && Byte[i]; i++)
 469     {
 470         if (Byte[i] > 127)
 471         {
 472             return 1;
 473         }
 474     }
 475
 476     return 0;
 477 }
 478
 479 static int Utf16ToUtf8(const WCHAR *src, char *dst)
 480 {
 481     int len;
 482     int size;
 483
 484     len = (int)wcslen(src) + 1;
 485     size = WideCharToMultiByte(CP_UTF8, 0, src, len, NULL, 0, NULL, NULL);
 486     return WideCharToMultiByte(CP_UTF8, 0, src, len, dst, size, NULL, NULL);
 487 }
 488
 489 static int Utf8ToUtf16(const char* src, WCHAR * dst)
 490 {
 491     int size = MultiByteToWideChar(CP_UTF8, 0, src, -1, dst, 0);
 492     return MultiByteToWideChar(CP_UTF8, 0, src, -1, dst, size + 1);
 493 }
 494
 495 static BOOL IsDirExist(const char *Fmt, ...)
 496 {
 497     va_list Arg;
 498     DWORD Attr;
 499     int UTF8 = 0;
 500     CHAR FilePathA[MAX_PATH];
 501     WCHAR FilePathW[MAX_PATH];
 502
 503     va_start(Arg, Fmt);
 504     vsnprintf_s(FilePathA, sizeof(FilePathA), sizeof(FilePathA), Fmt, Arg);
 505     va_end(Arg);
 506
 507     UTF8 = IsUTF8Encode(FilePathA);
 508
 509     if (UTF8)
 510     {
 511         Utf8ToUtf16(FilePathA, FilePathW);
 512         Attr = GetFileAttributesW(FilePathW);
 513     }
 514     else
 515     {
 516         Attr = GetFileAttributesA(FilePathA);
 517     }
 518
 519     if (Attr != INVALID_FILE_ATTRIBUTES && (Attr & FILE_ATTRIBUTE_DIRECTORY))
 520     {
 521         return TRUE;
 522     }
 523
 524     return FALSE;
 525 }
 526
 527 static BOOL IsFileExist(const char *Fmt, ...)
 528 {
 529     va_list Arg;
 530     HANDLE hFile;
 531     DWORD Attr;
 532     BOOL bRet = FALSE;
 533     int UTF8 = 0;
 534     CHAR FilePathA[MAX_PATH];
 535     WCHAR FilePathW[MAX_PATH];
 536
 537     va_start(Arg, Fmt);
 538     vsnprintf_s(FilePathA, sizeof(FilePathA), sizeof(FilePathA), Fmt, Arg);
 539     va_end(Arg);
 540
 541     UTF8 = IsUTF8Encode(FilePathA);
 542
 543     if (UTF8)
 544     {
 545         Utf8ToUtf16(FilePathA, FilePathW);
 546         hFile = CreateFileW(FilePathW, FILE_READ_EA, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
 547     }
 548     else
 549     {
 550         hFile = CreateFileA(FilePathA, FILE_READ_EA, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
 551     }
 552     if (INVALID_HANDLE_VALUE == hFile)
 553     {
 554         goto out;
 555     }
 556
 557     CloseHandle(hFile);
 558
 559     if (UTF8)
 560     {
 561         Attr = GetFileAttributesW(FilePathW);
 562     }
 563     else
 564     {
 565         Attr = GetFileAttributesA(FilePathA);
 566     }
 567
 568     if (Attr & FILE_ATTRIBUTE_DIRECTORY)
 569     {
 570         goto out;
 571     }
 572
 573     bRet = TRUE;
 574
 575 out:
 576     Log("File <%s> %s", FilePathA, (bRet ? "exist" : "NOT exist"));
 577     return bRet;
 578 }
 579
 580 static int GetPhyDiskUUID(const char LogicalDrive, UINT8 *UUID, UINT32 *DiskSig, DISK_EXTENT *DiskExtent)
 581 {
 582     BOOL Ret;
 583     DWORD dwSize;
 584     HANDLE Handle;
 585     VOLUME_DISK_EXTENTS DiskExtents;
 586     CHAR PhyPath[128];
 587     UINT8 SectorBuf[512];
 588
 589     Log("GetPhyDiskUUID %C", LogicalDrive);
 590
 591     sprintf_s(PhyPath, sizeof(PhyPath), "\\\\.\\%C:", LogicalDrive);
 592     Handle = CreateFileA(PhyPath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
 593     if (Handle == INVALID_HANDLE_VALUE)
 594     {
 595         Log("Could not open the disk<%s>, error:%u", PhyPath, GetLastError());
 596         return 1;
 597     }
 598
 599     Ret = DeviceIoControl(Handle,
 600         IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
 601         NULL,
 602         0,
 603         &DiskExtents,
 604         (DWORD)(sizeof(DiskExtents)),
 605         (LPDWORD)&dwSize,
 606         NULL);
 607     if (!Ret || DiskExtents.NumberOfDiskExtents == 0)
 608     {
 609         Log("DeviceIoControl IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS failed, error:%u", GetLastError());
 610         CloseHandle(Handle);
 611         return 1;
 612     }
 613     CloseHandle(Handle);
 614
 615     memcpy(DiskExtent, DiskExtents.Extents, sizeof(DISK_EXTENT));
 616     Log("%C: is in PhysicalDrive%d Offset:%llu", LogicalDrive, DiskExtents.Extents[0].DiskNumber,
 617         (ULONGLONG)(DiskExtents.Extents[0].StartingOffset.QuadPart));
 618
 619     sprintf_s(PhyPath, sizeof(PhyPath), "\\\\.\\PhysicalDrive%d", DiskExtents.Extents[0].DiskNumber);
 620     Handle = CreateFileA(PhyPath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
 621     if (Handle == INVALID_HANDLE_VALUE)
 622     {
 623         Log("Could not open the disk<%s>, error:%u", PhyPath, GetLastError());
 624         return 1;
 625     }
 626
 627     if (!ReadFile(Handle, SectorBuf, sizeof(SectorBuf), &dwSize, NULL))
 628     {
 629         Log("ReadFile failed, dwSize:%u  error:%u", dwSize, GetLastError());
 630         CloseHandle(Handle);
 631         return 1;
 632     }
 633
 634     memcpy(UUID, SectorBuf + 0x180, 16);
 635     if (DiskSig)
 636     {
 637         memcpy(DiskSig, SectorBuf + 0x1B8, 4);
 638     }
 639
 640     CloseHandle(Handle);
 641     return 0;
 642 }
 643
 644 static int VentoyMountAnywhere(HANDLE Handle)
 645 {
 646     DWORD Status;
 647     ATTACH_VIRTUAL_DISK_PARAMETERS AttachParameters;
 648
 649     Log("VentoyMountAnywhere");
 650
 651     memset(&AttachParameters, 0, sizeof(AttachParameters));
 652     AttachParameters.Version = ATTACH_VIRTUAL_DISK_VERSION_1;
 653
 654     Status = AttachVirtualDisk(Handle, NULL, ATTACH_VIRTUAL_DISK_FLAG_READ_ONLY | ATTACH_VIRTUAL_DISK_FLAG_PERMANENT_LIFETIME, 0, &AttachParameters, NULL);
 655     if (Status != ERROR_SUCCESS)
 656     {
 657         Log("Failed to attach virtual disk ErrorCode:%u", Status);
 658         return 1;
 659     }
 660
 661     return 0;
 662 }
 663
 664 int VentoyMountY(HANDLE Handle)
 665 {
 666     int  i;
 667     BOOL  bRet = FALSE;
 668     DWORD Status;
 669     DWORD physicalDriveNameSize;
 670     CHAR *Pos = NULL;
 671     WCHAR physicalDriveName[MAX_PATH];
 672     CHAR physicalDriveNameA[MAX_PATH];
 673     CHAR cdromDriveName[MAX_PATH];
 674     ATTACH_VIRTUAL_DISK_PARAMETERS AttachParameters;
 675
 676     Log("VentoyMountY");
 677
 678     memset(&AttachParameters, 0, sizeof(AttachParameters));
 679     AttachParameters.Version = ATTACH_VIRTUAL_DISK_VERSION_1;
 680
 681     Status = AttachVirtualDisk(Handle, NULL, ATTACH_VIRTUAL_DISK_FLAG_READ_ONLY | ATTACH_VIRTUAL_DISK_FLAG_NO_DRIVE_LETTER | ATTACH_VIRTUAL_DISK_FLAG_PERMANENT_LIFETIME, 0, &AttachParameters, NULL);
 682     if (Status != ERROR_SUCCESS)
 683     {
 684         Log("Failed to attach virtual disk ErrorCode:%u", Status);
 685         return 1;
 686     }
 687
 688     memset(physicalDriveName, 0, sizeof(physicalDriveName));
 689     memset(physicalDriveNameA, 0, sizeof(physicalDriveNameA));
 690
 691     physicalDriveNameSize = MAX_PATH;
 692     Status = GetVirtualDiskPhysicalPath(Handle, &physicalDriveNameSize, physicalDriveName);
 693     if (Status != ERROR_SUCCESS)
 694     {
 695         Log("Failed GetVirtualDiskPhysicalPath ErrorCode:%u", Status);
 696         return 1;
 697     }
 698
 699     for (i = 0; physicalDriveName[i]; i++)
 700     {
 701         physicalDriveNameA[i] = (CHAR)toupper((CHAR)(physicalDriveName[i]));
 702     }
 703
 704     Log("physicalDriveNameA=<%s>", physicalDriveNameA);
 705
 706     Pos = strstr(physicalDriveNameA, "CDROM");
 707     if (!Pos)
 708     {
 709         Log("Not cdrom phy drive");
 710         return 1;
 711     }
 712
 713     sprintf_s(cdromDriveName, sizeof(cdromDriveName), "\\Device\\%s", Pos);
 714     Log("cdromDriveName=<%s>", cdromDriveName);
 715
 716     for (i = 0; i < 3 && (bRet == FALSE); i++)
 717     {
 718         Sleep(1000);
 719         bRet = DefineDosDeviceA(DDD_RAW_TARGET_PATH, "Y:", cdromDriveName);
 720         Log("DefineDosDeviceA %s", bRet ? "success" : "failed");
 721     }
 722
 723     return bRet ? 0 : 1;
 724 }
 725
 726 static BOOL VentoyAPINeedMountY(const char *IsoPath)
 727 {
 728     (void)IsoPath;
 729
 730     /* TBD */
 731     return FALSE;
 732 }
 733
 734 static int VentoyAttachVirtualDisk(HANDLE Handle, const char *IsoPath)
 735 {
 736     int DriveYFree;
 737     DWORD Drives;
 738
 739     Drives = GetLogicalDrives();
 740     if ((1 << 24) & Drives)
 741     {
 742         Log("Y: is occupied");
 743         DriveYFree = 0;
 744     }
 745     else
 746     {
 747         Log("Y: is free now");
 748         DriveYFree = 1;
 749     }
 750
 751     if (DriveYFree && VentoyAPINeedMountY(IsoPath))
 752     {
 753         return VentoyMountY(Handle);
 754     }
 755     else
 756     {
 757         return VentoyMountAnywhere(Handle);
 758     }
 759 }
 760
 761 int VentoyMountISOByAPI(const char *IsoPath)
 762 {
 763     int i;
 764     HANDLE Handle;
 765     DWORD Status;
 766     WCHAR wFilePath[512] = { 0 };
 767     VIRTUAL_STORAGE_TYPE StorageType;
 768     OPEN_VIRTUAL_DISK_PARAMETERS OpenParameters;
 769
 770     Log("VentoyMountISOByAPI <%s>", IsoPath);
 771
 772     if (IsUTF8Encode(IsoPath))
 773     {
 774         Log("This is UTF8 encoding");
 775         MultiByteToWideChar(CP_UTF8, 0, IsoPath, (int)strlen(IsoPath), wFilePath, (int)(sizeof(wFilePath) / sizeof(WCHAR)));
 776     }
 777     else
 778     {
 779         Log("This is ANSI encoding");
 780         MultiByteToWideChar(CP_ACP, 0, IsoPath, (int)strlen(IsoPath), wFilePath, (int)(sizeof(wFilePath) / sizeof(WCHAR)));
 781     }
 782
 783     memset(&StorageType, 0, sizeof(StorageType));
 784     memset(&OpenParameters, 0, sizeof(OpenParameters));
 785
 786     OpenParameters.Version = OPEN_VIRTUAL_DISK_VERSION_1;
 787
 788     for (i = 0; i < 10; i++)
 789     {
 790         Status = OpenVirtualDisk(&StorageType, wFilePath, VIRTUAL_DISK_ACCESS_READ, 0, &OpenParameters, &Handle);
 791         if (ERROR_FILE_NOT_FOUND == Status || ERROR_PATH_NOT_FOUND == Status)
 792         {
 793             Log("OpenVirtualDisk ErrorCode:%u, now wait and retry...", Status);
 794             Sleep(1000);
 795         }
 796         else
 797         {
 798             if (ERROR_SUCCESS == Status)
 799             {
 800                 Log("OpenVirtualDisk success");
 801             }
 802             else if (ERROR_VIRTDISK_PROVIDER_NOT_FOUND == Status)
 803             {
 804                 Log("VirtualDisk for ISO file is not supported in current system");
 805             }
 806             else
 807             {
 808                 Log("Failed to open virtual disk ErrorCode:%u", Status);
 809             }
 810             break;
 811         }
 812     }
 813
 814     if (Status != ERROR_SUCCESS)
 815     {
 816         return 1;
 817     }
 818
 819     Log("OpenVirtualDisk success");
 820
 821     Status = VentoyAttachVirtualDisk(Handle, IsoPath);
 822     if (Status != ERROR_SUCCESS)
 823     {
 824         Log("Failed to attach virtual disk ErrorCode:%u", Status);
 825         CloseHandle(Handle);
 826         return 1;
 827     }
 828
 829     Log("VentoyAttachVirtualDisk success");
 830
 831     CloseHandle(Handle);
 832     return 0;
 833 }
 834
 835
 836 static HANDLE g_FatPhyDrive;
 837 static UINT64 g_Part2StartSec;
 838
 839 static int CopyFileFromFatDisk(const CHAR* SrcFile, const CHAR *DstFile)
 840 {
 841     int rc = 1;
 842     int size = 0;
 843     char *buf = NULL;
 844     void *flfile = NULL;
 845
 846     Log("CopyFileFromFatDisk (%s)==>(%s)", SrcFile, DstFile);
 847
 848     flfile = fl_fopen(SrcFile, "rb");
 849     if (flfile)
 850     {
 851         fl_fseek(flfile, 0, SEEK_END);
 852         size = (int)fl_ftell(flfile);
 853         fl_fseek(flfile, 0, SEEK_SET);
 854
 855         buf = (char *)malloc(size);
 856         if (buf)
 857         {
 858             fl_fread(buf, 1, size, flfile);
 859
 860             rc = 0;
 861             SaveBuffer2File(DstFile, buf, size);
 862             free(buf);
 863         }
 864
 865         fl_fclose(flfile);
 866     }
 867
 868     return rc;
 869 }
 870
 871 static int VentoyFatDiskRead(uint32 Sector, uint8 *Buffer, uint32 SectorCount)
 872 {
 873     DWORD dwSize;
 874     BOOL bRet;
 875     DWORD ReadSize;
 876     LARGE_INTEGER liCurrentPosition;
 877
 878     liCurrentPosition.QuadPart = Sector + g_Part2StartSec;
 879     liCurrentPosition.QuadPart *= 512;
 880     SetFilePointerEx(g_FatPhyDrive, liCurrentPosition, &liCurrentPosition, FILE_BEGIN);
 881
 882     ReadSize = (DWORD)(SectorCount * 512);
 883
 884     bRet = ReadFile(g_FatPhyDrive, Buffer, ReadSize, &dwSize, NULL);
 885     if (bRet == FALSE || dwSize != ReadSize)
 886     {
 887         Log("ReadFile error bRet:%u WriteSize:%u dwSize:%u ErrCode:%u", bRet, ReadSize, dwSize, GetLastError());
 888     }
 889
 890     return 1;
 891 }
 892
 893 static BOOL Is2K10PE(void)
 894 {
 895     BOOL bRet = FALSE;
 896     FILE *fp = NULL;
 897     CHAR szLine[1024];
 898
 899     fopen_s(&fp, "X:\\Windows\\System32\\PECMD.INI", "r");
 900     if (!fp)
 901     {
 902         return FALSE;
 903     }
 904
 905     memset(szLine, 0, sizeof(szLine));
 906     while (fgets(szLine, sizeof(szLine) - 1, fp))
 907     {
 908         if (strstr(szLine, "2k10\\"))
 909         {
 910             bRet = TRUE;
 911             break;
 912         }
 913     }
 914
 915     fclose(fp);
 916     return bRet;
 917 }
 918
 919 static CHAR GetIMDiskMountLogicalDrive(const char *suffix)
 920 {
 921     CHAR Letter = 'Y';
 922     DWORD Drives;
 923     DWORD Mask = 0x1000000;
 924
 925     // fixed use M as mountpoint for 2K10 PE
 926     if (Is2K10PE())
 927     {
 928         Log("Use M: for 2K10 PE");
 929         return 'M';
 930     }
 931
 932     //fixed use Z as mountpoint for Lenovo Product Recovery
 933     if (strcmp(suffix, "VTLRI") == 0)
 934     {
 935         return 'Z';
 936     }
 937
 938     Drives = GetLogicalDrives();
 939     Log("Drives=0x%x", Drives);
 940
 941     while (Mask)
 942     {
 943         if ((Drives & Mask) == 0)
 944         {
 945             break;
 946         }
 947
 948         Letter--;
 949         Mask >>= 1;
 950     }
 951
 952     return Letter;
 953 }
 954
 955 UINT64 GetVentoyEfiPartStartSector(HANDLE hDrive)
 956 {
 957     BOOL bRet;
 958     DWORD dwSize;
 959     MBR_HEAD MBR;
 960     VTOY_GPT_INFO *pGpt = NULL;
 961     UINT64 StartSector = 0;
 962
 963     SetFilePointer(hDrive, 0, NULL, FILE_BEGIN);
 964
 965     bRet = ReadFile(hDrive, &MBR, sizeof(MBR), &dwSize, NULL);
 966     Log("Read MBR Ret:%u Size:%u code:%u", bRet, dwSize, LASTERR);
 967
 968     if ((!bRet) || (dwSize != sizeof(MBR)))
 969     {
 970         0;
 971     }
 972
 973     if (MBR.PartTbl[0].FsFlag == 0xEE)
 974     {
 975         Log("GPT partition style");
 976
 977         pGpt = malloc(sizeof(VTOY_GPT_INFO));
 978         if (!pGpt)
 979         {
 980             return 0;
 981         }
 982
 983         SetFilePointer(hDrive, 0, NULL, FILE_BEGIN);
 984         bRet = ReadFile(hDrive, pGpt, sizeof(VTOY_GPT_INFO), &dwSize, NULL);
 985         if ((!bRet) || (dwSize != sizeof(VTOY_GPT_INFO)))
 986         {
 987             Log("Failed to read gpt info %d %u %d", bRet, dwSize, LASTERR);
 988             return 0;
 989         }
 990
 991         StartSector = pGpt->PartTbl[1].StartLBA;
 992         free(pGpt);
 993     }
 994     else
 995     {
 996         Log("MBR partition style");
 997         StartSector = MBR.PartTbl[1].StartSectorId;
 998     }
 999
1000     Log("GetVentoyEfiPart StartSector: %llu", StartSector);
1001     return StartSector;
1002 }
1003
1004 static int VentoyCopyImdisk(DWORD PhyDrive, CHAR *ImPath)
1005 {
1006     int rc = 1;
1007     BOOL bRet;
1008     DWORD dwBytes;
1009     HANDLE hDrive;
1010     CHAR PhyPath[MAX_PATH];
1011     GET_LENGTH_INFORMATION LengthInfo;
1012
1013     if (IsFileExist("X:\\Windows\\System32\\imdisk.exe"))
1014     {
1015         Log("imdisk.exe already exist, no need to copy...");
1016         strcpy_s(ImPath, MAX_PATH, "imdisk.exe");
1017         return 0;
1018     }
1019
1020     if (IsFileExist("X:\\Windows\\System32\\ventoy\\imdisk.exe"))
1021     {
1022         Log("imdisk.exe already copied, no need to copy...");
1023         strcpy_s(ImPath, MAX_PATH, "ventoy\\imdisk.exe");
1024         return 0;
1025     }
1026
1027     sprintf_s(PhyPath, sizeof(PhyPath), "\\\\.\\PhysicalDrive%d", PhyDrive);
1028     hDrive = CreateFileA(PhyPath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
1029     if (hDrive == INVALID_HANDLE_VALUE)
1030     {
1031         Log("Could not open the disk<%s>, error:%u", PhyPath, GetLastError());
1032         goto End;
1033     }
1034
1035     bRet = DeviceIoControl(hDrive, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &LengthInfo, sizeof(LengthInfo), &dwBytes, NULL);
1036     if (!bRet)
1037     {
1038         Log("Could not get phy disk %s size, error:%u", PhyPath, GetLastError());
1039         goto End;
1040     }
1041
1042     g_FatPhyDrive = hDrive;
1043     g_Part2StartSec = GetVentoyEfiPartStartSector(hDrive);
1044
1045     Log("Parse FAT fs...");
1046
1047     fl_init();
1048
1049     if (0 == fl_attach_media(VentoyFatDiskRead, NULL))
1050     {
1051         if (g_system_bit == 64)
1052         {
1053             CopyFileFromFatDisk("/ventoy/imdisk/64/imdisk.sys", "ventoy\\imdisk.sys");
1054             CopyFileFromFatDisk("/ventoy/imdisk/64/imdisk.exe", "ventoy\\imdisk.exe");
1055             CopyFileFromFatDisk("/ventoy/imdisk/64/imdisk.cpl", "ventoy\\imdisk.cpl");
1056         }
1057         else
1058         {
1059             CopyFileFromFatDisk("/ventoy/imdisk/32/imdisk.sys", "ventoy\\imdisk.sys");
1060             CopyFileFromFatDisk("/ventoy/imdisk/32/imdisk.exe", "ventoy\\imdisk.exe");
1061             CopyFileFromFatDisk("/ventoy/imdisk/32/imdisk.cpl", "ventoy\\imdisk.cpl");
1062         }
1063
1064         GetCurrentDirectoryA(sizeof(PhyPath), PhyPath);
1065         strcat_s(PhyPath, sizeof(PhyPath), "\\ventoy\\imdisk.sys");
1066
1067         if (LoadNtDriver(PhyPath) == 0)
1068         {
1069             strcpy_s(ImPath, MAX_PATH, "ventoy\\imdisk.exe");
1070             rc = 0;
1071         }
1072     }
1073     fl_shutdown();
1074
1075 End:
1076
1077     SAFE_CLOSE_HANDLE(hDrive);
1078
1079     return rc;
1080 }
1081
1082 static int VentoyRunImdisk(const char *suffix, const char *IsoPath, const char *imdiskexe, const char *opt)
1083 {
1084     CHAR Letter;
1085     CHAR Cmdline[512];
1086     WCHAR CmdlineW[512];
1087     PROCESS_INFORMATION Pi;
1088
1089     Log("VentoyRunImdisk <%s> <%s> <%s> <%s>", suffix, IsoPath, imdiskexe, opt);
1090
1091     Letter = GetIMDiskMountLogicalDrive(suffix);
1092
1093     sprintf_s(Cmdline, sizeof(Cmdline), "%s -a -o %s -f \"%s\" -m %C:", imdiskexe, opt, IsoPath, Letter);
1094     Log("mount iso to %C: use imdisk cmd <%s>", Letter, Cmdline);
1095
1096     if (IsUTF8Encode(IsoPath))
1097     {
1098         STARTUPINFOW Si;
1099         GetStartupInfoW(&Si);
1100         Si.dwFlags |= STARTF_USESHOWWINDOW;
1101         Si.wShowWindow = SW_HIDE;
1102
1103         Utf8ToUtf16(Cmdline, CmdlineW);
1104         CreateProcessW(NULL, CmdlineW, NULL, NULL, FALSE, 0, NULL, NULL, &Si, &Pi);
1105
1106         Log("This is UTF8 encoding");
1107     }
1108     else
1109     {
1110         STARTUPINFOA Si;
1111         GetStartupInfoA(&Si);
1112         Si.dwFlags |= STARTF_USESHOWWINDOW;
1113         Si.wShowWindow = SW_HIDE;
1114
1115         CreateProcessA(NULL, Cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &Si, &Pi);
1116
1117         Log("This is ANSI encoding");
1118     }
1119
1120     Log("Wait for imdisk process ...");
1121     WaitForSingleObject(Pi.hProcess, INFINITE);
1122     Log("imdisk process finished");
1123
1124     return 0;
1125 }
1126
1127 int VentoyMountISOByImdisk(const char *IsoPath, DWORD PhyDrive)
1128 {
1129     int rc = 1;
1130     CHAR ImPath[MAX_PATH];
1131
1132     Log("VentoyMountISOByImdisk %s", IsoPath);
1133
1134     if (0 == VentoyCopyImdisk(PhyDrive, ImPath))
1135     {
1136         VentoyRunImdisk("iso", IsoPath, ImPath, "ro");
1137         rc = 0;
1138     }
1139
1140     return rc;
1141 }
1142
1143 static int GetIsoId(CONST CHAR *IsoPath, IsoId *ids)
1144 {
1145     int i;
1146     int n = 0;
1147     HANDLE hFile;
1148     DWORD dwSize = 0;
1149     BOOL bRet[8];
1150
1151     hFile = CreateFileA(IsoPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
1152     if (hFile == INVALID_HANDLE_VALUE)
1153     {
1154         return 1;
1155     }
1156
1157     SetFilePointer(hFile, 2048 * 16 + 8, NULL, FILE_BEGIN);
1158     bRet[n++] = ReadFile(hFile, ids->SystemId, 32, &dwSize, NULL);
1159
1160     SetFilePointer(hFile, 2048 * 16 + 40, NULL, FILE_BEGIN);
1161     bRet[n++] = ReadFile(hFile, ids->VolumeId, 32, &dwSize, NULL);
1162
1163     SetFilePointer(hFile, 2048 * 16 + 318, NULL, FILE_BEGIN);
1164     bRet[n++] = ReadFile(hFile, ids->PulisherId, 128, &dwSize, NULL);
1165
1166     SetFilePointer(hFile, 2048 * 16 + 446, NULL, FILE_BEGIN);
1167     bRet[n++] = ReadFile(hFile, ids->PreparerId, 128, &dwSize, NULL);
1168
1169     CloseHandle(hFile);
1170
1171
1172     for (i = 0; i < n; i++)
1173     {
1174         if (bRet[i] == FALSE)
1175         {
1176             return 1;
1177         }
1178     }
1179
1180
1181     TrimString(ids->SystemId, FALSE);
1182     TrimString(ids->VolumeId, FALSE);
1183     TrimString(ids->PulisherId, FALSE);
1184     TrimString(ids->PreparerId, FALSE);
1185
1186     Log("ISO ID: System<%s> Volume<%s> Pulisher<%s> Preparer<%s>",
1187         ids->SystemId, ids->VolumeId, ids->PulisherId, ids->PreparerId);
1188
1189     return 0;
1190 }
1191
1192 static int CheckSkipMountIso(CONST CHAR *IsoPath)
1193 {
1194     BOOL InRoot = FALSE;
1195     int slashcnt = 0;
1196     CONST CHAR *p = NULL;
1197     IsoId ID;
1198
1199     // C:\\xxx
1200     for (p = IsoPath; *p; p++)
1201     {
1202         if (*p == '\\' || *p == '/')
1203         {
1204             slashcnt++;
1205         }
1206     }
1207
1208     if (slashcnt == 2)
1209     {
1210         InRoot = TRUE;
1211     }
1212
1213     memset(&ID, 0, sizeof(ID));
1214     if (GetIsoId(IsoPath, &ID))
1215     {
1216         return 0;
1217     }
1218
1219     //Bob.Ombs.Modified.Win10PEx64.iso will auto find ISO file in root, so we can skip the mount
1220     if (InRoot && strcmp(ID.VolumeId, "Modified-Win10PEx64") == 0)
1221     {
1222         return 1;
1223     }
1224
1225     return 0;
1226 }
1227
1228 static int MountIsoFile(CONST CHAR *IsoPath, DWORD PhyDrive)
1229 {
1230     if (CheckSkipMountIso(IsoPath))
1231     {
1232         Log("Skip mount ISO file for <%s>", IsoPath);
1233         return 0;
1234     }
1235
1236     if (IsWindows8OrGreater())
1237     {
1238         Log("This is Windows 8 or latter...");
1239         if (VentoyMountISOByAPI(IsoPath) == 0)
1240         {
1241             Log("Mount iso by API success");
1242             return 0;
1243         }
1244         else
1245         {
1246             Log("Mount iso by API failed, maybe not supported, try imdisk");
1247             return VentoyMountISOByImdisk(IsoPath, PhyDrive);
1248         }
1249     }
1250     else
1251     {
1252         Log("This is before Windows 8 ...");
1253         if (VentoyMountISOByImdisk(IsoPath, PhyDrive) == 0)
1254         {
1255             Log("Mount iso by imdisk success");
1256             return 0;
1257         }
1258         else
1259         {
1260             return VentoyMountISOByAPI(IsoPath);
1261         }
1262     }
1263 }
1264
1265 static int GetPhyDriveByLogicalDrive(int DriveLetter)
1266 {
1267     BOOL Ret;
1268     DWORD dwSize;
1269     HANDLE Handle;
1270     VOLUME_DISK_EXTENTS DiskExtents;
1271     CHAR PhyPath[128];
1272
1273     sprintf_s(PhyPath, sizeof(PhyPath), "\\\\.\\%C:", (CHAR)DriveLetter);
1274
1275     Handle = CreateFileA(PhyPath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
1276     if (Handle == INVALID_HANDLE_VALUE)
1277     {
1278         Log("Could not open the disk<%s>, error:%u", PhyPath, GetLastError());
1279         return -1;
1280     }
1281
1282     Ret = DeviceIoControl(Handle,
1283         IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
1284         NULL,
1285         0,
1286         &DiskExtents,
1287         (DWORD)(sizeof(DiskExtents)),
1288         (LPDWORD)&dwSize,
1289         NULL);
1290
1291     if (!Ret || DiskExtents.NumberOfDiskExtents == 0)
1292     {
1293         Log("DeviceIoControl IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS failed %s, error:%u", PhyPath, GetLastError());
1294         SAFE_CLOSE_HANDLE(Handle);
1295         return -1;
1296     }
1297     SAFE_CLOSE_HANDLE(Handle);
1298
1299     Log("LogicalDrive:%s PhyDrive:%d Offset:%llu ExtentLength:%llu",
1300         PhyPath,
1301         DiskExtents.Extents[0].DiskNumber,
1302         DiskExtents.Extents[0].StartingOffset.QuadPart,
1303         DiskExtents.Extents[0].ExtentLength.QuadPart
1304         );
1305
1306     return (int)DiskExtents.Extents[0].DiskNumber;
1307 }
1308
1309
1310 static int DeleteVentoyPart2MountPoint(DWORD PhyDrive)
1311 {
1312     CHAR Letter = 'A';
1313     DWORD Drives;
1314     DWORD PhyDisk;
1315     CHAR DriveName[] = "?:\\";
1316
1317     Log("DeleteVentoyPart2MountPoint Phy%u ...", PhyDrive);
1318
1319     Drives = GetLogicalDrives();
1320     while (Drives)
1321     {
1322         if ((Drives & 0x01) && IsFileExist("%C:\\ventoy\\ventoy.cpio", Letter))
1323         {
1324             Log("File %C:\\ventoy\\ventoy.cpio exist", Letter);
1325
1326             PhyDisk = GetPhyDriveByLogicalDrive(Letter);
1327             Log("PhyDisk=%u for %C", PhyDisk, Letter);
1328
1329             if (PhyDisk == PhyDrive)
1330             {
1331                 DriveName[0] = Letter;
1332                 DeleteVolumeMountPointA(DriveName);
1333                 return 0;
1334             }
1335         }
1336
1337         Letter++;
1338         Drives >>= 1;
1339     }
1340
1341     return 1;
1342 }
1343
1344 static BOOL check_tar_archive(const char *archive, CHAR *tarName)
1345 {
1346     int len;
1347     int nameLen;
1348     const char *pos = archive;
1349     const char *slash = archive;
1350
1351     while (*pos)
1352     {
1353         if (*pos == '\\' || *pos == '/')
1354         {
1355             slash = pos;
1356         }
1357         pos++;
1358     }
1359
1360     len = (int)strlen(slash);
1361
1362     if (len > 7 && (strncmp(slash + len - 7, ".tar.gz", 7) == 0 || strncmp(slash + len - 7, ".tar.xz", 7) == 0))
1363     {
1364         nameLen = (int)sprintf_s(tarName, MAX_PATH, "X:%s", slash);
1365         tarName[nameLen - 3] = 0;
1366         return TRUE;
1367     }
1368     else if (len > 8 && strncmp(slash + len - 8, ".tar.bz2", 8) == 0)
1369     {
1370         nameLen = (int)sprintf_s(tarName, MAX_PATH, "X:%s", slash);
1371         tarName[nameLen - 4] = 0;
1372         return TRUE;
1373     }
1374     else if (len > 9 && strncmp(slash + len - 9, ".tar.lzma", 9) == 0)
1375     {
1376         nameLen = (int)sprintf_s(tarName, MAX_PATH, "X:%s", slash);
1377         tarName[nameLen - 5] = 0;
1378         return TRUE;
1379     }
1380
1381     return FALSE;
1382 }
1383
1384 static UCHAR *g_unxz_buffer = NULL;
1385 static int g_unxz_len = 0;
1386
1387 static void unxz_error(char *x)
1388 {
1389     Log("%s", x);
1390 }
1391
1392 static int unxz_flush(void *src, unsigned int size)
1393 {
1394     memcpy(g_unxz_buffer + g_unxz_len, src, size);
1395     g_unxz_len += (int)size;
1396
1397     return (int)size;
1398 }
1399
1400 static int DecompressInjectionArchive(const char *archive, DWORD PhyDrive)
1401 {
1402     int rc = 1;
1403     int writelen = 0;
1404     UCHAR *Buffer = NULL;
1405     UCHAR *RawBuffer = NULL;
1406     BOOL bRet;
1407     DWORD dwBytes;
1408     DWORD dwSize;
1409     HANDLE hDrive;
1410     HANDLE hOut;
1411     DWORD flags = CREATE_NO_WINDOW;
1412     CHAR StrBuf[MAX_PATH];
1413     CHAR tarName[MAX_PATH];
1414     STARTUPINFOA Si;
1415     PROCESS_INFORMATION Pi;
1416     PROCESS_INFORMATION NewPi;
1417     GET_LENGTH_INFORMATION LengthInfo;
1418     SECURITY_ATTRIBUTES Sa = { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
1419
1420     Log("DecompressInjectionArchive %s", archive);
1421
1422     sprintf_s(StrBuf, sizeof(StrBuf), "\\\\.\\PhysicalDrive%d", PhyDrive);
1423     hDrive = CreateFileA(StrBuf, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
1424     if (hDrive == INVALID_HANDLE_VALUE)
1425     {
1426         Log("Could not open the disk<%s>, error:%u", StrBuf, GetLastError());
1427         goto End;
1428     }
1429
1430     bRet = DeviceIoControl(hDrive, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &LengthInfo, sizeof(LengthInfo), &dwBytes, NULL);
1431     if (!bRet)
1432     {
1433         Log("Could not get phy disk %s size, error:%u", StrBuf, GetLastError());
1434         goto End;
1435     }
1436
1437     g_FatPhyDrive = hDrive;
1438     g_Part2StartSec = GetVentoyEfiPartStartSector(hDrive);
1439
1440     Log("Parse FAT fs...");
1441
1442     fl_init();
1443
1444     if (0 == fl_attach_media(VentoyFatDiskRead, NULL))
1445     {
1446         if (g_system_bit == 64)
1447         {
1448             CopyFileFromFatDisk("/ventoy/7z/64/7za.xz", "ventoy\\7za.xz");
1449         }
1450         else
1451         {
1452             CopyFileFromFatDisk("/ventoy/7z/32/7za.xz", "ventoy\\7za.xz");
1453         }
1454
1455         ReadWholeFile2Buf("ventoy\\7za.xz", &Buffer, &dwSize);
1456         Log("7za.xz file size:%u", dwSize);
1457
1458         RawBuffer = malloc(SIZE_1MB * 4);
1459         if (RawBuffer)
1460         {
1461             g_unxz_buffer = RawBuffer;
1462             g_unxz_len = 0;
1463             unxz(Buffer, (int)dwSize, NULL, unxz_flush, NULL, &writelen, unxz_error);
1464             if (writelen == (int)dwSize)
1465             {
1466                 Log("Decompress success 7za.xz(%u) ---> 7za.exe(%d)", dwSize, g_unxz_len);
1467             }
1468             else
1469             {
1470                 Log("Decompress failed 7za.xz(%u) ---> 7za.exe(%u)", dwSize, dwSize);
1471             }
1472
1473             SaveBuffer2File("ventoy\\7za.exe", RawBuffer, (DWORD)g_unxz_len);
1474
1475             g_unxz_buffer = NULL;
1476             g_unxz_len = 0;
1477             free(RawBuffer);
1478         }
1479         else
1480         {
1481             Log("Failed to alloc 4MB memory");
1482         }
1483
1484         sprintf_s(StrBuf, sizeof(StrBuf), "ventoy\\7za.exe x -y -aoa -oX:\\ %s", archive);
1485
1486         Log("extract inject to X:");
1487         Log("cmdline:<%s>", StrBuf);
1488
1489         GetStartupInfoA(&Si);
1490
1491         hOut = CreateFileA("ventoy\\7z.log",
1492             FILE_APPEND_DATA,
1493             FILE_SHARE_WRITE | FILE_SHARE_READ,
1494             &Sa,
1495             OPEN_ALWAYS,
1496             FILE_ATTRIBUTE_NORMAL,
1497             NULL);
1498
1499         Si.dwFlags |= STARTF_USESTDHANDLES;
1500
1501         if (hOut != INVALID_HANDLE_VALUE)
1502         {
1503             Si.hStdError = hOut;
1504             Si.hStdOutput = hOut;
1505         }
1506
1507         CreateProcessA(NULL, StrBuf, NULL, NULL, TRUE, flags, NULL, NULL, &Si, &Pi);
1508         WaitForSingleObject(Pi.hProcess, INFINITE);
1509
1510         //
1511         // decompress tar archive, for tar.gz/tar.xz/tar.bz2
1512         //
1513         if (check_tar_archive(archive, tarName))
1514         {
1515             Log("Decompress tar archive...<%s>", tarName);
1516
1517             sprintf_s(StrBuf, sizeof(StrBuf), "ventoy\\7za.exe x -y -aoa -oX:\\ %s", tarName);
1518
1519             CreateProcessA(NULL, StrBuf, NULL, NULL, TRUE, flags, NULL, NULL, &Si, &NewPi);
1520             WaitForSingleObject(NewPi.hProcess, INFINITE);
1521
1522             Log("Now delete %s", tarName);
1523             DeleteFileA(tarName);
1524         }
1525
1526         SAFE_CLOSE_HANDLE(hOut);
1527     }
1528     fl_shutdown();
1529
1530 End:
1531
1532     SAFE_CLOSE_HANDLE(hDrive);
1533
1534     return rc;
1535 }
1536
1537 static int UnattendNeedVarExpand(const char *script)
1538 {
1539     FILE *fp = NULL;
1540     char szLine[4096];
1541
1542     fopen_s(&fp, script, "r");
1543     if (!fp)
1544     {
1545         return 0;
1546     }
1547
1548     szLine[0] = szLine[4095] = 0;
1549
1550     while (fgets(szLine, sizeof(szLine) - 1, fp))
1551     {
1552         if (strstr(szLine, "$$VT_"))
1553         {
1554             fclose(fp);
1555             return 1;
1556         }
1557
1558         szLine[0] = szLine[4095] = 0;
1559     }
1560
1561     fclose(fp);
1562     return 0;
1563 }
1564
1565 static int ExpandSingleVar(VarDiskInfo *pDiskInfo, int DiskNum, const char *var, char *value, int len)
1566 {
1567     int i;
1568     int index = -1;
1569     UINT64 uiDst = 0;
1570     UINT64 uiDelta = 0;
1571     UINT64 uiMaxSize = 0;
1572     UINT64 uiMaxDelta = ULLONG_MAX;
1573
1574     value[0] = 0;
1575
1576     if (strcmp(var, "VT_WINDOWS_DISK_1ST_NONVTOY") == 0)
1577     {
1578         for (i = 0; i < DiskNum; i++)
1579         {
1580             if (pDiskInfo[i].Capacity > 0 && i != g_vtoy_disk_drive)
1581             {
1582                 Log("%s=<PhyDrive%d>", var, i);
1583                 sprintf_s(value, len, "%d", i);
1584                 return 0;
1585             }
1586         }
1587     }
1588     else if (strcmp(var, "VT_WINDOWS_DISK_1ST_NONUSB") == 0)
1589     {
1590         for (i = 0; i < DiskNum; i++)
1591         {
1592             if (pDiskInfo[i].Capacity > 0 && pDiskInfo[i].BusType != BusTypeUsb)
1593             {
1594                 Log("%s=<PhyDrive%d>", var, i);
1595                 sprintf_s(value, len, "%d", i);
1596                 return 0;
1597             }
1598         }
1599     }
1600     else if (strcmp(var, "VT_WINDOWS_DISK_MAX_SIZE") == 0)
1601     {
1602         for (i = 0; i < DiskNum; i++)
1603         {
1604             if (pDiskInfo[i].Capacity > 0 && pDiskInfo[i].Capacity > uiMaxSize)
1605             {
1606                 index = i;
1607                 uiMaxSize = pDiskInfo[i].Capacity;
1608             }
1609         }
1610
1611         Log("%s=<PhyDrive%d>", var, index);
1612         sprintf_s(value, len, "%d", index);
1613     }
1614     else if (strncmp(var, "VT_WINDOWS_DISK_CLOSEST_", 24) == 0)
1615     {
1616         uiDst = strtoul(var + 24, NULL, 10);
1617         uiDst = uiDst * (1024ULL * 1024ULL * 1024ULL);
1618
1619         for (i = 0; i < DiskNum; i++)
1620         {
1621             if (pDiskInfo[i].Capacity == 0)
1622             {
1623                 continue;
1624             }
1625
1626             if (pDiskInfo[i].Capacity > uiDst)
1627             {
1628                 uiDelta = pDiskInfo[i].Capacity - uiDst;
1629             }
1630             else
1631             {
1632                 uiDelta = uiDst - pDiskInfo[i].Capacity;
1633             }
1634
1635             if (uiDelta < uiMaxDelta)
1636             {
1637                 uiMaxDelta = uiDelta;
1638                 index = i;
1639             }
1640         }
1641
1642         Log("%s=<PhyDrive%d>", var, index);
1643         sprintf_s(value, len, "%d", index);
1644     }
1645     else
1646     {
1647         Log("Invalid var name <%s>", var);
1648         sprintf_s(value, len, "$$%s$$", var);
1649     }
1650
1651     if (value[0] == 0)
1652     {
1653         sprintf_s(value, len, "$$%s$$", var);
1654     }
1655
1656     return 0;
1657 }
1658
1659 static int GetRegDwordValue(HKEY Key, LPCSTR SubKey, LPCSTR ValueName, DWORD *pValue)
1660 {
1661     HKEY hKey;
1662     DWORD Type;
1663     DWORD Size;
1664     LSTATUS lRet;
1665     DWORD Value;
1666
1667     lRet = RegOpenKeyExA(Key, SubKey, 0, KEY_QUERY_VALUE, &hKey);
1668     Log("RegOpenKeyExA <%s> Ret:%ld", SubKey, lRet);
1669
1670     if (ERROR_SUCCESS == lRet)
1671     {
1672         Size = sizeof(Value);
1673         lRet = RegQueryValueExA(hKey, ValueName, NULL, &Type, (LPBYTE)&Value, &Size);
1674         Log("RegQueryValueExA <%s> ret:%u  Size:%u Value:%u", ValueName, lRet, Size, Value);
1675
1676         *pValue = Value;
1677         RegCloseKey(hKey);
1678
1679         return 0;
1680     }
1681     else
1682     {
1683         return 1;
1684     }
1685 }
1686
1687 static const CHAR * GetBusTypeString(int Type)
1688 {
1689     switch (Type)
1690     {
1691         case BusTypeUnknown: return "unknown";
1692         case BusTypeScsi: return "SCSI";
1693         case BusTypeAtapi: return "Atapi";
1694         case BusTypeAta: return "ATA";
1695         case BusType1394: return "1394";
1696         case BusTypeSsa: return "SSA";
1697         case BusTypeFibre: return "Fibre";
1698         case BusTypeUsb: return "USB";
1699         case BusTypeRAID: return "RAID";
1700         case BusTypeiScsi: return "iSCSI";
1701         case BusTypeSas: return "SAS";
1702         case BusTypeSata: return "SATA";
1703         case BusTypeSd: return "SD";
1704         case BusTypeMmc: return "MMC";
1705         case BusTypeVirtual: return "Virtual";
1706         case BusTypeFileBackedVirtual: return "FileBackedVirtual";
1707         case BusTypeSpaces: return "Spaces";
1708         case BusTypeNvme: return "Nvme";
1709     }
1710     return "unknown";
1711 }
1712
1713 static int GetHumanReadableGBSize(UINT64 SizeBytes)
1714 {
1715     int i;
1716     int Pow2 = 1;
1717     double Delta;
1718     double GB = SizeBytes * 1.0 / 1000 / 1000 / 1000;
1719
1720     if ((SizeBytes % 1073741824) == 0)
1721     {
1722         return (int)(SizeBytes / 1073741824);
1723     }
1724
1725     for (i = 0; i < 12; i++)
1726     {
1727         if (Pow2 > GB)
1728         {
1729             Delta = (Pow2 - GB) / Pow2;
1730         }
1731         else
1732         {
1733             Delta = (GB - Pow2) / Pow2;
1734         }
1735
1736         if (Delta < 0.05)
1737         {
1738             return Pow2;
1739         }
1740
1741         Pow2 <<= 1;
1742     }
1743
1744     return (int)GB;
1745 }
1746
1747 static int EnumerateAllDisk(VarDiskInfo **ppDiskInfo, int *pDiskNum)
1748 {
1749     int i;
1750     DWORD Value;
1751     int DiskNum = 0;
1752     BOOL  bRet;
1753     DWORD dwBytes;
1754     VarDiskInfo *pDiskInfo = NULL;
1755     HANDLE Handle = INVALID_HANDLE_VALUE;
1756     CHAR PhyDrive[128];
1757     GET_LENGTH_INFORMATION LengthInfo;
1758     STORAGE_PROPERTY_QUERY Query;
1759     STORAGE_DESCRIPTOR_HEADER DevDescHeader;
1760     STORAGE_DEVICE_DESCRIPTOR *pDevDesc;
1761
1762     if (GetRegDwordValue(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services\\disk\\Enum", "Count", &Value) == 0)
1763     {
1764         DiskNum = (int)Value;
1765     }
1766     else
1767     {
1768         Log("Failed to read disk count");
1769         return 1;
1770     }
1771
1772     Log("Current phy disk count:%d", DiskNum);
1773     if (DiskNum <= 0)
1774     {
1775         return 1;
1776     }
1777
1778     pDiskInfo = malloc(DiskNum * sizeof(VarDiskInfo));
1779     if (!pDiskInfo)
1780     {
1781         Log("Failed to alloc");
1782         return 1;
1783     }
1784     memset(pDiskInfo, 0, DiskNum * sizeof(VarDiskInfo));
1785
1786     for (i = 0; i < DiskNum; i++)
1787     {
1788         SAFE_CLOSE_HANDLE(Handle);
1789
1790         safe_sprintf(PhyDrive, "\\\\.\\PhysicalDrive%d", i);
1791         Handle = CreateFileA(PhyDrive, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
1792         Log("Create file Handle:%p %s status:%u", Handle, PhyDrive, LASTERR);
1793
1794         if (Handle == INVALID_HANDLE_VALUE)
1795         {
1796             continue;
1797         }
1798
1799         bRet = DeviceIoControl(Handle,
1800                                IOCTL_DISK_GET_LENGTH_INFO, NULL,
1801                                0,
1802                                &LengthInfo,
1803                                sizeof(LengthInfo),
1804                                &dwBytes,
1805                                NULL);
1806         if (!bRet)
1807         {
1808             Log("DeviceIoControl IOCTL_DISK_GET_LENGTH_INFO failed error:%u", LASTERR);
1809             continue;
1810         }
1811
1812         Log("PHYSICALDRIVE%d size %llu bytes", i, (ULONGLONG)LengthInfo.Length.QuadPart);
1813
1814         Query.PropertyId = StorageDeviceProperty;
1815         Query.QueryType = PropertyStandardQuery;
1816
1817         bRet = DeviceIoControl(Handle,
1818                                IOCTL_STORAGE_QUERY_PROPERTY,
1819                                &Query,
1820                                sizeof(Query),
1821                                &DevDescHeader,
1822                                sizeof(STORAGE_DESCRIPTOR_HEADER),
1823                                &dwBytes,
1824                                NULL);
1825         if (!bRet)
1826         {
1827             Log("DeviceIoControl1 error:%u dwBytes:%u", LASTERR, dwBytes);
1828             continue;
1829         }
1830
1831         if (DevDescHeader.Size < sizeof(STORAGE_DEVICE_DESCRIPTOR))
1832         {
1833             Log("Invalid DevDescHeader.Size:%u", DevDescHeader.Size);
1834             continue;
1835         }
1836
1837         pDevDesc = (STORAGE_DEVICE_DESCRIPTOR *)malloc(DevDescHeader.Size);
1838         if (!pDevDesc)
1839         {
1840             Log("failed to malloc error:%u len:%u", LASTERR, DevDescHeader.Size);
1841             continue;
1842         }
1843
1844         bRet = DeviceIoControl(Handle,
1845                                IOCTL_STORAGE_QUERY_PROPERTY,
1846                                &Query,
1847                                sizeof(Query),
1848                                pDevDesc,
1849                                DevDescHeader.Size,
1850                                &dwBytes,
1851                                NULL);
1852         if (!bRet)
1853         {
1854             Log("DeviceIoControl2 error:%u dwBytes:%u", LASTERR, dwBytes);
1855             free(pDevDesc);
1856             continue;
1857         }
1858
1859         pDiskInfo[i].RemovableMedia = pDevDesc->RemovableMedia;
1860         pDiskInfo[i].BusType = pDevDesc->BusType;
1861         pDiskInfo[i].DeviceType = pDevDesc->DeviceType;
1862         pDiskInfo[i].Capacity = LengthInfo.Length.QuadPart;
1863
1864         if (pDevDesc->VendorIdOffset)
1865         {
1866             safe_strcpy(pDiskInfo[i].VendorId, (char *)pDevDesc + pDevDesc->VendorIdOffset);
1867             TrimString(pDiskInfo[i].VendorId, TRUE);
1868         }
1869
1870         if (pDevDesc->ProductIdOffset)
1871         {
1872             safe_strcpy(pDiskInfo[i].ProductId, (char *)pDevDesc + pDevDesc->ProductIdOffset);
1873             TrimString(pDiskInfo[i].ProductId, TRUE);
1874         }
1875
1876         if (pDevDesc->ProductRevisionOffset)
1877         {
1878             safe_strcpy(pDiskInfo[i].ProductRev, (char *)pDevDesc + pDevDesc->ProductRevisionOffset);
1879             TrimString(pDiskInfo[i].ProductRev, TRUE);
1880         }
1881
1882         if (pDevDesc->SerialNumberOffset)
1883         {
1884             safe_strcpy(pDiskInfo[i].SerialNumber, (char *)pDevDesc + pDevDesc->SerialNumberOffset);
1885             TrimString(pDiskInfo[i].SerialNumber, TRUE);
1886         }
1887
1888         free(pDevDesc);
1889         SAFE_CLOSE_HANDLE(Handle);
1890     }
1891
1892     Log("########## DUMP DISK BEGIN ##########");
1893     for (i = 0; i < DiskNum; i++)
1894     {
1895         Log("PhyDrv:%d BusType:%-4s Removable:%u Size:%dGB(%llu) Name:%s %s",
1896             i, GetBusTypeString(pDiskInfo[i].BusType), pDiskInfo[i].RemovableMedia,
1897             GetHumanReadableGBSize(pDiskInfo[i].Capacity), pDiskInfo[i].Capacity,
1898             pDiskInfo[i].VendorId, pDiskInfo[i].ProductId);
1899     }
1900     Log("Ventoy disk is PhyDvr%d", g_vtoy_disk_drive);
1901     Log("########## DUMP DISK END ##########");
1902
1903     *ppDiskInfo = pDiskInfo;
1904     *pDiskNum = DiskNum;
1905     return 0;
1906 }
1907
1908 static int UnattendVarExpand(const char *script, const char *tmpfile)
1909 {
1910     FILE *fp = NULL;
1911     FILE *fout = NULL;
1912     char *start = NULL;
1913     char *end = NULL;
1914     char szLine[4096];
1915     char szValue[256];
1916     int DiskNum = 0;
1917     VarDiskInfo *pDiskInfo = NULL;
1918
1919     Log("UnattendVarExpand ...");
1920
1921     if (EnumerateAllDisk(&pDiskInfo, &DiskNum))
1922     {
1923         Log("Failed to EnumerateAllDisk");
1924         return 1;
1925     }
1926
1927     fopen_s(&fp, script, "r");
1928     if (!fp)
1929     {
1930         free(pDiskInfo);
1931         return 0;
1932     }
1933
1934     fopen_s(&fout, tmpfile, "w+");
1935     if (!fout)
1936     {
1937         fclose(fp);
1938         free(pDiskInfo);
1939         return 0;
1940     }
1941
1942     szLine[0] = szLine[4095] = 0;
1943
1944     while (fgets(szLine, sizeof(szLine) - 1, fp))
1945     {
1946         start = strstr(szLine, "$$VT_");
1947         if (start)
1948         {
1949             end = strstr(start + 5, "$$");
1950         }
1951
1952         if (start && end)
1953         {
1954             *start = 0;
1955             fprintf(fout, "%s", szLine);
1956
1957             *end = 0;
1958             ExpandSingleVar(pDiskInfo, DiskNum, start + 2, szValue, sizeof(szValue) - 1);
1959             fprintf(fout, "%s", szValue);
1960
1961             fprintf(fout, "%s", end + 2);
1962         }
1963         else
1964         {
1965             fprintf(fout, "%s", szLine);
1966         }
1967
1968         szLine[0] = szLine[4095] = 0;
1969     }
1970
1971     fclose(fp);
1972     fclose(fout);
1973     free(pDiskInfo);
1974     return 0;
1975 }
1976
1977 //#define VAR_DEBUG 1
1978
1979 static int CreateUnattendRegKey(const char *file)
1980 {
1981     DWORD dw;
1982     HKEY hKey;
1983     LSTATUS Ret;
1984
1985 #ifndef VAR_DEBUG
1986     Ret = RegCreateKeyEx(HKEY_LOCAL_MACHINE, "System\\Setup", 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &dw);
1987     if (ERROR_SUCCESS == Ret)
1988     {
1989         Ret = RegSetValueEx(hKey, "UnattendFile", 0, REG_SZ, file, (DWORD)(strlen(file) + 1));
1990     }
1991 #endif
1992
1993     return 0;
1994 }
1995
1996 static int ProcessUnattendedInstallation(const char *script, DWORD PhyDrive)
1997 {
1998     CHAR Letter;
1999     CHAR DrvLetter;
2000     CHAR TmpFile[MAX_PATH];
2001     CHAR CurDir[MAX_PATH];
2002     CHAR ImPath[MAX_PATH];
2003
2004     Log("Copy unattended XML ...");
2005
2006     GetCurrentDirectory(sizeof(CurDir), CurDir);
2007     Letter = CurDir[0];
2008     if ((Letter >= 'A' && Letter <= 'Z') || (Letter >= 'a' && Letter <= 'z'))
2009     {
2010         Log("Current Drive Letter: %C", Letter);
2011     }
2012     else
2013     {
2014         Letter = 'X';
2015     }
2016
2017 #ifdef VAR_DEBUG
2018     sprintf_s(CurDir, sizeof(CurDir), "%C:\\AutounattendXXX.xml", Letter);
2019 #else
2020     sprintf_s(CurDir, sizeof(CurDir), "%C:\\Unattend.xml", Letter);
2021 #endif
2022
2023     if (UnattendNeedVarExpand(script))
2024     {
2025         sprintf_s(TmpFile, sizeof(TmpFile), "%C:\\__Autounattend", Letter);
2026         UnattendVarExpand(script, TmpFile);
2027
2028         Log("Expand Copy file <%s> --> <%s>", script, CurDir);
2029         CopyFileA(TmpFile, CurDir, FALSE);
2030     }
2031     else
2032     {
2033         Log("No var expand copy file <%s> --> <%s>", script, CurDir);
2034         CopyFileA(script, CurDir, FALSE);
2035     }
2036
2037     VentoyCopyImdisk(PhyDrive, ImPath);
2038     DrvLetter = VentoyGetFirstFreeDriveLetter(FALSE);
2039     VentoyProcessRunCmd("%s -a -s 64M -m %C: -p \"/fs:FAT32 /q /y\"", ImPath, DrvLetter);
2040
2041     Sleep(300);
2042
2043     sprintf_s(TmpFile, sizeof(TmpFile), "%C:\\Unattend.xml", DrvLetter);
2044     if (CopyFileA(CurDir, TmpFile, FALSE))
2045     {
2046         DeleteFileA(CurDir);
2047         Log("Move file <%s> ==> <%s>, use the later as unattend XML", CurDir, TmpFile);
2048         CreateUnattendRegKey(TmpFile);
2049     }
2050     else
2051     {
2052         Log("Failed to copy file <%s> ==> <%s>, use OLD", CurDir, TmpFile);
2053         CreateUnattendRegKey(CurDir);
2054     }
2055
2056     return 0;
2057 }
2058
2059 static int VentoyGetFileVersion(const CHAR *FilePath, UINT16 *pMajor, UINT16 *pMinor, UINT16 *pBuild, UINT16 *pRevision)
2060 {
2061     int ret = 1;
2062     DWORD dwHandle;
2063     DWORD dwSize;
2064     UINT VerLen = 0;
2065     CHAR *Buffer = NULL;
2066     VS_FIXEDFILEINFO* VerInfo = NULL;
2067     UINT16 Major, Minor, Build, Revision;
2068
2069     Log("Get file version for <%s>", FilePath);
2070
2071     dwSize = GetFileVersionInfoSizeA(FilePath, &dwHandle);
2072     if (0 == dwSize)
2073     {
2074         Log("Failed to get file version info size: %u", LASTERR);
2075         goto End;
2076     }
2077
2078     Buffer = malloc(dwSize);
2079     if (!Buffer)
2080     {
2081         Log("malloc failed %u", dwSize);
2082         goto End;
2083     }
2084
2085     if (FALSE == GetFileVersionInfoA(FilePath, dwHandle, dwSize, Buffer))
2086     {
2087         Log("Failed to get file version info : %u", LASTERR);
2088         goto End;
2089     }
2090
2091     if (VerQueryValueA(Buffer, "\\", (LPVOID)&VerInfo, &VerLen) && VerLen != 0)
2092     {
2093         if (VerInfo->dwSignature == VS_FFI_SIGNATURE)
2094         {
2095             Major = HIWORD(VerInfo->dwFileVersionMS);
2096             Minor = LOWORD(VerInfo->dwFileVersionMS);
2097             Build = HIWORD(VerInfo->dwFileVersionLS);
2098             Revision = LOWORD(VerInfo->dwFileVersionLS);
2099
2100             Log("FileVersionze: <%u %u %u %u>", Major, Minor, Build, Revision);
2101
2102             if (Major == 10 && Build > 20000)
2103             {
2104                 Major = 11;
2105             }
2106
2107             if (pMajor)
2108             {
2109                 *pMajor = Major;
2110             }
2111             if (pMinor)
2112             {
2113                 *pMinor = Minor;
2114             }
2115             if (pBuild)
2116             {
2117                 *pBuild = Build;
2118             }
2119             if (pRevision)
2120             {
2121                 *pRevision = Revision;
2122             }
2123
2124             ret = 0;
2125         }
2126         else
2127         {
2128             Log("Invalid verinfo signature 0x%x", VerInfo->dwSignature);
2129         }
2130     }
2131     else
2132     {
2133         Log("VerQueryValueA failed %u", LASTERR);
2134     }
2135
2136 End:
2137     if (Buffer)
2138     {
2139         free(Buffer);
2140     }
2141
2142     return ret;
2143 }
2144
2145 static BOOL VentoyIsNeedBypass(const char *isofile, const char MntLetter)
2146 {
2147     UINT16 Major;
2148     BOOL bRet = FALSE;
2149     CHAR CheckFile[MAX_PATH];
2150
2151     if (FALSE == IsFileExist("%C:\\sources\\install.wim", MntLetter) &&
2152         FALSE == IsFileExist("%C:\\sources\\install.esd", MntLetter))
2153     {
2154         Log("install.wim/install.esd not exist, this is not a windows install media.");
2155         goto End;
2156     }
2157
2158     if (FALSE == IsFileExist("%C:\\sources\\boot.wim", MntLetter))
2159     {
2160         Log("boot.wim not exist, this is not a windows install media.");
2161         goto End;
2162     }
2163
2164     if (IsFileExist("%C:\\sources\\compatresources.dll", MntLetter))
2165     {
2166         sprintf_s(CheckFile, sizeof(CheckFile), "%C:\\sources\\compatresources.dll", MntLetter);
2167     }
2168     else if (IsFileExist("%C:\\setup.exe", MntLetter))
2169     {
2170         sprintf_s(CheckFile, sizeof(CheckFile), "%C:\\setup.exe", MntLetter);
2171     }
2172     else if (IsFileExist("X:\\setup.exe"))
2173     {
2174         sprintf_s(CheckFile, sizeof(CheckFile), "X:\\setup.exe");
2175     }
2176     else
2177     {
2178         Log("No Check file found");
2179         goto End;
2180     }
2181
2182     if (VentoyGetFileVersion(CheckFile, &Major, NULL, NULL, NULL))
2183     {
2184         goto End;
2185     }
2186
2187     if (Major >= 11)
2188     {
2189         Log("Enable for Windows 11 %u", Major);
2190         bRet = TRUE;
2191     }
2192     else
2193     {
2194         Log("This is not Windows 11, not need to bypass.", Major);
2195     }
2196
2197 End:
2198     return bRet;
2199 }
2200
2201 static int Windows11Bypass(const char *isofile, const char MntLetter, UINT8 Check, UINT8 NRO)
2202 {
2203     int Ret = 1;
2204     HKEY hKey = NULL;
2205     HKEY hSubKey = NULL;
2206     LSTATUS Status;
2207     DWORD dwValue;
2208     DWORD dwSize;
2209
2210     Log("Windows11Bypass for <%s> %C: Check:%u NRO:%u", isofile, MntLetter, Check, NRO);
2211
2212     if (!VentoyIsNeedBypass(isofile, MntLetter))
2213     {
2214         goto End;
2215     }
2216
2217     //Now we really need to bypass windows 11 check. create registry
2218
2219     if (Check)
2220     {
2221         Status = RegCreateKeyExA(HKEY_LOCAL_MACHINE, "System\\Setup", 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &dwSize);
2222         if (ERROR_SUCCESS != Status)
2223         {
2224             Log("Failed to create reg key System\\Setup %u %u", LASTERR, Status);
2225             goto End;
2226         }
2227
2228         Status = RegCreateKeyExA(hKey, "LabConfig", 0, NULL, 0, KEY_SET_VALUE | KEY_QUERY_VALUE | KEY_CREATE_SUB_KEY, NULL, &hSubKey, &dwSize);
2229         if (ERROR_SUCCESS != Status)
2230         {
2231             Log("Failed to create LabConfig reg  %u %u", LASTERR, Status);
2232             goto End;
2233         }
2234
2235         //set reg value
2236         Status += RegSetValueExA(hSubKey, "BypassRAMCheck", 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(DWORD));
2237         Status += RegSetValueExA(hSubKey, "BypassTPMCheck", 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(DWORD));
2238         Status += RegSetValueExA(hSubKey, "BypassSecureBootCheck", 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(DWORD));
2239         Status += RegSetValueExA(hSubKey, "BypassCPUCheck", 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(DWORD));
2240
2241         Log("Create bypass check registry %s %u", (Status == ERROR_SUCCESS) ? "SUCCESS" : "FAILED", Status);
2242     }
2243
2244
2245     if (NRO)
2246     {
2247         Status = RegCreateKeyExA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion", 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &dwSize);
2248         if (ERROR_SUCCESS != Status)
2249         {
2250             Log("Failed to create reg key SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\OOBE %u %u", LASTERR, Status);
2251             goto End;
2252         }
2253
2254         Status = RegCreateKeyExA(hKey, "OOBE", 0, NULL, 0, KEY_SET_VALUE | KEY_QUERY_VALUE | KEY_CREATE_SUB_KEY, NULL, &hSubKey, &dwSize);
2255         if (ERROR_SUCCESS != Status)
2256         {
2257             Log("Failed to create OOBE reg  %u %u", LASTERR, Status);
2258             goto End;
2259         }
2260
2261         Status += RegSetValueExA(hSubKey, "BypassNRO", 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(DWORD));
2262         Log("Create BypassNRO registry %s %u", (Status == ERROR_SUCCESS) ? "SUCCESS" : "FAILED", Status);
2263     }
2264
2265
2266     Ret = 0;
2267
2268 End:
2269
2270     return Ret;
2271 }
2272
2273 static BOOL CheckVentoyDisk(DWORD DiskNum)
2274 {
2275     DWORD dwSize = 0;
2276     CHAR PhyPath[128];
2277     UINT8 SectorBuf[512];
2278     HANDLE Handle;
2279     UINT8 check[8] = { 0x56, 0x54, 0x00, 0x47, 0x65, 0x00, 0x48, 0x44 };
2280
2281     sprintf_s(PhyPath, sizeof(PhyPath), "\\\\.\\PhysicalDrive%d", DiskNum);
2282     Handle = CreateFileA(PhyPath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
2283     if (Handle == INVALID_HANDLE_VALUE)
2284     {
2285         Log("Could not open the disk<%s>, error:%u", PhyPath, GetLastError());
2286         return FALSE;
2287     }
2288
2289     if (!ReadFile(Handle, SectorBuf, sizeof(SectorBuf), &dwSize, NULL))
2290     {
2291         Log("ReadFile failed, dwSize:%u  error:%u", dwSize, GetLastError());
2292         CloseHandle(Handle);
2293         return FALSE;
2294     }
2295
2296     CloseHandle(Handle);
2297
2298     if (memcmp(SectorBuf + 0x190, check, 8) == 0)
2299     {
2300         return TRUE;
2301     }
2302
2303     return FALSE;
2304 }
2305
2306 static BOOL VentoyIsLenovoRecovery(CHAR *IsoPath, CHAR *VTLRIPath)
2307 {
2308     int n;
2309     int UTF8 = 0;
2310     HANDLE hFile;
2311     DWORD Attr;
2312     WCHAR FilePathW[MAX_PATH];
2313
2314     UTF8 = IsUTF8Encode(IsoPath);
2315
2316     if (UTF8)
2317     {
2318         Utf8ToUtf16(IsoPath, FilePathW);
2319
2320         n = (int)wcslen(FilePathW);
2321         if (n > 4 && _wcsicmp(FilePathW + n - 4, L".iso") == 0)
2322         {
2323             FilePathW[n - 3] = L'V';
2324             FilePathW[n - 2] = L'T';
2325             FilePathW[n - 1] = L'L';
2326             FilePathW[n - 0] = L'R';
2327             FilePathW[n + 1] = L'I';
2328             FilePathW[n + 2] = 0;
2329
2330             hFile = CreateFileW(FilePathW, FILE_READ_EA, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
2331             if (hFile != INVALID_HANDLE_VALUE)
2332             {
2333                 CloseHandle(hFile);
2334                 Attr = GetFileAttributesW(FilePathW);
2335
2336                 if ((Attr & FILE_ATTRIBUTE_DIRECTORY) == 0)
2337                 {
2338                     Utf16ToUtf8(FilePathW, VTLRIPath);
2339                     return TRUE;
2340                 }
2341             }
2342         }
2343     }
2344     else
2345     {
2346         n = (int)strlen(IsoPath);
2347         if (n > 4 && _stricmp(IsoPath + n - 4, ".iso") == 0)
2348         {
2349             IsoPath[n - 4] = 0;
2350             sprintf_s(VTLRIPath, MAX_PATH, "%s.VTLRI", IsoPath);
2351             IsoPath[n - 4] = '.';
2352
2353             if (IsFileExist(VTLRIPath))
2354             {
2355                 return TRUE;
2356             }
2357         }
2358     }
2359
2360     return FALSE;
2361 }
2362
2363 static int MountVTLRI(CHAR *ImgPath, DWORD PhyDrive)
2364 {
2365     STARTUPINFOA Si;
2366     PROCESS_INFORMATION Pi;
2367     CHAR Cmdline[256];
2368     CHAR ImDiskPath[256];
2369
2370     Log("MountVTLRI <%s> %u", ImgPath, PhyDrive);
2371
2372     VentoyCopyImdisk(PhyDrive, ImDiskPath);
2373
2374     VentoyRunImdisk("VTLRI", ImgPath, ImDiskPath, "ro,rem");
2375
2376     CopyFileA(g_prog_full_path, "ventoy\\VTLRISRV.exe", FALSE);
2377
2378     sprintf_s(Cmdline, sizeof(Cmdline), "ventoy\\VTLRISRV.exe VTLRI_SRV %C Z", ImgPath[0]);
2379
2380
2381     GetStartupInfoA(&Si);
2382     Si.dwFlags |= STARTF_USESHOWWINDOW;
2383     Si.wShowWindow = SW_HIDE;
2384     CreateProcessA(NULL, Cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &Si, &Pi);
2385
2386     Log("Process cmdline <%s>", Cmdline);
2387
2388     return 0;
2389 }
2390
2391 static int VentoyHook(ventoy_os_param *param)
2392 {
2393     int i;
2394     int rc;
2395     BOOL find = FALSE;
2396     BOOL vtoyfind = FALSE;
2397     CHAR Letter;
2398     CHAR MntLetter;
2399     CHAR VtoyLetter;
2400     DWORD Drives;
2401     DWORD NewDrives;
2402     DWORD VtoyDiskNum;
2403     UINT32 DiskSig;
2404     UINT32 VtoySig;
2405     DISK_EXTENT DiskExtent;
2406     DISK_EXTENT VtoyDiskExtent;
2407     UINT8 UUID[16];
2408     CHAR IsoPath[MAX_PATH];
2409     CHAR VTLRIPath[MAX_PATH];
2410
2411     Log("VentoyHook Path:<%s>", param->vtoy_img_path);
2412
2413     if (IsUTF8Encode(param->vtoy_img_path))
2414     {
2415         Log("This file is UTF8 encoding");
2416     }
2417
2418     for (i = 0; i < 5; i++)
2419     {
2420         Letter = 'A';
2421         Drives = GetLogicalDrives();
2422         Log("Logic Drives: 0x%x", Drives);
2423
2424         while (Drives)
2425         {
2426             if (Drives & 0x01)
2427             {
2428                 sprintf_s(IsoPath, sizeof(IsoPath), "%C:\\%s", Letter, param->vtoy_img_path);
2429                 if (IsFileExist("%s", IsoPath))
2430                 {
2431                     Log("File exist under %C:", Letter);
2432                     memset(UUID, 0, sizeof(UUID));
2433                     memset(&DiskExtent, 0, sizeof(DiskExtent));
2434                     if (GetPhyDiskUUID(Letter, UUID, NULL, &DiskExtent) == 0)
2435                     {
2436                         if (memcmp(UUID, param->vtoy_disk_guid, 16) == 0)
2437                         {
2438                             Log("Disk UUID match");
2439                             find = TRUE;
2440                             break;
2441                         }
2442                     }
2443                 }
2444                 else
2445                 {
2446                     Log("File NOT exist under %C:", Letter);
2447                 }
2448             }
2449
2450             Drives >>= 1;
2451             Letter++;
2452         }
2453
2454         if (find)
2455         {
2456             break;
2457         }
2458         else
2459         {
2460             Log("Now wait and retry ...");
2461             Sleep(1000);
2462         }
2463     }
2464
2465     if (find == FALSE)
2466     {
2467         Log("Failed to find ISO file");
2468         return 1;
2469     }
2470
2471     Log("Find ISO file <%s>", IsoPath);
2472
2473     //Find VtoyLetter in Vlnk Mode
2474     if (g_os_param_reserved[6] == 1)
2475     {
2476         memcpy(&VtoySig, g_os_param_reserved + 7, 4);
2477         for (i = 0; i < 5; i++)
2478         {
2479             VtoyLetter = 'A';
2480             Drives = GetLogicalDrives();
2481             Log("Logic Drives: 0x%x  VentoySig:%08X", Drives, VtoySig);
2482
2483             while (Drives)
2484             {
2485                 if (Drives & 0x01)
2486                 {
2487                     memset(UUID, 0, sizeof(UUID));
2488                     memset(&VtoyDiskExtent, 0, sizeof(VtoyDiskExtent));
2489                     DiskSig = 0;
2490                     if (GetPhyDiskUUID(VtoyLetter, UUID, &DiskSig, &VtoyDiskExtent) == 0)
2491                     {
2492                         Log("DiskSig=%08X PartStart=%lld", DiskSig, VtoyDiskExtent.StartingOffset.QuadPart);
2493                         if (DiskSig == VtoySig && VtoyDiskExtent.StartingOffset.QuadPart == SIZE_1MB)
2494                         {
2495                             Log("Ventoy Disk Sig match");
2496                             vtoyfind = TRUE;
2497                             break;
2498                         }
2499                     }
2500                 }
2501
2502                 Drives >>= 1;
2503                 VtoyLetter++;
2504             }
2505
2506             if (vtoyfind)
2507             {
2508                 Log("Find Ventoy Letter: %C", VtoyLetter);
2509                 break;
2510             }
2511             else
2512             {
2513                 Log("Now wait and retry ...");
2514                 Sleep(1000);
2515             }
2516         }
2517
2518         if (vtoyfind == FALSE)
2519         {
2520             Log("Failed to find ventoy disk");
2521             return 1;
2522         }
2523
2524         VtoyDiskNum = VtoyDiskExtent.DiskNumber;
2525     }
2526     else
2527     {
2528         VtoyLetter = Letter;
2529         Log("No vlnk mode %C", Letter);
2530
2531         VtoyDiskNum = DiskExtent.DiskNumber;
2532     }
2533
2534     if (CheckVentoyDisk(VtoyDiskNum))
2535     {
2536         Log("Disk check OK %C: %u", VtoyLetter, VtoyDiskNum);
2537     }
2538     else
2539     {
2540         Log("Failed to check ventoy disk %u", VtoyDiskNum);
2541         return 1;
2542     }
2543
2544     g_vtoy_disk_drive = VtoyDiskNum;
2545
2546     Drives = GetLogicalDrives();
2547     Log("Drives before mount: 0x%x", Drives);
2548
2549     if (VentoyIsLenovoRecovery(IsoPath, VTLRIPath))
2550     {
2551         Log("This is lenovo recovery image, mount VTLRI file.");
2552         rc = MountVTLRI(VTLRIPath, VtoyDiskNum);
2553     }
2554     else
2555     {
2556         Log("This is normal image, mount ISO file.");
2557         rc = MountIsoFile(IsoPath, VtoyDiskNum);
2558     }
2559
2560     NewDrives = GetLogicalDrives();
2561     Log("Drives after mount: 0x%x (0x%x)", NewDrives, (NewDrives ^ Drives));
2562
2563     MntLetter = 'A';
2564     NewDrives = (NewDrives ^ Drives);
2565     while (NewDrives)
2566     {
2567         if (NewDrives & 0x01)
2568         {
2569             if ((NewDrives >> 1) == 0)
2570             {
2571                 Log("The ISO file is mounted at %C:", MntLetter);
2572             }
2573             else
2574             {
2575                 Log("Maybe the ISO file is mounted at %C:", MntLetter);
2576             }
2577             break;
2578         }
2579
2580         NewDrives >>= 1;
2581         MntLetter++;
2582     }
2583
2584     Log("Mount ISO FILE: %s", rc == 0 ? "SUCCESS" : "FAILED");
2585
2586     //Windows 11 bypass check
2587     if (g_windows_data.windows11_bypass_check == 1 || g_windows_data.windows11_bypass_nro == 1)
2588     {
2589         Windows11Bypass(IsoPath, MntLetter, g_windows_data.windows11_bypass_check, g_windows_data.windows11_bypass_nro);
2590     }
2591
2592     // for protect
2593     rc = DeleteVentoyPart2MountPoint(VtoyDiskNum);
2594     Log("Delete ventoy mountpoint: %s", rc == 0 ? "SUCCESS" : "NO NEED");
2595
2596     if (g_windows_data.auto_install_script[0])
2597     {
2598         if (IsFileExist("%s", VTOY_AUTO_FILE))
2599         {
2600             Log("use auto install script %s...", VTOY_AUTO_FILE);
2601             ProcessUnattendedInstallation(VTOY_AUTO_FILE, VtoyDiskNum);
2602         }
2603         else
2604         {
2605             Log("auto install script %s not exist", IsoPath);
2606         }
2607     }
2608     else
2609     {
2610         Log("auto install no need");
2611     }
2612
2613     if (g_windows_data.injection_archive[0])
2614     {
2615         sprintf_s(IsoPath, sizeof(IsoPath), "%C:%s", VtoyLetter, g_windows_data.injection_archive);
2616         if (IsFileExist("%s", IsoPath))
2617         {
2618             Log("decompress injection archive %s...", IsoPath);
2619             DecompressInjectionArchive(IsoPath, VtoyDiskNum);
2620
2621             if (IsFileExist("%s", AUTO_RUN_BAT))
2622             {
2623                 HANDLE hOut;
2624                 DWORD flags = CREATE_NO_WINDOW;
2625                 CHAR StrBuf[1024];
2626                 STARTUPINFOA Si;
2627                 PROCESS_INFORMATION Pi;
2628                 SECURITY_ATTRIBUTES Sa = { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
2629
2630                 Log("%s exist, now run it...", AUTO_RUN_BAT);
2631
2632                 GetStartupInfoA(&Si);
2633
2634                 hOut = CreateFileA(AUTO_RUN_LOG,
2635                     FILE_APPEND_DATA,
2636                     FILE_SHARE_WRITE | FILE_SHARE_READ,
2637                     &Sa,
2638                     OPEN_ALWAYS,
2639                     FILE_ATTRIBUTE_NORMAL,
2640                     NULL);
2641
2642                 Si.dwFlags |= STARTF_USESTDHANDLES;
2643                 if (hOut != INVALID_HANDLE_VALUE)
2644                 {
2645                     Si.hStdError = hOut;
2646                     Si.hStdOutput = hOut;
2647                 }
2648
2649                 sprintf_s(IsoPath, sizeof(IsoPath), "%C:\\%s", Letter, param->vtoy_img_path);
2650                 sprintf_s(StrBuf, sizeof(StrBuf), "cmd.exe /c %s \"%s\" %C", AUTO_RUN_BAT, IsoPath, MntLetter);
2651                 CreateProcessA(NULL, StrBuf, NULL, NULL, TRUE, flags, NULL, NULL, &Si, &Pi);
2652                 WaitForSingleObject(Pi.hProcess, INFINITE);
2653
2654                 SAFE_CLOSE_HANDLE(hOut);
2655             }
2656             else
2657             {
2658                 Log("%s not exist...", AUTO_RUN_BAT);
2659             }
2660         }
2661         else
2662         {
2663             Log("injection archive %s not exist", IsoPath);
2664         }
2665     }
2666     else
2667     {
2668         Log("no injection archive found");
2669     }
2670
2671     return 0;
2672 }
2673
2674 static int ExtractWindowsDataFile(char *databuf)
2675 {
2676     int len = 0;
2677     char *filedata = NULL;
2678     ventoy_windows_data *pdata = (ventoy_windows_data *)databuf;
2679
2680     Log("ExtractWindowsDataFile: auto install <%s:%d>", pdata->auto_install_script, pdata->auto_install_len);
2681
2682     filedata = databuf + sizeof(ventoy_windows_data);
2683
2684     if (pdata->auto_install_script[0] && pdata->auto_install_len > 0)
2685     {
2686         SaveBuffer2File(VTOY_AUTO_FILE, filedata, pdata->auto_install_len);
2687         filedata += pdata->auto_install_len;
2688         len = pdata->auto_install_len;
2689     }
2690
2691     return len;
2692 }
2693
2694 static int ventoy_check_create_directory(void)
2695 {
2696     if (IsDirExist("ventoy"))
2697     {
2698         Log("ventoy directory already exist");
2699     }
2700     else
2701     {
2702         Log("ventoy directory not exist, now create it.");
2703         if (!CreateDirectoryA("ventoy", NULL))
2704         {
2705             Log("Failed to create ventoy directory err:%u", GetLastError());
2706             return 1;
2707         }
2708     }
2709
2710     return 0;
2711 }
2712
2713 int VentoyJump(INT argc, CHAR **argv, CHAR *LunchFile)
2714 {
2715     int rc = 1;
2716     int stat = 0;
2717     int exlen = 0;
2718     DWORD Pos;
2719     DWORD PeStart;
2720     DWORD FileSize;
2721     DWORD LockStatus = 0;
2722     BYTE *Buffer = NULL;
2723     CHAR ExeFileName[MAX_PATH];
2724
2725     sprintf_s(ExeFileName, sizeof(ExeFileName), "%s", argv[0]);
2726     if (!IsFileExist("%s", ExeFileName))
2727     {
2728         Log("File %s NOT exist, now try %s.exe", ExeFileName, ExeFileName);
2729         sprintf_s(ExeFileName, sizeof(ExeFileName), "%s.exe", argv[0]);
2730
2731         Log("File %s exist ? %s", ExeFileName, IsFileExist("%s", ExeFileName) ? "YES" : "NO");
2732     }
2733
2734     if (ReadWholeFile2Buf(ExeFileName, (void **)&Buffer, &FileSize))
2735     {
2736         goto End;
2737     }
2738
2739     Log("VentoyJump %dbit", g_system_bit);
2740
2741     MUTEX_LOCK(g_vtoyins_mutex);
2742     stat = ventoy_check_create_directory();
2743     MUTEX_UNLOCK(g_vtoyins_mutex);
2744
2745     if (stat != 0)
2746     {
2747         goto End;
2748     }
2749
2750     for (PeStart = 0; PeStart < FileSize; PeStart += 16)
2751     {
2752         if (CheckOsParam((ventoy_os_param *)(Buffer + PeStart)) &&
2753             CheckPeHead(Buffer, FileSize, PeStart + sizeof(ventoy_os_param)))
2754         {
2755             Log("Find os pararm at %u", PeStart);
2756
2757             memcpy(&g_os_param, Buffer + PeStart, sizeof(ventoy_os_param));
2758             memcpy(&g_windows_data, Buffer + PeStart + sizeof(ventoy_os_param), sizeof(ventoy_windows_data));
2759             exlen = ExtractWindowsDataFile(Buffer + PeStart + sizeof(ventoy_os_param));
2760             memcpy(g_os_param_reserved, g_os_param.vtoy_reserved, sizeof(g_os_param_reserved));
2761
2762             if (g_os_param_reserved[0] == 1)
2763             {
2764                 Log("break here for debug .....");
2765                 goto End;
2766             }
2767
2768             // convert / to \\
2769             for (Pos = 0; Pos < sizeof(g_os_param.vtoy_img_path) && g_os_param.vtoy_img_path[Pos]; Pos++)
2770             {
2771                 if (g_os_param.vtoy_img_path[Pos] == '/')
2772                 {
2773                     g_os_param.vtoy_img_path[Pos] = '\\';
2774                 }
2775             }
2776
2777             PeStart += sizeof(ventoy_os_param) + sizeof(ventoy_windows_data) + exlen;
2778             sprintf_s(LunchFile, MAX_PATH, "ventoy\\%s", GetFileNameInPath(ExeFileName));
2779
2780             MUTEX_LOCK(g_vtoyins_mutex);
2781             if (IsFileExist("%s", LunchFile))
2782             {
2783                 Log("vtoyjump multiple call ...");
2784                 rc = 0;
2785                 MUTEX_UNLOCK(g_vtoyins_mutex);
2786                 goto End;
2787             }
2788
2789             SaveBuffer2File(LunchFile, Buffer + PeStart, FileSize - PeStart);
2790             MUTEX_UNLOCK(g_vtoyins_mutex);
2791
2792             break;
2793         }
2794     }
2795
2796     if (PeStart >= FileSize)
2797     {
2798         Log("OS param not found");
2799         goto End;
2800     }
2801
2802     if (g_os_param_reserved[0] == 2)
2803     {
2804         Log("skip hook for debug .....");
2805         rc = 0;
2806         goto End;
2807     }
2808
2809     rc = VentoyHook(&g_os_param);
2810
2811 End:
2812
2813     if (Buffer)
2814     {
2815         free(Buffer);
2816     }
2817
2818     return rc;
2819 }
2820
2821
2822 int real_main(int argc, char **argv)
2823 {
2824     int i = 0;
2825     int rc = 0;
2826     CHAR NewFile[MAX_PATH];
2827     CHAR LunchFile[MAX_PATH];
2828     CHAR CallParam[1024] = { 0 };
2829     STARTUPINFOA Si;
2830     PROCESS_INFORMATION Pi;
2831
2832     Log("#### real_main #### argc = %d", argc);
2833     Log("program full path: <%s>", g_prog_full_path);
2834     Log("program dir: <%s>", g_prog_dir);
2835     Log("program name: <%s>", g_prog_name);
2836
2837     Log("argc = %d", argc);
2838     for (i = 0; i < argc; i++)
2839     {
2840         Log("argv[%d]=<%s>", i, argv[i]);
2841         if (i > 0)
2842         {
2843             strcat_s(CallParam, sizeof(CallParam), " ");
2844             strcat_s(CallParam, sizeof(CallParam), argv[i]);
2845         }
2846     }
2847
2848     GetStartupInfoA(&Si);
2849     memset(LunchFile, 0, sizeof(LunchFile));
2850
2851     rc = VentoyJump(argc, argv, LunchFile);
2852
2853     Log("LunchFile=<%s> CallParam=<%s>", LunchFile, CallParam);
2854
2855     if (_stricmp(g_prog_name, "winpeshl.exe") != 0 && IsFileExist("ventoy\\%s", g_prog_name))
2856     {
2857         sprintf_s(NewFile, sizeof(NewFile), "%s\\VTOYJUMP.EXE", g_prog_dir);
2858         MoveFileA(g_prog_full_path, NewFile);
2859         Log("Move <%s> to <%s>", g_prog_full_path, NewFile);
2860
2861         sprintf_s(NewFile, sizeof(NewFile), "ventoy\\%s", g_prog_name);
2862         CopyFileA(NewFile, g_prog_full_path, TRUE);
2863         Log("Copy <%s> to <%s>", NewFile, g_prog_full_path);
2864
2865         sprintf_s(LunchFile, sizeof(LunchFile), "%s", g_prog_full_path);
2866         Log("Final lunchFile is <%s>", LunchFile);
2867     }
2868     else
2869     {
2870         Log("We don't need to recover original <%s>", g_prog_name);
2871     }
2872
2873     if (g_os_param_reserved[0] == 3)
2874     {
2875         Log("Open log for debug ...");
2876         sprintf_s(LunchFile, sizeof(LunchFile), "%s", "notepad.exe ventoy.log");
2877     }
2878     else
2879     {
2880         if (CallParam[0])
2881         {
2882             strcat_s(LunchFile, sizeof(LunchFile), CallParam);
2883         }
2884         else if (NULL == strstr(LunchFile, "setup.exe"))
2885         {
2886             Log("Not setup.exe, hide windows.");
2887             Si.dwFlags |= STARTF_USESHOWWINDOW;
2888             Si.wShowWindow = SW_HIDE;
2889         }
2890
2891         Log("Ventoy jump %s ...", rc == 0 ? "success" : "failed");
2892     }
2893
2894     Log("Now launch <%s> ...", LunchFile);
2895
2896     if (g_os_param_reserved[0] == 4)
2897     {
2898         Log("Open cmd for debug ...");
2899         Si.dwFlags |= STARTF_USESHOWWINDOW;
2900         Si.wShowWindow = SW_NORMAL;
2901         sprintf_s(LunchFile, sizeof(LunchFile), "%s", "cmd.exe");
2902     }
2903
2904     Log("Backup log at this point");
2905     CopyFileA(LOG_FILE, "X:\\Windows\\ventoy.backup", TRUE);
2906
2907     CreateProcessA(NULL, LunchFile, NULL, NULL, FALSE, 0, NULL, NULL, &Si, &Pi);
2908
2909     for (i = 0; rc && i < 1800; i++)
2910     {
2911         Log("Ventoy hook failed, now wait and retry ...");
2912         Sleep(1000);
2913         rc = VentoyHook(&g_os_param);
2914     }
2915
2916     Log("Wait process...");
2917     WaitForSingleObject(Pi.hProcess, INFINITE);
2918
2919     Log("vtoyjump finished");
2920     return 0;
2921 }
2922
2923 static void VentoyToUpper(CHAR *str)
2924 {
2925     int i;
2926     for (i = 0; str[i]; i++)
2927     {
2928         str[i] = (CHAR)toupper(str[i]);
2929     }
2930 }
2931
2932 static int vtoy_remove_duplicate_file(char *File)
2933 {
2934     CHAR szCmd[MAX_PATH];
2935     CHAR NewFile[MAX_PATH];
2936     STARTUPINFOA Si;
2937     PROCESS_INFORMATION Pi;
2938
2939     Log("<1> Copy New file", File);
2940     sprintf_s(NewFile, sizeof(NewFile), "%s_NEW", File);
2941     CopyFileA(File, NewFile, FALSE);
2942
2943     Log("<2> Remove file <%s>", File);
2944     GetStartupInfoA(&Si);
2945     Si.dwFlags |= STARTF_USESHOWWINDOW;
2946     Si.wShowWindow = SW_HIDE;
2947     sprintf_s(szCmd, sizeof(szCmd), "cmd.exe /c del /F /Q %s", File);
2948     CreateProcessA(NULL, szCmd, NULL, NULL, FALSE, 0, NULL, NULL, &Si, &Pi);
2949     WaitForSingleObject(Pi.hProcess, INFINITE);
2950
2951     Log("<3> Copy back file <%s>", File);
2952     MoveFileA(NewFile, File);
2953
2954     return 0;
2955 }
2956
2957 static int VTLRI_ServiceMain(int argc, char **argv)
2958 {
2959     int n = 0;
2960     DWORD Err;
2961     BOOL bRet = TRUE;
2962     CHAR Drive[16];
2963     CHAR FsType[64];
2964     CHAR Cmdline[256];
2965     PROCESS_INFORMATION Pi;
2966     STARTUPINFOA Si;
2967
2968     //XXX.exe VTLRI_SRV D Z
2969     Log("VTLRI_ServiceMain start %s %s %s ...", argv[0], argv[1], argv[2]);
2970
2971     sprintf_s(Drive, sizeof(Drive), "%C:\\", argv[2][0]);
2972
2973     while (n < 3)
2974     {
2975         bRet = GetVolumeInformationA(Drive, NULL, 0, NULL, NULL, NULL, FsType, sizeof(FsType));
2976         if (bRet)
2977         {
2978             Sleep(400);
2979         }
2980         else
2981         {
2982             Err = LASTERR;
2983             if (Err == ERROR_PATH_NOT_FOUND)
2984             {
2985                 Log("%s not found", Drive);
2986                 n++;
2987             }
2988         }
2989     }
2990
2991     sprintf_s(Cmdline, sizeof(Cmdline), "ventoy\\imdisk.exe -d -m %C:", argv[3][0]);
2992     Log("Remove disk by <%s>", Cmdline);
2993
2994     GetStartupInfoA(&Si);
2995     Si.dwFlags |= STARTF_USESHOWWINDOW;
2996     Si.wShowWindow = SW_HIDE;
2997
2998     CreateProcessA(NULL, Cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &Si, &Pi);
2999     WaitForSingleObject(Pi.hProcess, INFINITE);
3000     return 0;
3001 }
3002
3003 int main(int argc, char **argv)
3004 {
3005     int i;
3006     STARTUPINFOA Si;
3007     PROCESS_INFORMATION Pi;
3008     CHAR CurDir[MAX_PATH];
3009     CHAR NewArgv0[MAX_PATH];
3010     CHAR CallParam[1024] = { 0 };
3011
3012     g_vtoylog_mutex = CreateMutexA(NULL, FALSE, "VTOYLOG_LOCK");
3013     g_vtoyins_mutex = CreateMutexA(NULL, FALSE, "VTOYINS_LOCK");
3014
3015     Log("######## VentoyJump %dbit ##########", g_system_bit);
3016
3017     if (argc > 1 && strcmp(argv[1], "VTLRI_SRV") == 0)
3018     {
3019         return VTLRI_ServiceMain(argc, argv);
3020     }
3021
3022     GetCurrentDirectoryA(sizeof(CurDir), CurDir);
3023     Log("Current directory is <%s>", CurDir);
3024
3025     GetModuleFileNameA(NULL, g_prog_full_path, MAX_PATH);
3026     split_path_name(g_prog_full_path, g_prog_dir, g_prog_name);
3027
3028     Log("EXE path: <%s> dir:<%s> name:<%s>", g_prog_full_path, g_prog_dir, g_prog_name);
3029
3030     if (IsFileExist(WIMBOOT_FILE))
3031     {
3032         Log("This is wimboot mode ...");
3033         g_wimboot_mode = TRUE;
3034
3035         if (!IsFileExist(WIMBOOT_DONE))
3036         {
3037             vtoy_remove_duplicate_file(g_prog_full_path);
3038             SaveBuffer2File(WIMBOOT_DONE, g_prog_full_path, 1);
3039         }
3040     }
3041     else
3042     {
3043         Log("This is normal mode ...");
3044     }
3045
3046     if (_stricmp(g_prog_name, "WinLogon.exe") == 0)
3047     {
3048         Log("This time is rejump back ...");
3049
3050         strcpy_s(g_prog_full_path, sizeof(g_prog_full_path), argv[1]);
3051         split_path_name(g_prog_full_path, g_prog_dir, g_prog_name);
3052
3053         return real_main(argc - 1, argv + 1);
3054     }
3055     else if (_stricmp(g_prog_name, "PECMD.exe") == 0)
3056     {
3057         strcpy_s(NewArgv0, sizeof(NewArgv0), g_prog_dir);
3058         VentoyToUpper(NewArgv0);
3059
3060         if (NULL == strstr(NewArgv0, "SYSTEM32") && IsFileExist(ORG_PECMD_BK_PATH))
3061         {
3062             Log("Just call original pecmd.exe");
3063             strcpy_s(CallParam, sizeof(CallParam), ORG_PECMD_PATH);
3064         }
3065         else
3066         {
3067             Log("We need to rejump for pecmd ...");
3068
3069             ventoy_check_create_directory();
3070             CopyFileA(g_prog_full_path, "ventoy\\WinLogon.exe", TRUE);
3071
3072             sprintf_s(CallParam, sizeof(CallParam), "ventoy\\WinLogon.exe %s", g_prog_full_path);
3073         }
3074
3075         for (i = 1; i < argc; i++)
3076         {
3077             strcat_s(CallParam, sizeof(CallParam), " ");
3078             strcat_s(CallParam, sizeof(CallParam), argv[i]);
3079         }
3080
3081         Log("Now rejump to <%s> ...", CallParam);
3082         GetStartupInfoA(&Si);
3083         CreateProcessA(NULL, CallParam, NULL, NULL, FALSE, 0, NULL, NULL, &Si, &Pi);
3084
3085         Log("Wait rejump process...");
3086         WaitForSingleObject(Pi.hProcess, INFINITE);
3087         Log("rejump finished");
3088         return 0;
3089     }
3090     else
3091     {
3092         Log("We don't need to rejump ...");
3093
3094         ventoy_check_create_directory();
3095         strcpy_s(NewArgv0, sizeof(NewArgv0), g_prog_full_path);
3096         argv[0] = NewArgv0;
3097
3098         return real_main(argc, argv);
3099     }
3100 }