LinuxGUI/Ventoy2Disk/Core/ventoy_util.c

   1 /******************************************************************************
   2  * ventoy_util.c  ---- ventoy util
   3  * Copyright (c) 2021, longpanda <admin@ventoy.net>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 3 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  17  *
  18  */
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <stdint.h>
  22 #include <string.h>
  23 #include <stdarg.h>
  24 #include <errno.h>
  25 #include <time.h>
  26 #include <unistd.h>
  27 #include <fcntl.h>
  28 #include <sys/types.h>
  29 #include <sys/ioctl.h>
  30 #include <sys/stat.h>
  31 #include <sys/types.h>
  32 #include <sys/mount.h>
  33 #include <linux/fs.h>
  34 #include <dirent.h>
  35 #include <time.h>
  36 #include <ventoy_define.h>
  37 #include <ventoy_util.h>
  38
  39 uint8_t g_mbr_template[512];
  40
  41 void ventoy_gen_preudo_uuid(void *uuid)
  42 {
  43     int i;
  44     int fd;
  45
  46     fd = open("/dev/urandom", O_RDONLY | O_BINARY);
  47     if (fd < 0)
  48     {
  49         srand(time(NULL));
  50         for (i = 0; i < 8; i++)
  51         {
  52             *((uint16_t *)uuid + i) = (uint16_t)(rand() & 0xFFFF);
  53         }
  54     }
  55     else
  56     {
  57         read(fd, uuid, 16);
  58         close(fd);
  59     }
  60 }
  61
  62 uint64_t ventoy_get_human_readable_gb(uint64_t SizeBytes)
  63 {
  64     int i;
  65     int Pow2 = 1;
  66     double Delta;
  67     double GB = SizeBytes * 1.0 / 1000 / 1000 / 1000;
  68
  69     if ((SizeBytes % SIZE_1GB) == 0)
  70     {
  71         return (uint64_t)(SizeBytes / SIZE_1GB);
  72     }
  73
  74     for (i = 0; i < 12; i++)
  75     {
  76         if (Pow2 > GB)
  77         {
  78             Delta = (Pow2 - GB) / Pow2;
  79         }
  80         else
  81         {
  82             Delta = (GB - Pow2) / Pow2;
  83         }
  84
  85         if (Delta < 0.05)
  86         {
  87             return Pow2;
  88         }
  89
  90         Pow2 <<= 1;
  91     }
  92
  93     return (uint64_t)GB;
  94 }
  95
  96
  97 int ventoy_get_sys_file_line(char *buffer, int buflen, const char *fmt, ...)
  98 {
  99     int len;
 100     char c;
 101     char path[256];
 102     va_list arg;
 103
 104     va_start(arg, fmt);
 105     vsnprintf(path, 256, fmt, arg);
 106     va_end(arg);
 107
 108     if (access(path, F_OK) >= 0)
 109     {
 110         FILE *fp = fopen(path, "r");
 111         memset(buffer, 0, buflen);
 112         len = (int)fread(buffer, 1, buflen - 1, fp);
 113         fclose(fp);
 114
 115         while (len > 0)
 116         {
 117             c = buffer[len - 1];
 118             if (c == '\r' || c == '\n' || c == ' ' || c == '\t')
 119             {
 120                 buffer[len - 1] = 0;
 121                 len--;
 122             }
 123             else
 124             {
 125                 break;
 126             }
 127         }
 128
 129         return 0;
 130     }
 131     else
 132     {
 133         vdebug("%s not exist \n", path);
 134         return 1;
 135     }
 136 }
 137
 138 int ventoy_is_disk_mounted(const char *devpath)
 139 {
 140     int len;
 141     int mount = 0;
 142     char line[512];
 143     FILE *fp = NULL;
 144
 145     fp = fopen("/proc/mounts", "r");
 146     if (!fp)
 147     {
 148         return 0;
 149     }
 150
 151     len = (int)strlen(devpath);
 152     while (fgets(line, sizeof(line), fp))
 153     {
 154         if (strncmp(line, devpath, len) == 0)
 155         {
 156             mount = 1;
 157             vdebug("%s mounted <%s>\n", devpath, line);
 158             goto end;
 159         }
 160     }
 161
 162 end:
 163     fclose(fp);
 164     return mount;
 165 }
 166
 167 int ventoy_try_umount_disk(const char *devpath)
 168 {
 169     int rc;
 170     int len;
 171     char line[512];
 172     char *pos1 = NULL;
 173     char *pos2 = NULL;
 174     FILE *fp = NULL;
 175
 176     fp = fopen("/proc/mounts", "r");
 177     if (!fp)
 178     {
 179         return 0;
 180     }
 181
 182     len = (int)strlen(devpath);
 183     while (fgets(line, sizeof(line), fp))
 184     {
 185         if (strncmp(line, devpath, len) == 0)
 186         {
 187             pos1 = strchr(line, ' ');
 188             if (pos1)
 189             {
 190                 pos2 = strchr(pos1 + 1, ' ');
 191                 if (pos2)
 192                 {
 193                     *pos2 = 0;
 194                 }
 195
 196                 rc = umount(pos1 + 1);
 197                 if (rc)
 198                 {
 199                     vdebug("umount %s %s [ failed ] error:%d\n", devpath, pos1 + 1, errno);
 200                 }
 201                 else
 202                 {
 203                     vdebug("umount %s %s [ success ]\n", devpath, pos1 + 1);
 204                 }
 205             }
 206         }
 207     }
 208
 209     fclose(fp);
 210     return 0;
 211 }
 212
 213
 214 int ventoy_read_file_to_buf(const char *FileName, int ExtLen, void **Bufer, int *BufLen)
 215 {
 216     int FileSize;
 217     FILE *fp = NULL;
 218     void *Data = NULL;
 219
 220     fp = fopen(FileName, "rb");
 221     if (fp == NULL)
 222     {
 223         vlog("Failed to open file %s", FileName);
 224         return 1;
 225     }
 226
 227     fseek(fp, 0, SEEK_END);
 228     FileSize = (int)ftell(fp);
 229
 230     Data = malloc(FileSize + ExtLen);
 231     if (!Data)
 232     {
 233         fclose(fp);
 234         return 1;
 235     }
 236
 237     fseek(fp, 0, SEEK_SET);
 238     fread(Data, 1, FileSize, fp);
 239
 240     fclose(fp);
 241
 242     *Bufer = Data;
 243     *BufLen = FileSize;
 244
 245     return 0;
 246 }
 247
 248 const char * ventoy_get_local_version(void)
 249 {
 250     int rc;
 251     int FileSize;
 252     char *Pos = NULL;
 253     char *Buf = NULL;
 254     static char LocalVersion[64] = { 0 };
 255
 256     if (LocalVersion[0] == 0)
 257     {
 258         rc = ventoy_read_file_to_buf("ventoy/version", 1, (void **)&Buf, &FileSize);
 259         if (rc)
 260         {
 261             return "";
 262         }
 263         Buf[FileSize] = 0;
 264
 265         for (Pos = Buf; *Pos; Pos++)
 266         {
 267             if (*Pos == '\r' || *Pos == '\n')
 268             {
 269                 *Pos = 0;
 270                 break;
 271             }
 272         }
 273
 274         scnprintf(LocalVersion, "%s", Buf);
 275         free(Buf);
 276     }
 277
 278     return LocalVersion;
 279 }
 280
 281 int VentoyGetLocalBootImg(MBR_HEAD *pMBR)
 282 {
 283     memcpy(pMBR, g_mbr_template, 512);
 284     return 0;
 285 }
 286
 287 static int VentoyFillProtectMBR(uint64_t DiskSizeBytes, MBR_HEAD *pMBR)
 288 {
 289     ventoy_guid Guid;
 290     uint32_t DiskSignature;
 291     uint64_t DiskSectorCount;
 292
 293     VentoyGetLocalBootImg(pMBR);
 294
 295     ventoy_gen_preudo_uuid(&Guid);
 296
 297     memcpy(&DiskSignature, &Guid, sizeof(uint32_t));
 298
 299     vdebug("Disk signature: 0x%08x\n", DiskSignature);
 300
 301     memcpy(pMBR->BootCode + 0x1B8, &DiskSignature, 4);
 302
 303     DiskSectorCount = DiskSizeBytes / 512 - 1;
 304     if (DiskSectorCount > 0xFFFFFFFF)
 305     {
 306         DiskSectorCount = 0xFFFFFFFF;
 307     }
 308
 309     memset(pMBR->PartTbl, 0, sizeof(pMBR->PartTbl));
 310
 311     pMBR->PartTbl[0].Active = 0x00;
 312     pMBR->PartTbl[0].FsFlag = 0xee; // EE
 313
 314     pMBR->PartTbl[0].StartHead = 0;
 315     pMBR->PartTbl[0].StartSector = 1;
 316     pMBR->PartTbl[0].StartCylinder = 0;
 317     pMBR->PartTbl[0].EndHead = 254;
 318     pMBR->PartTbl[0].EndSector = 63;
 319     pMBR->PartTbl[0].EndCylinder = 1023;
 320
 321     pMBR->PartTbl[0].StartSectorId = 1;
 322     pMBR->PartTbl[0].SectorCount = (uint32_t)DiskSectorCount;
 323
 324     pMBR->Byte55 = 0x55;
 325     pMBR->ByteAA = 0xAA;
 326
 327     pMBR->BootCode[92] = 0x22;
 328
 329     return 0;
 330 }
 331
 332 static int ventoy_fill_gpt_partname(uint16_t Name[36], const char *asciiName)
 333 {
 334     int i;
 335     int len;
 336
 337     memset(Name, 0, 36 * sizeof(uint16_t));
 338     len = (int)strlen(asciiName);
 339     for (i = 0; i < 36 && i < len; i++)
 340     {
 341         Name[i] = asciiName[i];
 342     }
 343
 344     return 0;
 345 }
 346
 347 int ventoy_fill_gpt(uint64_t size, uint64_t reserve, int align4k, VTOY_GPT_INFO *gpt)
 348 {
 349     uint64_t ReservedSector = 33;
 350     uint64_t ModSectorCount = 0;
 351     uint64_t Part1SectorCount = 0;
 352     uint64_t DiskSectorCount = size / 512;
 353     VTOY_GPT_HDR *Head = &gpt->Head;
 354     VTOY_GPT_PART_TBL *Table = gpt->PartTbl;
 355     ventoy_guid WindowsDataPartType = { 0xebd0a0a2, 0xb9e5, 0x4433, { 0x87, 0xc0, 0x68, 0xb6, 0xb7, 0x26, 0x99, 0xc7 } };
 356     //ventoy_guid EspPartType = { 0xc12a7328, 0xf81f, 0x11d2, { 0xba, 0x4b, 0x00, 0xa0, 0xc9, 0x3e, 0xc9, 0x3b } };
 357         //ventoy_guid BiosGrubPartType = { 0x21686148, 0x6449, 0x6e6f, { 0x74, 0x4e, 0x65, 0x65, 0x64, 0x45, 0x46, 0x49 } };
 358
 359     VentoyFillProtectMBR(size, &gpt->MBR);
 360
 361     if (reserve > 0)
 362     {
 363         ReservedSector += reserve / 512;
 364     }
 365
 366     Part1SectorCount = DiskSectorCount - ReservedSector - (VTOYEFI_PART_BYTES / 512) - 2048;
 367
 368     ModSectorCount = (Part1SectorCount % 8);
 369     if (ModSectorCount)
 370     {
 371         vlog("Part1SectorCount:%llu is not aligned by 4KB (%llu)\n", (_ull)Part1SectorCount, (_ull)ModSectorCount);
 372     }
 373
 374     // check aligned with 4KB
 375     if (align4k)
 376     {
 377         if (ModSectorCount)
 378         {
 379             vdebug("Disk need to align with 4KB %u\n", (uint32_t)ModSectorCount);
 380             Part1SectorCount -= ModSectorCount;
 381         }
 382         else
 383         {
 384             vdebug("no need to align with 4KB\n");
 385         }
 386     }
 387
 388     memcpy(Head->Signature, "EFI PART", 8);
 389     Head->Version[2] = 0x01;
 390     Head->Length = 92;
 391     Head->Crc = 0;
 392     Head->EfiStartLBA = 1;
 393     Head->EfiBackupLBA = DiskSectorCount - 1;
 394     Head->PartAreaStartLBA = 34;
 395     Head->PartAreaEndLBA = DiskSectorCount - 34;
 396     ventoy_gen_preudo_uuid(&Head->DiskGuid);
 397     Head->PartTblStartLBA = 2;
 398     Head->PartTblTotNum = 128;
 399     Head->PartTblEntryLen = 128;
 400
 401
 402     memcpy(&(Table[0].PartType), &WindowsDataPartType, sizeof(ventoy_guid));
 403     ventoy_gen_preudo_uuid(&(Table[0].PartGuid));
 404     Table[0].StartLBA = 2048;
 405     Table[0].LastLBA = 2048 + Part1SectorCount - 1;
 406     Table[0].Attr = 0;
 407     ventoy_fill_gpt_partname(Table[0].Name, "Ventoy");
 408
 409     // to fix windows issue
 410     //memcpy(&(Table[1].PartType), &EspPartType, sizeof(GUID));
 411     memcpy(&(Table[1].PartType), &WindowsDataPartType, sizeof(ventoy_guid));
 412     ventoy_gen_preudo_uuid(&(Table[1].PartGuid));
 413     Table[1].StartLBA = Table[0].LastLBA + 1;
 414     Table[1].LastLBA = Table[1].StartLBA + VTOYEFI_PART_BYTES / 512 - 1;
 415     Table[1].Attr = 0xC000000000000001ULL;
 416     ventoy_fill_gpt_partname(Table[1].Name, "VTOYEFI");
 417
 418 #if 0
 419         memcpy(&(Table[2].PartType), &BiosGrubPartType, sizeof(ventoy_guid));
 420         ventoy_gen_preudo_uuid(&(Table[2].PartGuid));
 421         Table[2].StartLBA = 34;
 422         Table[2].LastLBA = 2047;
 423         Table[2].Attr = 0;
 424 #endif
 425
 426     //Update CRC
 427     Head->PartTblCrc = ventoy_crc32(Table, sizeof(gpt->PartTbl));
 428     Head->Crc = ventoy_crc32(Head, Head->Length);
 429
 430     return 0;
 431 }
 432
 433 int VentoyFillMBRLocation(uint64_t DiskSizeInBytes, uint32_t StartSectorId, uint32_t SectorCount, PART_TABLE *Table)
 434 {
 435     uint8_t Head;
 436     uint8_t Sector;
 437     uint8_t nSector = 63;
 438     uint8_t nHead = 8;
 439     uint32_t Cylinder;
 440     uint32_t EndSectorId;
 441
 442     while (nHead != 0 && (DiskSizeInBytes / 512 / nSector / nHead) > 1024)
 443     {
 444         nHead = (uint8_t)nHead * 2;
 445     }
 446
 447     if (nHead == 0)
 448     {
 449         nHead = 255;
 450     }
 451
 452     Cylinder = StartSectorId / nSector / nHead;
 453     Head = StartSectorId / nSector % nHead;
 454     Sector = StartSectorId % nSector + 1;
 455
 456     Table->StartHead = Head;
 457     Table->StartSector = Sector;
 458     Table->StartCylinder = Cylinder;
 459
 460     EndSectorId = StartSectorId + SectorCount - 1;
 461     Cylinder = EndSectorId / nSector / nHead;
 462     Head = EndSectorId / nSector % nHead;
 463     Sector = EndSectorId % nSector + 1;
 464
 465     Table->EndHead = Head;
 466     Table->EndSector = Sector;
 467     Table->EndCylinder = Cylinder;
 468
 469     Table->StartSectorId = StartSectorId;
 470     Table->SectorCount = SectorCount;
 471
 472     return 0;
 473 }
 474
 475 int ventoy_fill_mbr(uint64_t size, uint64_t reserve, int align4k, MBR_HEAD *pMBR)
 476 {
 477     ventoy_guid Guid;
 478     uint32_t DiskSignature;
 479     uint32_t DiskSectorCount;
 480     uint32_t PartSectorCount;
 481     uint32_t PartStartSector;
 482         uint32_t ReservedSector;
 483
 484     VentoyGetLocalBootImg(pMBR);
 485
 486     ventoy_gen_preudo_uuid(&Guid);
 487
 488     memcpy(&DiskSignature, &Guid, sizeof(uint32_t));
 489
 490     vdebug("Disk signature: 0x%08x\n", DiskSignature);
 491
 492     memcpy(pMBR->BootCode + 0x1B8, &DiskSignature, 4);
 493
 494     if (size / 512 > 0xFFFFFFFF)
 495     {
 496         DiskSectorCount = 0xFFFFFFFF;
 497     }
 498     else
 499     {
 500         DiskSectorCount = (uint32_t)(size / 512);
 501     }
 502
 503         if (reserve <= 0)
 504         {
 505                 ReservedSector = 0;
 506         }
 507         else
 508         {
 509                 ReservedSector = (uint32_t)(reserve / 512);
 510         }
 511
 512     // check aligned with 4KB
 513     if (align4k)
 514     {
 515         uint64_t sectors = size / 512;
 516         if (sectors % 8)
 517         {
 518             vlog("Disk need to align with 4KB %u\n", (uint32_t)(sectors % 8));
 519             ReservedSector += (uint32_t)(sectors % 8);
 520         }
 521         else
 522         {
 523             vdebug("no need to align with 4KB\n");
 524         }
 525     }
 526
 527         vlog("ReservedSector: %u\n", ReservedSector);
 528
 529     //Part1
 530     PartStartSector = VTOYIMG_PART_START_SECTOR;
 531         PartSectorCount = DiskSectorCount - ReservedSector - VTOYEFI_PART_BYTES / 512 - PartStartSector;
 532     VentoyFillMBRLocation(size, PartStartSector, PartSectorCount, pMBR->PartTbl);
 533
 534     pMBR->PartTbl[0].Active = 0x80; // bootable
 535     pMBR->PartTbl[0].FsFlag = 0x07; // exFAT/NTFS/HPFS
 536
 537     //Part2
 538     PartStartSector += PartSectorCount;
 539     PartSectorCount = VTOYEFI_PART_BYTES / 512;
 540     VentoyFillMBRLocation(size, PartStartSector, PartSectorCount, pMBR->PartTbl + 1);
 541
 542     pMBR->PartTbl[1].Active = 0x00;
 543     pMBR->PartTbl[1].FsFlag = 0xEF; // EFI System Partition
 544
 545     pMBR->Byte55 = 0x55;
 546     pMBR->ByteAA = 0xAA;
 547
 548     return 0;
 549 }
 550