]> glassweightruler.freedombox.rocks Git - Ventoy.git/blob - GRUB2/MOD_SRC/grub-2.04/grub-core/ventoy/ventoy_cmd.c
projects / Ventoy.git / blob
? search:


73e982154fc99bf19660d142f23d40fba2cd2d31
[Ventoy.git] / GRUB2 / MOD_SRC / grub-2.04 / grub-core / ventoy / ventoy_cmd.c
1 /******************************************************************************
2 * ventoy_cmd.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 <grub/types.h>
22 #include <grub/misc.h>
23 #include <grub/mm.h>
24 #include <grub/err.h>
25 #include <grub/dl.h>
26 #include <grub/disk.h>
27 #include <grub/device.h>
28 #include <grub/term.h>
29 #include <grub/partition.h>
30 #include <grub/file.h>
31 #include <grub/normal.h>
32 #include <grub/extcmd.h>
33 #include <grub/datetime.h>
34 #include <grub/i18n.h>
35 #include <grub/net.h>
36 #include <grub/misc.h>
37 #include <grub/kernel.h>
38 #ifdef GRUB_MACHINE_EFI
39 #include <grub/efi/api.h>
40 #include <grub/efi/efi.h>
41 #endif
42 #include <grub/time.h>
43 #include <grub/video.h>
44 #include <grub/acpi.h>
45 #include <grub/charset.h>
46 #include <grub/crypto.h>
47 #include <grub/lib/crc.h>
48 #include <grub/random.h>
49 #include <grub/ventoy.h>
50 #include "ventoy_def.h"
51 #include "miniz.h"
52
53 GRUB_MOD_LICENSE ("GPLv3+");
54
55 static grub_uint8_t g_check_mbr_data[] = {
56 0xEB, 0x63, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
57 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
58 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
59 0x56, 0x54, 0x00, 0x47, 0x65, 0x00, 0x48, 0x44, 0x00, 0x52, 0x64, 0x00, 0x20, 0x45, 0x72, 0x0D,
60 };
61
62 initrd_info *g_initrd_img_list = NULL;
63 initrd_info *g_initrd_img_tail = NULL;
64 int g_initrd_img_count = 0;
65 int g_valid_initrd_count = 0;
66 int g_default_menu_mode = 0;
67 int g_filt_dot_underscore_file = 0;
68 int g_sort_case_sensitive = 0;
69 int g_tree_view_menu_style = 0;
70 static grub_file_t g_old_file;
71 static int g_ventoy_last_entry_back;
72
73 char g_iso_path[256];
74 char g_img_swap_tmp_buf[1024];
75 img_info g_img_swap_tmp;
76 img_info *g_ventoy_img_list = NULL;
77
78 int g_ventoy_img_count = 0;
79
80 grub_device_t g_enum_dev = NULL;
81 grub_fs_t g_enum_fs = NULL;
82 int g_img_max_search_level = -1;
83 img_iterator_node g_img_iterator_head;
84 img_iterator_node *g_img_iterator_tail = NULL;
85
86 grub_uint8_t g_ventoy_break_level = 0;
87 grub_uint8_t g_ventoy_debug_level = 0;
88 grub_uint8_t g_ventoy_chain_type = 0;
89
90 grub_uint8_t *g_ventoy_cpio_buf = NULL;
91 grub_uint32_t g_ventoy_cpio_size = 0;
92 cpio_newc_header *g_ventoy_initrd_head = NULL;
93 grub_uint8_t *g_ventoy_runtime_buf = NULL;
94
95 int g_plugin_image_list = 0;
96
97 ventoy_grub_param *g_grub_param = NULL;
98
99 ventoy_guid g_ventoy_guid = VENTOY_GUID;
100
101 ventoy_img_chunk_list g_img_chunk_list;
102
103 int g_wimboot_enable = 0;
104 ventoy_img_chunk_list g_wimiso_chunk_list;
105 char *g_wimiso_path = NULL;
106 grub_uint32_t g_wimiso_size = 0;
107
108 int g_vhdboot_enable = 0;
109
110 grub_uint64_t g_svd_replace_offset = 0;
111
112 int g_conf_replace_count = 0;
113 grub_uint64_t g_conf_replace_offset[VTOY_MAX_CONF_REPLACE] = { 0 };
114 conf_replace *g_conf_replace_node[VTOY_MAX_CONF_REPLACE] = { NULL };
115 grub_uint8_t *g_conf_replace_new_buf[VTOY_MAX_CONF_REPLACE] = { NULL };
116 int g_conf_replace_new_len[VTOY_MAX_CONF_REPLACE] = { 0 };
117 int g_conf_replace_new_len_align[VTOY_MAX_CONF_REPLACE] = { 0 };
118
119 int g_ventoy_disk_bios_id = 0;
120 ventoy_gpt_info *g_ventoy_part_info = NULL;
121 grub_uint64_t g_ventoy_disk_size = 0;
122 grub_uint64_t g_ventoy_disk_part_size[2];
123
124 char *g_tree_script_buf = NULL;
125 int g_tree_script_pos = 0;
126 int g_tree_script_pre = 0;
127
128 static char *g_list_script_buf = NULL;
129 static int g_list_script_pos = 0;
130
131 static char *g_part_list_buf = NULL;
132 static int g_part_list_pos = 0;
133 static grub_uint64_t g_part_end_max = 0;
134
135 static int g_video_mode_max = 0;
136 static int g_video_mode_num = 0;
137 static ventoy_video_mode *g_video_mode_list = NULL;
138
139 static int g_enumerate_time_checked = 0;
140 static grub_uint64_t g_enumerate_start_time_ms;
141 static grub_uint64_t g_enumerate_finish_time_ms;
142 int g_vtoy_file_flt[VTOY_FILE_FLT_BUTT] = {0};
143
144 static char g_iso_vd_id_publisher[130];
145 static char g_iso_vd_id_prepare[130];
146 static char g_iso_vd_id_application[130];
147
148 static int g_pager_flag = 0;
149 static char g_old_pager[32];
150
151 const char *g_menu_class[img_type_max] =
152 {
153 "vtoyiso", "vtoywim", "vtoyefi", "vtoyimg", "vtoyvhd", "vtoyvtoy"
154 };
155
156 const char *g_menu_prefix[img_type_max] =
157 {
158 "iso", "wim", "efi", "img", "vhd", "vtoy"
159 };
160
161 static int g_vtoy_secondary_need_recover = 0;
162
163 static int g_vtoy_load_prompt = 0;
164 static char g_vtoy_prompt_msg[64];
165
166 static char g_json_case_mis_path[32];
167
168 static ventoy_vlnk_part *g_vlnk_part_list = NULL;
169
170 int ventoy_get_fs_type(const char *fs)
171 {
172 if (NULL == fs)
173 {
174 return ventoy_fs_max;
175 }
176 else if (grub_strncmp(fs, "exfat", 5) == 0)
177 {
178 return ventoy_fs_exfat;
179 }
180 else if (grub_strncmp(fs, "ntfs", 4) == 0)
181 {
182 return ventoy_fs_ntfs;
183 }
184 else if (grub_strncmp(fs, "ext", 3) == 0)
185 {
186 return ventoy_fs_ext;
187 }
188 else if (grub_strncmp(fs, "xfs", 3) == 0)
189 {
190 return ventoy_fs_xfs;
191 }
192 else if (grub_strncmp(fs, "udf", 3) == 0)
193 {
194 return ventoy_fs_udf;
195 }
196 else if (grub_strncmp(fs, "fat", 3) == 0)
197 {
198 return ventoy_fs_fat;
199 }
200
201 return ventoy_fs_max;
202 }
203
204 static int ventoy_string_check(const char *str, grub_char_check_func check)
205 {
206 if (!str)
207 {
208 return 0;
209 }
210
211 for ( ; *str; str++)
212 {
213 if (!check(*str))
214 {
215 return 0;
216 }
217 }
218
219 return 1;
220 }
221
222
223 static grub_ssize_t ventoy_fs_read(grub_file_t file, char *buf, grub_size_t len)
224 {
225 grub_memcpy(buf, (char *)file->data + file->offset, len);
226 return len;
227 }
228
229 static int ventoy_control_get_flag(const char *key)
230 {
231 const char *val = ventoy_get_env(key);
232
233 if (val && val[0] == '1' && val[1] == 0)
234 {
235 return 1;
236 }
237 return 0;
238 }
239
240 static grub_err_t ventoy_fs_close(grub_file_t file)
241 {
242 grub_file_close(g_old_file);
243 grub_free(file->data);
244
245 file->device = 0;
246 file->name = 0;
247
248 return 0;
249 }
250
251 static int ventoy_video_hook(const struct grub_video_mode_info *info, void *hook_arg)
252 {
253 int i;
254
255 (void)hook_arg;
256
257 if (info->mode_type & GRUB_VIDEO_MODE_TYPE_PURE_TEXT)
258 {
259 return 0;
260 }
261
262 for (i = 0; i < g_video_mode_num; i++)
263 {
264 if (g_video_mode_list[i].width == info->width &&
265 g_video_mode_list[i].height == info->height &&
266 g_video_mode_list[i].bpp == info->bpp)
267 {
268 return 0;
269 }
270 }
271
272 g_video_mode_list[g_video_mode_num].width = info->width;
273 g_video_mode_list[g_video_mode_num].height = info->height;
274 g_video_mode_list[g_video_mode_num].bpp = info->bpp;
275 g_video_mode_num++;
276
277 if (g_video_mode_num == g_video_mode_max)
278 {
279 g_video_mode_max *= 2;
280 g_video_mode_list = grub_realloc(g_video_mode_list, g_video_mode_max * sizeof(ventoy_video_mode));
281 }
282
283 return 0;
284 }
285
286 static int ventoy_video_mode_cmp(ventoy_video_mode *v1, ventoy_video_mode *v2)
287 {
288 if (v1->bpp == v2->bpp)
289 {
290 if (v1->width == v2->width)
291 {
292 if (v1->height == v2->height)
293 {
294 return 0;
295 }
296 else
297 {
298 return (v1->height < v2->height) ? -1 : 1;
299 }
300 }
301 else
302 {
303 return (v1->width < v2->width) ? -1 : 1;
304 }
305 }
306 else
307 {
308 return (v1->bpp < v2->bpp) ? -1 : 1;
309 }
310 }
311
312 static int ventoy_enum_video_mode(void)
313 {
314 int i, j;
315 grub_video_adapter_t adapter;
316 grub_video_driver_id_t id;
317 ventoy_video_mode mode;
318
319 g_video_mode_num = 0;
320 g_video_mode_max = 1024;
321 g_video_mode_list = grub_malloc(sizeof(ventoy_video_mode) * g_video_mode_max);
322 if (!g_video_mode_list)
323 {
324 return 0;
325 }
326
327 #ifdef GRUB_MACHINE_PCBIOS
328 grub_dl_load ("vbe");
329 #endif
330
331 id = grub_video_get_driver_id ();
332
333 FOR_VIDEO_ADAPTERS (adapter)
334 {
335 if (!adapter->iterate ||
336 (adapter->id != id && (id != GRUB_VIDEO_DRIVER_NONE ||
337 adapter->init() != GRUB_ERR_NONE)))
338 {
339 continue;
340 }
341
342 adapter->iterate(ventoy_video_hook, NULL);
343
344 if (adapter->id != id)
345 {
346 adapter->fini();
347 }
348 }
349
350 /* sort video mode */
351 for (i = 0; i < g_video_mode_num; i++)
352 for (j = i + 1; j < g_video_mode_num; j++)
353 {
354 if (ventoy_video_mode_cmp(g_video_mode_list + i, g_video_mode_list + j) < 0)
355 {
356 grub_memcpy(&mode, g_video_mode_list + i, sizeof(ventoy_video_mode));
357 grub_memcpy(g_video_mode_list + i, g_video_mode_list + j, sizeof(ventoy_video_mode));
358 grub_memcpy(g_video_mode_list + j, &mode, sizeof(ventoy_video_mode));
359 }
360 }
361
362 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
363 }
364
365 static grub_file_t ventoy_wrapper_open(grub_file_t rawFile, enum grub_file_type type)
366 {
367 int len;
368 grub_file_t file;
369 static struct grub_fs vtoy_fs =
370 {
371 .name = "vtoy",
372 .fs_dir = 0,
373 .fs_open = 0,
374 .fs_read = ventoy_fs_read,
375 .fs_close = ventoy_fs_close,
376 .fs_label = 0,
377 .next = 0
378 };
379
380 if (type != 52)
381 {
382 return rawFile;
383 }
384
385 file = (grub_file_t)grub_zalloc(sizeof (*file));
386 if (!file)
387 {
388 return 0;
389 }
390
391 file->data = grub_malloc(rawFile->size + 4096);
392 if (!file->data)
393 {
394 return 0;
395 }
396
397 grub_file_read(rawFile, file->data, rawFile->size);
398 len = ventoy_fill_data(4096, (char *)file->data + rawFile->size);
399
400 g_old_file = rawFile;
401
402 file->size = rawFile->size + len;
403 file->device = rawFile->device;
404 file->fs = &vtoy_fs;
405 file->not_easily_seekable = 1;
406
407 return file;
408 }
409
410 static int ventoy_check_decimal_var(const char *name, long *value)
411 {
412 const char *value_str = NULL;
413
414 value_str = grub_env_get(name);
415 if (NULL == value_str)
416 {
417 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Variable %s not found", name);
418 }
419
420 if (!ventoy_is_decimal(value_str))
421 {
422 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Variable %s value '%s' is not an integer", name, value_str);
423 }
424
425 *value = grub_strtol(value_str, NULL, 10);
426
427 return GRUB_ERR_NONE;
428 }
429
430 grub_uint64_t ventoy_get_vtoy_partsize(int part)
431 {
432 grub_uint64_t sectors;
433
434 if (grub_strncmp(g_ventoy_part_info->Head.Signature, "EFI PART", 8) == 0)
435 {
436 sectors = g_ventoy_part_info->PartTbl[part].LastLBA + 1 - g_ventoy_part_info->PartTbl[part].StartLBA;
437 }
438 else
439 {
440 sectors = g_ventoy_part_info->MBR.PartTbl[part].SectorCount;
441 }
442
443 return sectors * 512;
444 }
445
446 static int ventoy_load_efiboot_template(char **buf, int *datalen, int *direntoff)
447 {
448 int len;
449 grub_file_t file;
450 char exec[128];
451 char *data = NULL;
452 grub_uint32_t offset;
453
454 file = ventoy_grub_file_open(GRUB_FILE_TYPE_LINUX_INITRD, "%s/ventoy/ventoy_efiboot.img.xz", ventoy_get_env("vtoy_efi_part"));
455 if (file == NULL)
456 {
457 debug("failed to open file <%s>\n", "ventoy_efiboot.img.xz");
458 return 1;
459 }
460
461 len = (int)file->size;
462
463 data = (char *)grub_malloc(file->size);
464 if (!data)
465 {
466 return 1;
467 }
468
469 grub_file_read(file, data, file->size);
470 grub_file_close(file);
471
472 grub_snprintf(exec, sizeof(exec), "loopback efiboot mem:0x%llx:size:%d", (ulonglong)(ulong)data, len);
473 grub_script_execute_sourcecode(exec);
474
475 file = grub_file_open("(efiboot)/EFI/BOOT/BOOTX64.EFI", GRUB_FILE_TYPE_LINUX_INITRD);
476 offset = (grub_uint32_t)grub_iso9660_get_last_file_dirent_pos(file);
477 grub_file_close(file);
478
479 grub_script_execute_sourcecode("loopback -d efiboot");
480
481 *buf = data;
482 *datalen = len;
483 *direntoff = offset + 2;
484
485 return 0;
486 }
487
488 static int ventoy_set_check_result(int ret, const char *msg)
489 {
490 char buf[32];
491
492 grub_snprintf(buf, sizeof(buf), "%d", (ret & 0x7FFF));
493 grub_env_set("VTOY_CHKDEV_RESULT_STRING", buf);
494 grub_env_export("VTOY_CHKDEV_RESULT_STRING");
495
496 if (ret)
497 {
498 grub_printf(VTOY_WARNING"\n");
499 grub_printf(VTOY_WARNING"\n");
500 grub_printf(VTOY_WARNING"\n\n\n");
501
502 grub_printf("This is NOT a standard Ventoy device and is NOT supported (%d).\n", ret);
503 grub_printf("Error message: <%s>\n\n", msg);
504 grub_printf("You should follow the instructions in https://www.ventoy.net to use Ventoy.\n");
505
506 grub_printf("\n\nWill exit after 10 seconds ...... ");
507 grub_refresh();
508 grub_sleep(10);
509 }
510
511 return ret;
512 }
513
514 static int ventoy_check_official_device(grub_device_t dev)
515 {
516 int workaround = 0;
517 grub_file_t file;
518 grub_uint64_t offset;
519 char devname[64];
520 grub_fs_t fs;
521 grub_uint8_t mbr[512];
522 grub_disk_t disk;
523 grub_device_t dev2;
524 char *label = NULL;
525 struct grub_partition *partition;
526
527 if (dev->disk == NULL || dev->disk->partition == NULL)
528 {
529 return ventoy_set_check_result(1 | 0x1000, "Internal Error");
530 }
531
532 if (0 == ventoy_check_file_exist("(%s,2)/ventoy/ventoy.cpio", dev->disk->name) ||
533 0 == ventoy_check_file_exist("(%s,2)/grub/localboot.cfg", dev->disk->name) ||
534 0 == ventoy_check_file_exist("(%s,2)/tool/mount.exfat-fuse_aarch64", dev->disk->name))
535 {
536 #ifndef GRUB_MACHINE_EFI
537 if (0 == ventoy_check_file_exist("(ventoydisk)/ventoy/ventoy.cpio", dev->disk->name))
538 {
539 return ventoy_set_check_result(2 | 0x1000, "File ventoy/ventoy.cpio missing in VTOYEFI partition");
540 }
541 else if (0 == ventoy_check_file_exist("(ventoydisk)/grub/localboot.cfg", dev->disk->name))
542 {
543 return ventoy_set_check_result(2 | 0x1000, "File grub/localboot.cfg missing in VTOYEFI partition");
544 }
545 else if (0 == ventoy_check_file_exist("(ventoydisk)/tool/mount.exfat-fuse_aarch64", dev->disk->name))
546 {
547 return ventoy_set_check_result(2 | 0x1000, "File tool/mount.exfat-fuse_aarch64 missing in VTOYEFI partition");
548 }
549 else
550 {
551 workaround = 1;
552 }
553 #endif
554 }
555
556 /* We must have partition 2 */
557 if (workaround)
558 {
559 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", "(ventoydisk)/ventoy/ventoy.cpio");
560 }
561 else
562 {
563 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "(%s,2)/ventoy/ventoy.cpio", dev->disk->name);
564 }
565 if (!file)
566 {
567 return ventoy_set_check_result(3 | 0x1000, "File ventoy/ventoy.cpio open failed in VTOYEFI partition");
568 }
569
570 if (NULL == grub_strstr(file->fs->name, "fat"))
571 {
572 grub_file_close(file);
573 return ventoy_set_check_result(4 | 0x1000, "VTOYEFI partition is not FAT filesystem");
574 }
575
576 partition = dev->disk->partition;
577 if (partition->number != 0 || partition->start != 2048)
578 {
579 return ventoy_set_check_result(5, "Ventoy partition is not start at 1MB");
580 }
581
582 if (workaround)
583 {
584 if (grub_strncmp(g_ventoy_part_info->Head.Signature, "EFI PART", 8) == 0)
585 {
586 ventoy_gpt_part_tbl *PartTbl = g_ventoy_part_info->PartTbl;
587 if (PartTbl[1].StartLBA != PartTbl[0].LastLBA + 1 ||
588 (PartTbl[1].LastLBA + 1 - PartTbl[1].StartLBA) != 65536)
589 {
590 grub_file_close(file);
591 return ventoy_set_check_result(6, "Disk partition layout check failed.");
592 }
593 }
594 else
595 {
596 ventoy_part_table *PartTbl = g_ventoy_part_info->MBR.PartTbl;
597 if (PartTbl[1].StartSectorId != PartTbl[0].StartSectorId + PartTbl[0].SectorCount ||
598 PartTbl[1].SectorCount != 65536)
599 {
600 grub_file_close(file);
601 return ventoy_set_check_result(6, "Disk partition layout check failed.");
602 }
603 }
604 }
605 else
606 {
607 offset = partition->start + partition->len;
608 partition = file->device->disk->partition;
609 if ((partition->number != 1) || (partition->len != 65536) || (offset != partition->start))
610 {
611 grub_file_close(file);
612 return ventoy_set_check_result(7, "Disk partition layout check failed.");
613 }
614 }
615
616 grub_file_close(file);
617
618 if (workaround == 0)
619 {
620 grub_snprintf(devname, sizeof(devname), "%s,2", dev->disk->name);
621 dev2 = grub_device_open(devname);
622 if (!dev2)
623 {
624 return ventoy_set_check_result(8, "Disk open failed");
625 }
626
627 fs = grub_fs_probe(dev2);
628 if (!fs)
629 {
630 grub_device_close(dev2);
631 return ventoy_set_check_result(9, "FS probe failed");
632 }
633
634 fs->fs_label(dev2, &label);
635 if ((!label) || grub_strncmp("VTOYEFI", label, 7))
636 {
637 grub_device_close(dev2);
638 return ventoy_set_check_result(10, "Partition name is not VTOYEFI");
639 }
640
641 grub_device_close(dev2);
642 }
643
644 /* MBR check */
645 disk = grub_disk_open(dev->disk->name);
646 if (!disk)
647 {
648 return ventoy_set_check_result(11, "Disk open failed");
649 }
650
651 grub_memset(mbr, 0, 512);
652 grub_disk_read(disk, 0, 0, 512, mbr);
653 grub_disk_close(disk);
654
655 if (grub_memcmp(g_check_mbr_data, mbr, 0x30) || grub_memcmp(g_check_mbr_data + 0x30, mbr + 0x190, 16))
656 {
657 return ventoy_set_check_result(12, "MBR check failed");
658 }
659
660 return ventoy_set_check_result(0, NULL);
661 }
662
663 static int ventoy_check_ignore_flag(const char *filename, const struct grub_dirhook_info *info, void *data)
664 {
665 if (0 == info->dir)
666 {
667 if (filename && filename[0] == '.' && 0 == grub_strncmp(filename, ".ventoyignore", 13))
668 {
669 *((int *)data) = 1;
670 return 0;
671 }
672 }
673
674 return 0;
675 }
676
677 grub_uint64_t ventoy_grub_get_file_size(const char *fmt, ...)
678 {
679 grub_uint64_t size = 0;
680 grub_file_t file;
681 va_list ap;
682 char fullpath[256] = {0};
683
684 va_start (ap, fmt);
685 grub_vsnprintf(fullpath, 255, fmt, ap);
686 va_end (ap);
687
688 file = grub_file_open(fullpath, VENTOY_FILE_TYPE);
689 if (!file)
690 {
691 debug("grub_file_open failed <%s>\n", fullpath);
692 grub_errno = 0;
693 return 0;
694 }
695
696 size = file->size;
697 grub_file_close(file);
698 return size;
699 }
700
701 grub_file_t ventoy_grub_file_open(enum grub_file_type type, const char *fmt, ...)
702 {
703 va_list ap;
704 grub_file_t file;
705 char fullpath[512] = {0};
706
707 va_start (ap, fmt);
708 grub_vsnprintf(fullpath, 511, fmt, ap);
709 va_end (ap);
710
711 file = grub_file_open(fullpath, type);
712 if (!file)
713 {
714 debug("grub_file_open failed <%s> %d\n", fullpath, grub_errno);
715 grub_errno = 0;
716 }
717
718 return file;
719 }
720
721 int ventoy_is_dir_exist(const char *fmt, ...)
722 {
723 va_list ap;
724 int len;
725 char *pos = NULL;
726 char buf[512] = {0};
727
728 grub_snprintf(buf, sizeof(buf), "%s", "[ -d \"");
729 pos = buf + 6;
730
731 va_start (ap, fmt);
732 len = grub_vsnprintf(pos, 511, fmt, ap);
733 va_end (ap);
734
735 grub_strncpy(pos + len, "\" ]", 3);
736
737 debug("script exec %s\n", buf);
738
739 if (0 == grub_script_execute_sourcecode(buf))
740 {
741 return 1;
742 }
743
744 return 0;
745 }
746
747 int ventoy_gzip_compress(void *mem_in, int mem_in_len, void *mem_out, int mem_out_len)
748 {
749 mz_stream s;
750 grub_uint8_t *outbuf;
751 grub_uint8_t gzHdr[10] =
752 {
753 0x1F, 0x8B, /* magic */
754 8, /* z method */
755 0, /* flags */
756 0,0,0,0, /* mtime */
757 4, /* xfl */
758 3, /* OS */
759 };
760
761 grub_memset(&s, 0, sizeof(mz_stream));
762
763 mz_deflateInit2(&s, 1, MZ_DEFLATED, -MZ_DEFAULT_WINDOW_BITS, 6, MZ_DEFAULT_STRATEGY);
764
765 outbuf = (grub_uint8_t *)mem_out;
766
767 mem_out_len -= sizeof(gzHdr) + 8;
768 grub_memcpy(outbuf, gzHdr, sizeof(gzHdr));
769 outbuf += sizeof(gzHdr);
770
771 s.avail_in = mem_in_len;
772 s.next_in = mem_in;
773
774 s.avail_out = mem_out_len;
775 s.next_out = outbuf;
776
777 mz_deflate(&s, MZ_FINISH);
778
779 mz_deflateEnd(&s);
780
781 outbuf += s.total_out;
782 *(grub_uint32_t *)outbuf = grub_getcrc32c(0, outbuf, s.total_out);
783 *(grub_uint32_t *)(outbuf + 4) = (grub_uint32_t)(s.total_out);
784
785 return s.total_out + sizeof(gzHdr) + 8;
786 }
787
788
789 #if 0
790 ventoy grub cmds
791 #endif
792
793 static grub_err_t ventoy_cmd_debug(grub_extcmd_context_t ctxt, int argc, char **args)
794 {
795 if (argc != 1)
796 {
797 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s {on|off}", cmd_raw_name);
798 }
799
800 if (0 == grub_strcmp(args[0], "on"))
801 {
802 g_ventoy_debug = 1;
803 grub_env_set("vtdebug_flag", "debug");
804 }
805 else
806 {
807 g_ventoy_debug = 0;
808 grub_env_set("vtdebug_flag", "");
809 }
810
811 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
812 }
813
814 static grub_err_t ventoy_cmd_break(grub_extcmd_context_t ctxt, int argc, char **args)
815 {
816 (void)ctxt;
817
818 if (argc < 1 || (args[0][0] != '0' && args[0][0] != '1'))
819 {
820 grub_printf("Usage: %s {level} [debug]\r\n", cmd_raw_name);
821 grub_printf(" level:\r\n");
822 grub_printf(" 01/11: busybox / (+cat log)\r\n");
823 grub_printf(" 02/12: initrd / (+cat log)\r\n");
824 grub_printf(" 03/13: hook / (+cat log)\r\n");
825 grub_printf("\r\n");
826 grub_printf(" debug:\r\n");
827 grub_printf(" 0: debug is off\r\n");
828 grub_printf(" 1: debug is on\r\n");
829 grub_printf("\r\n");
830 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
831 }
832
833 g_ventoy_break_level = (grub_uint8_t)grub_strtoul(args[0], NULL, 16);
834
835 if (argc > 1 && grub_strtoul(args[1], NULL, 10) > 0)
836 {
837 g_ventoy_debug_level = 1;
838 }
839
840 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
841 }
842
843 static grub_err_t ventoy_cmd_strstr(grub_extcmd_context_t ctxt, int argc, char **args)
844 {
845 (void)ctxt;
846
847 if (argc != 2)
848 {
849 return 1;
850 }
851
852 return (grub_strstr(args[0], args[1])) ? 0 : 1;
853 }
854
855 static grub_err_t ventoy_cmd_strbegin(grub_extcmd_context_t ctxt, int argc, char **args)
856 {
857 char *c0, *c1;
858
859 (void)ctxt;
860
861 if (argc != 2)
862 {
863 return 1;
864 }
865
866 c0 = args[0];
867 c1 = args[1];
868
869 while (*c0 && *c1)
870 {
871 if (*c0 != *c1)
872 {
873 return 1;
874 }
875 c0++;
876 c1++;
877 }
878
879 if (*c1)
880 {
881 return 1;
882 }
883
884 return 0;
885 }
886
887 static grub_err_t ventoy_cmd_strcasebegin(grub_extcmd_context_t ctxt, int argc, char **args)
888 {
889 char *c0, *c1;
890
891 (void)ctxt;
892
893 if (argc != 2)
894 {
895 return 1;
896 }
897
898 c0 = args[0];
899 c1 = args[1];
900
901 while (*c0 && *c1)
902 {
903 if ((*c0 != *c1) && (*c0 != grub_toupper(*c1)))
904 {
905 return 1;
906 }
907 c0++;
908 c1++;
909 }
910
911 if (*c1)
912 {
913 return 1;
914 }
915
916 return 0;
917 }
918
919 static grub_err_t ventoy_cmd_incr(grub_extcmd_context_t ctxt, int argc, char **args)
920 {
921 long value_long = 0;
922 char buf[32];
923
924 if ((argc != 2) || (!ventoy_is_decimal(args[1])))
925 {
926 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s {Variable} {Int}", cmd_raw_name);
927 }
928
929 if (GRUB_ERR_NONE != ventoy_check_decimal_var(args[0], &value_long))
930 {
931 return grub_errno;
932 }
933
934 value_long += grub_strtol(args[1], NULL, 10);
935
936 grub_snprintf(buf, sizeof(buf), "%ld", value_long);
937 grub_env_set(args[0], buf);
938
939 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
940 }
941
942 static grub_err_t ventoy_cmd_mod(grub_extcmd_context_t ctxt, int argc, char **args)
943 {
944 ulonglong value1 = 0;
945 ulonglong value2 = 0;
946 char buf[32];
947
948 if (argc != 3)
949 {
950 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s {Int} {Int} {Variable}", cmd_raw_name);
951 }
952
953 value1 = grub_strtoull(args[0], NULL, 10);
954 value2 = grub_strtoull(args[1], NULL, 10);
955
956 grub_snprintf(buf, sizeof(buf), "%llu", (value1 & (value2 - 1)));
957 grub_env_set(args[2], buf);
958
959 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
960 }
961
962 static grub_err_t ventoy_cmd_file_size(grub_extcmd_context_t ctxt, int argc, char **args)
963 {
964 int rc = 1;
965 char buf[32];
966 grub_file_t file;
967
968 (void)ctxt;
969 (void)argc;
970 (void)args;
971
972 if (argc != 2)
973 {
974 return rc;
975 }
976
977 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", args[0]);
978 if (file == NULL)
979 {
980 debug("failed to open file <%s> for udf check\n", args[0]);
981 return 1;
982 }
983
984 grub_snprintf(buf, sizeof(buf), "%llu", (unsigned long long)file->size);
985
986 grub_env_set(args[1], buf);
987
988 grub_file_close(file);
989 rc = 0;
990
991 return rc;
992 }
993
994 static grub_err_t ventoy_cmd_load_wimboot(grub_extcmd_context_t ctxt, int argc, char **args)
995 {
996 grub_file_t file;
997
998 (void)ctxt;
999 (void)argc;
1000 (void)args;
1001
1002 g_wimboot_enable = 0;
1003 g_wimiso_size = 0;
1004 grub_check_free(g_wimiso_path);
1005 grub_check_free(g_wimiso_chunk_list.chunk);
1006
1007 file = grub_file_open(args[0], VENTOY_FILE_TYPE);
1008 if (!file)
1009 {
1010 return 0;
1011 }
1012
1013 grub_memset(&g_wimiso_chunk_list, 0, sizeof(g_wimiso_chunk_list));
1014 g_wimiso_chunk_list.chunk = grub_malloc(sizeof(ventoy_img_chunk) * DEFAULT_CHUNK_NUM);
1015 if (NULL == g_wimiso_chunk_list.chunk)
1016 {
1017 return grub_error(GRUB_ERR_OUT_OF_MEMORY, "Can't allocate image chunk memoty\n");
1018 }
1019
1020 g_wimiso_chunk_list.max_chunk = DEFAULT_CHUNK_NUM;
1021 g_wimiso_chunk_list.cur_chunk = 0;
1022
1023 ventoy_get_block_list(file, &g_wimiso_chunk_list, file->device->disk->partition->start);
1024
1025 g_wimboot_enable = 1;
1026 g_wimiso_path = grub_strdup(args[0]);
1027 g_wimiso_size = (grub_uint32_t)(file->size);
1028 grub_file_close(file);
1029
1030 return 0;
1031 }
1032
1033 static grub_err_t ventoy_cmd_concat_efi_iso(grub_extcmd_context_t ctxt, int argc, char **args)
1034 {
1035 int len = 0;
1036 int totlen = 0;
1037 int offset = 0;
1038 grub_file_t file;
1039 char *buf = NULL;
1040 char *data = NULL;
1041 ventoy_iso9660_override *dirent;
1042
1043 (void)ctxt;
1044
1045 if (argc != 2)
1046 {
1047 return 1;
1048 }
1049
1050 totlen = sizeof(ventoy_chain_head);
1051
1052 if (ventoy_load_efiboot_template(&buf, &len, &offset))
1053 {
1054 debug("failed to load efiboot template %d\n", len);
1055 return 1;
1056 }
1057
1058 totlen += len;
1059
1060 debug("efiboot template len:%d offset:%d\n", len, offset);
1061
1062 file = ventoy_grub_file_open(GRUB_FILE_TYPE_LINUX_INITRD, "%s", args[0]);
1063 if (file == NULL)
1064 {
1065 debug("failed to open file <%s>\n", args[0]);
1066 return 1;
1067 }
1068
1069 if (grub_strncmp(args[0], g_iso_path, grub_strlen(g_iso_path)))
1070 {
1071 file->vlnk = 1;
1072 }
1073
1074 totlen += ventoy_align_2k(file->size);
1075
1076 dirent = (ventoy_iso9660_override *)(buf + offset);
1077 dirent->first_sector = len / 2048;
1078 dirent->first_sector_be = grub_swap_bytes32(dirent->first_sector);
1079 dirent->size = (grub_uint32_t)file->size;
1080 dirent->size_be = grub_swap_bytes32(dirent->size);
1081
1082 debug("rawiso len:%d efilen:%d total:%d\n", len, (int)file->size, totlen);
1083
1084 #ifdef GRUB_MACHINE_EFI
1085 data = (char *)grub_efi_allocate_iso_buf(totlen);
1086 #else
1087 data = (char *)grub_malloc(totlen);
1088 #endif
1089
1090 ventoy_fill_os_param(file, (ventoy_os_param *)data);
1091
1092 grub_memcpy(data + sizeof(ventoy_chain_head), buf, len);
1093 grub_check_free(buf);
1094
1095 grub_file_read(file, data + sizeof(ventoy_chain_head) + len, file->size);
1096 grub_file_close(file);
1097
1098 ventoy_memfile_env_set(args[1], data, (ulonglong)totlen);
1099
1100 return 0;
1101 }
1102
1103 grub_err_t ventoy_cmd_set_wim_prompt(grub_extcmd_context_t ctxt, int argc, char **args)
1104 {
1105 (void)ctxt;
1106 (void)argc;
1107 (void)args;
1108
1109 g_vtoy_load_prompt = 0;
1110 grub_memset(g_vtoy_prompt_msg, 0, sizeof(g_vtoy_prompt_msg));
1111
1112 if (argc == 2 && args[0][0] == '1')
1113 {
1114 g_vtoy_load_prompt = 1;
1115 grub_snprintf(g_vtoy_prompt_msg, sizeof(g_vtoy_prompt_msg), "%s", args[1]);
1116 }
1117
1118 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
1119 }
1120
1121 int ventoy_need_prompt_load_file(void)
1122 {
1123 return g_vtoy_load_prompt;
1124 }
1125
1126 grub_ssize_t ventoy_load_file_with_prompt(grub_file_t file, void *buf, grub_ssize_t size)
1127 {
1128 grub_uint64_t ro = 0;
1129 grub_uint64_t div = 0;
1130 grub_ssize_t left = size;
1131 char *cur = (char *)buf;
1132
1133 grub_printf("\r%s 1%% ", g_vtoy_prompt_msg);
1134 grub_refresh();
1135
1136 while (left >= VTOY_SIZE_2MB)
1137 {
1138 grub_file_read(file, cur, VTOY_SIZE_2MB);
1139 cur += VTOY_SIZE_2MB;
1140 left -= VTOY_SIZE_2MB;
1141
1142 div = grub_divmod64((grub_uint64_t)((size - left) * 100), (grub_uint64_t)size, &ro);
1143 if (div < 1)
1144 {
1145 div = 1;
1146 }
1147 grub_printf("\r%s %d%% ", g_vtoy_prompt_msg, (int)div);
1148 grub_refresh();
1149 }
1150
1151 if (left > 0)
1152 {
1153 grub_file_read(file, cur, left);
1154 }
1155
1156 grub_printf("\r%s 100%% \n", g_vtoy_prompt_msg);
1157 grub_refresh();
1158
1159 return size;
1160 }
1161
1162 static grub_err_t ventoy_cmd_load_file_to_mem(grub_extcmd_context_t ctxt, int argc, char **args)
1163 {
1164 int rc = 1;
1165 char *buf = NULL;
1166 grub_file_t file;
1167 enum grub_file_type type;
1168
1169 (void)ctxt;
1170 (void)argc;
1171 (void)args;
1172
1173 if (argc != 3)
1174 {
1175 return rc;
1176 }
1177
1178 if (grub_strcmp(args[0], "nodecompress") == 0)
1179 {
1180 type = VENTOY_FILE_TYPE;
1181 }
1182 else
1183 {
1184 type = GRUB_FILE_TYPE_LINUX_INITRD;
1185 }
1186
1187 file = ventoy_grub_file_open(type, "%s", args[1]);
1188 if (file == NULL)
1189 {
1190 debug("failed to open file <%s>\n", args[1]);
1191 return 1;
1192 }
1193
1194 #ifdef GRUB_MACHINE_EFI
1195 buf = (char *)grub_efi_allocate_chain_buf(file->size);
1196 #else
1197 buf = (char *)grub_malloc(file->size);
1198 #endif
1199
1200 if (!buf)
1201 {
1202 grub_file_close(file);
1203 return 1;
1204 }
1205
1206 if (g_vtoy_load_prompt)
1207 {
1208 ventoy_load_file_with_prompt(file, buf, file->size);
1209 }
1210 else
1211 {
1212 grub_file_read(file, buf, file->size);
1213 }
1214
1215 ventoy_memfile_env_set(args[2], buf, (ulonglong)(file->size));
1216
1217 grub_file_close(file);
1218 rc = 0;
1219
1220 return rc;
1221 }
1222
1223 static grub_err_t ventoy_cmd_load_img_memdisk(grub_extcmd_context_t ctxt, int argc, char **args)
1224 {
1225 int rc = 1;
1226 int headlen;
1227 char *buf = NULL;
1228 grub_file_t file;
1229
1230 (void)ctxt;
1231 (void)argc;
1232 (void)args;
1233
1234 if (argc != 2)
1235 {
1236 return rc;
1237 }
1238
1239 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", args[0]);
1240 if (file == NULL)
1241 {
1242 debug("failed to open file <%s> for udf check\n", args[0]);
1243 return 1;
1244 }
1245
1246 headlen = sizeof(ventoy_chain_head);
1247
1248 #ifdef GRUB_MACHINE_EFI
1249 buf = (char *)grub_efi_allocate_iso_buf(headlen + file->size);
1250 #else
1251 buf = (char *)grub_malloc(headlen + file->size);
1252 #endif
1253
1254 ventoy_fill_os_param(file, (ventoy_os_param *)buf);
1255
1256 grub_file_read(file, buf + headlen, file->size);
1257
1258 ventoy_memfile_env_set(args[1], buf, (ulonglong)(file->size));
1259
1260 grub_file_close(file);
1261 rc = 0;
1262
1263 return rc;
1264 }
1265
1266 static grub_err_t ventoy_cmd_iso9660_is_joliet(grub_extcmd_context_t ctxt, int argc, char **args)
1267 {
1268 (void)ctxt;
1269 (void)argc;
1270 (void)args;
1271
1272 if (grub_iso9660_is_joliet())
1273 {
1274 debug("This time has joliet process\n");
1275 return 0;
1276 }
1277 else
1278 {
1279 return 1;
1280 }
1281 }
1282
1283 static grub_err_t ventoy_cmd_iso9660_nojoliet(grub_extcmd_context_t ctxt, int argc, char **args)
1284 {
1285 (void)ctxt;
1286
1287 if (argc != 1)
1288 {
1289 return 1;
1290 }
1291
1292 if (args[0][0] == '1')
1293 {
1294 grub_iso9660_set_nojoliet(1);
1295 }
1296 else
1297 {
1298 grub_iso9660_set_nojoliet(0);
1299 }
1300
1301 return 0;
1302 }
1303
1304 static grub_err_t ventoy_cmd_is_udf(grub_extcmd_context_t ctxt, int argc, char **args)
1305 {
1306 int i;
1307 int rc = 1;
1308 grub_file_t file;
1309 grub_uint8_t buf[32];
1310
1311 (void)ctxt;
1312 (void)argc;
1313 (void)args;
1314
1315 if (argc != 1)
1316 {
1317 return rc;
1318 }
1319
1320 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", args[0]);
1321 if (file == NULL)
1322 {
1323 debug("failed to open file <%s> for udf check\n", args[0]);
1324 return 1;
1325 }
1326
1327 for (i = 16; i < 32; i++)
1328 {
1329 grub_file_seek(file, i * 2048);
1330 grub_file_read(file, buf, sizeof(buf));
1331 if (buf[0] == 255)
1332 {
1333 break;
1334 }
1335 }
1336
1337 i++;
1338 grub_file_seek(file, i * 2048);
1339 grub_file_read(file, buf, sizeof(buf));
1340
1341 if (grub_memcmp(buf + 1, "BEA01", 5) == 0)
1342 {
1343 i++;
1344 grub_file_seek(file, i * 2048);
1345 grub_file_read(file, buf, sizeof(buf));
1346
1347 if (grub_memcmp(buf + 1, "NSR02", 5) == 0 ||
1348 grub_memcmp(buf + 1, "NSR03", 5) == 0)
1349 {
1350 rc = 0;
1351 }
1352 }
1353
1354 grub_file_close(file);
1355
1356 debug("ISO UDF: %s\n", rc ? "NO" : "YES");
1357
1358 return rc;
1359 }
1360
1361 static grub_err_t ventoy_cmd_cmp(grub_extcmd_context_t ctxt, int argc, char **args)
1362 {
1363 long value_long1 = 0;
1364 long value_long2 = 0;
1365
1366 if ((argc != 3) || (!ventoy_is_decimal(args[0])) || (!ventoy_is_decimal(args[2])))
1367 {
1368 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s {Int1} { eq|ne|gt|lt|ge|le } {Int2}", cmd_raw_name);
1369 }
1370
1371 value_long1 = grub_strtol(args[0], NULL, 10);
1372 value_long2 = grub_strtol(args[2], NULL, 10);
1373
1374 if (0 == grub_strcmp(args[1], "eq"))
1375 {
1376 grub_errno = (value_long1 == value_long2) ? GRUB_ERR_NONE : GRUB_ERR_TEST_FAILURE;
1377 }
1378 else if (0 == grub_strcmp(args[1], "ne"))
1379 {
1380 grub_errno = (value_long1 != value_long2) ? GRUB_ERR_NONE : GRUB_ERR_TEST_FAILURE;
1381 }
1382 else if (0 == grub_strcmp(args[1], "gt"))
1383 {
1384 grub_errno = (value_long1 > value_long2) ? GRUB_ERR_NONE : GRUB_ERR_TEST_FAILURE;
1385 }
1386 else if (0 == grub_strcmp(args[1], "lt"))
1387 {
1388 grub_errno = (value_long1 < value_long2) ? GRUB_ERR_NONE : GRUB_ERR_TEST_FAILURE;
1389 }
1390 else if (0 == grub_strcmp(args[1], "ge"))
1391 {
1392 grub_errno = (value_long1 >= value_long2) ? GRUB_ERR_NONE : GRUB_ERR_TEST_FAILURE;
1393 }
1394 else if (0 == grub_strcmp(args[1], "le"))
1395 {
1396 grub_errno = (value_long1 <= value_long2) ? GRUB_ERR_NONE : GRUB_ERR_TEST_FAILURE;
1397 }
1398 else
1399 {
1400 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s {Int1} { eq ne gt lt ge le } {Int2}", cmd_raw_name);
1401 }
1402
1403 return grub_errno;
1404 }
1405
1406 static grub_err_t ventoy_cmd_device(grub_extcmd_context_t ctxt, int argc, char **args)
1407 {
1408 char *pos = NULL;
1409 char buf[128] = {0};
1410
1411 if (argc != 2)
1412 {
1413 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s path var", cmd_raw_name);
1414 }
1415
1416 grub_strncpy(buf, (args[0][0] == '(') ? args[0] + 1 : args[0], sizeof(buf) - 1);
1417 pos = grub_strstr(buf, ",");
1418 if (pos)
1419 {
1420 *pos = 0;
1421 }
1422
1423 grub_env_set(args[1], buf);
1424
1425 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
1426 }
1427
1428 static grub_err_t ventoy_cmd_check_compatible(grub_extcmd_context_t ctxt, int argc, char **args)
1429 {
1430 int i;
1431 char buf[256];
1432 grub_disk_t disk;
1433 char *pos = NULL;
1434 const char *files[] = { "ventoy.dat", "VENTOY.DAT" };
1435
1436 (void)ctxt;
1437
1438 if (argc != 1)
1439 {
1440 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s (loop)", cmd_raw_name);
1441 }
1442
1443 for (i = 0; i < (int)ARRAY_SIZE(files); i++)
1444 {
1445 grub_snprintf(buf, sizeof(buf) - 1, "[ -e \"%s/%s\" ]", args[0], files[i]);
1446 if (0 == grub_script_execute_sourcecode(buf))
1447 {
1448 debug("file %s exist, ventoy_compatible YES\n", buf);
1449 grub_env_set("ventoy_compatible", "YES");
1450 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
1451 }
1452 else
1453 {
1454 debug("file %s NOT exist\n", buf);
1455 }
1456 }
1457
1458 grub_snprintf(buf, sizeof(buf) - 1, "%s", args[0][0] == '(' ? (args[0] + 1) : args[0]);
1459 pos = grub_strstr(buf, ")");
1460 if (pos)
1461 {
1462 *pos = 0;
1463 }
1464
1465 disk = grub_disk_open(buf);
1466 if (disk)
1467 {
1468 grub_disk_read(disk, 16 << 2, 0, 1024, g_img_swap_tmp_buf);
1469 grub_disk_close(disk);
1470
1471 g_img_swap_tmp_buf[703] = 0;
1472 for (i = 318; i < 703; i++)
1473 {
1474 if (g_img_swap_tmp_buf[i] == 'V' &&
1475 0 == grub_strncmp(g_img_swap_tmp_buf + i, VENTOY_COMPATIBLE_STR, VENTOY_COMPATIBLE_STR_LEN))
1476 {
1477 debug("Ventoy compatible string exist at %d, ventoy_compatible YES\n", i);
1478 grub_env_set("ventoy_compatible", "YES");
1479 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
1480 }
1481 }
1482 }
1483 else
1484 {
1485 debug("failed to open disk <%s>\n", buf);
1486 }
1487
1488 grub_env_set("ventoy_compatible", "NO");
1489 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
1490 }
1491
1492 int ventoy_cmp_img(img_info *img1, img_info *img2)
1493 {
1494 char *s1, *s2;
1495 int c1 = 0;
1496 int c2 = 0;
1497
1498 if (g_plugin_image_list == VENTOY_IMG_WHITE_LIST)
1499 {
1500 return (img1->plugin_list_index - img2->plugin_list_index);
1501 }
1502
1503 for (s1 = img1->name, s2 = img2->name; *s1 && *s2; s1++, s2++)
1504 {
1505 c1 = *s1;
1506 c2 = *s2;
1507
1508 if (0 == g_sort_case_sensitive)
1509 {
1510 if (grub_islower(c1))
1511 {
1512 c1 = c1 - 'a' + 'A';
1513 }
1514
1515 if (grub_islower(c2))
1516 {
1517 c2 = c2 - 'a' + 'A';
1518 }
1519 }
1520
1521 if (c1 != c2)
1522 {
1523 break;
1524 }
1525 }
1526
1527 return (c1 - c2);
1528 }
1529
1530 static int ventoy_cmp_subdir(img_iterator_node *node1, img_iterator_node *node2)
1531 {
1532 char *s1, *s2;
1533 int c1 = 0;
1534 int c2 = 0;
1535
1536 if (g_plugin_image_list == VENTOY_IMG_WHITE_LIST)
1537 {
1538 return (node1->plugin_list_index - node2->plugin_list_index);
1539 }
1540
1541 for (s1 = node1->dir, s2 = node2->dir; *s1 && *s2; s1++, s2++)
1542 {
1543 c1 = *s1;
1544 c2 = *s2;
1545
1546 if (0 == g_sort_case_sensitive)
1547 {
1548 if (grub_islower(c1))
1549 {
1550 c1 = c1 - 'a' + 'A';
1551 }
1552
1553 if (grub_islower(c2))
1554 {
1555 c2 = c2 - 'a' + 'A';
1556 }
1557 }
1558
1559 if (c1 != c2)
1560 {
1561 break;
1562 }
1563 }
1564
1565 return (c1 - c2);
1566 }
1567
1568 void ventoy_swap_img(img_info *img1, img_info *img2)
1569 {
1570 grub_memcpy(&g_img_swap_tmp, img1, sizeof(img_info));
1571
1572 grub_memcpy(img1, img2, sizeof(img_info));
1573 img1->next = g_img_swap_tmp.next;
1574 img1->prev = g_img_swap_tmp.prev;
1575
1576 g_img_swap_tmp.next = img2->next;
1577 g_img_swap_tmp.prev = img2->prev;
1578 grub_memcpy(img2, &g_img_swap_tmp, sizeof(img_info));
1579 }
1580
1581 int ventoy_img_name_valid(const char *filename, grub_size_t namelen)
1582 {
1583 (void)namelen;
1584
1585 if (g_filt_dot_underscore_file && filename[0] == '.' && filename[1] == '_')
1586 {
1587 return 0;
1588 }
1589
1590 return 1;
1591 }
1592
1593 static int ventoy_vlnk_iterate_partition(struct grub_disk *disk, const grub_partition_t partition, void *data)
1594 {
1595 ventoy_vlnk_part *node = NULL;
1596 grub_uint32_t SelfSig;
1597 grub_uint32_t *pSig = (grub_uint32_t *)data;
1598
1599 /* skip Ventoy partition 1/2 */
1600 grub_memcpy(&SelfSig, g_ventoy_part_info->MBR.BootCode + 0x1b8, 4);
1601 if (partition->number < 2 && SelfSig == *pSig)
1602 {
1603 return 0;
1604 }
1605
1606 node = grub_zalloc(sizeof(ventoy_vlnk_part));
1607 if (node)
1608 {
1609 node->disksig = *pSig;
1610 node->partoffset = (partition->start << GRUB_DISK_SECTOR_BITS);
1611 grub_snprintf(node->disk, sizeof(node->disk) - 1, "%s", disk->name);
1612 grub_snprintf(node->device, sizeof(node->device) - 1, "%s,%d", disk->name, partition->number + 1);
1613
1614 node->next = g_vlnk_part_list;
1615 g_vlnk_part_list = node;
1616 }
1617
1618 return 0;
1619 }
1620
1621 static int ventoy_vlnk_iterate_disk(const char *name, void *data)
1622 {
1623 grub_disk_t disk;
1624 grub_uint32_t sig;
1625
1626 (void)data;
1627
1628 disk = grub_disk_open(name);
1629 if (disk)
1630 {
1631 grub_disk_read(disk, 0, 0x1b8, 4, &sig);
1632 grub_partition_iterate(disk, ventoy_vlnk_iterate_partition, &sig);
1633 grub_disk_close(disk);
1634 }
1635
1636 return 0;
1637 }
1638
1639 static int ventoy_vlnk_probe_fs(ventoy_vlnk_part *cur)
1640 {
1641 const char *fs[ventoy_fs_max + 1] =
1642 {
1643 "exfat", "ntfs", "ext2", "xfs", "udf", "fat", NULL
1644 };
1645
1646 if (!cur->dev)
1647 {
1648 cur->dev = grub_device_open(cur->device);
1649 }
1650
1651 if (cur->dev)
1652 {
1653 cur->fs = grub_fs_list_probe(cur->dev, fs);
1654 }
1655
1656 return 0;
1657 }
1658
1659 static int ventoy_check_vlnk_data(ventoy_vlnk *vlnk, int print, char *dst, int size)
1660 {
1661 int diskfind = 0;
1662 int partfind = 0;
1663 int filefind = 0;
1664 char *disk, *device;
1665 grub_uint32_t readcrc, calccrc;
1666 ventoy_vlnk_part *cur;
1667 grub_fs_t fs = NULL;
1668
1669 if (grub_memcmp(&(vlnk->guid), &g_ventoy_guid, sizeof(ventoy_guid)))
1670 {
1671 if (print)
1672 {
1673 grub_printf("VLNK invalid guid\n");
1674 grub_refresh();
1675 }
1676 return 1;
1677 }
1678
1679 readcrc = vlnk->crc32;
1680 vlnk->crc32 = 0;
1681 calccrc = grub_getcrc32c(0, vlnk, sizeof(ventoy_vlnk));
1682 if (readcrc != calccrc)
1683 {
1684 if (print)
1685 {
1686 grub_printf("VLNK invalid crc 0x%08x 0x%08x\n", calccrc, readcrc);
1687 grub_refresh();
1688 }
1689 return 1;
1690 }
1691
1692 if (!g_vlnk_part_list)
1693 {
1694 grub_disk_dev_iterate(ventoy_vlnk_iterate_disk, NULL);
1695 }
1696
1697 for (cur = g_vlnk_part_list; cur && filefind == 0; cur = cur->next)
1698 {
1699 if (cur->disksig == vlnk->disk_signature)
1700 {
1701 diskfind = 1;
1702 disk = cur->disk;
1703 if (cur->partoffset == vlnk->part_offset)
1704 {
1705 partfind = 1;
1706 device = cur->device;
1707
1708 if (cur->probe == 0)
1709 {
1710 cur->probe = 1;
1711 ventoy_vlnk_probe_fs(cur);
1712 }
1713
1714 if (!fs)
1715 {
1716 fs = cur->fs;
1717 }
1718
1719 if (cur->fs)
1720 {
1721 struct grub_file file;
1722
1723 grub_memset(&file, 0, sizeof(file));
1724 file.device = cur->dev;
1725 if (cur->fs->fs_open(&file, vlnk->filepath) == GRUB_ERR_NONE)
1726 {
1727 filefind = 1;
1728 cur->fs->fs_close(&file);
1729 grub_snprintf(dst, size - 1, "(%s)%s", cur->device, vlnk->filepath);
1730 }
1731 }
1732 }
1733 }
1734 }
1735
1736 if (print)
1737 {
1738 grub_printf("\n==== VLNK Information ====\n"
1739 "Disk Signature: %08x\n"
1740 "Partition Offset: %llu\n"
1741 "File Path: <%s>\n\n",
1742 vlnk->disk_signature, (ulonglong)vlnk->part_offset, vlnk->filepath);
1743
1744 if (diskfind)
1745 {
1746 grub_printf("Disk Find: [ YES ] [ %s ]\n", disk);
1747 }
1748 else
1749 {
1750 grub_printf("Disk Find: [ NO ]\n");
1751 }
1752
1753 if (partfind)
1754 {
1755 grub_printf("Part Find: [ YES ] [ %s ] [ %s ]\n", device, fs ? fs->name : "N/A");
1756 }
1757 else
1758 {
1759 grub_printf("Part Find: [ NO ]\n");
1760 }
1761 grub_printf("File Find: [ %s ]\n", filefind ? "YES" : "NO");
1762 if (filefind)
1763 {
1764 grub_printf("VLNK File: <%s>\n", dst);
1765 }
1766
1767 grub_printf("\n");
1768 grub_refresh();
1769 }
1770
1771 return (1 - filefind);
1772 }
1773
1774 int ventoy_add_vlnk_file(char *dir, const char *name)
1775 {
1776 int rc = 1;
1777 char src[512];
1778 char dst[512];
1779 grub_file_t file = NULL;
1780 ventoy_vlnk vlnk;
1781
1782 if (!dir)
1783 {
1784 grub_snprintf(src, sizeof(src), "%s%s", g_iso_path, name);
1785 }
1786 else if (dir[0] == '/')
1787 {
1788 grub_snprintf(src, sizeof(src), "%s%s%s", g_iso_path, dir, name);
1789 }
1790 else
1791 {
1792 grub_snprintf(src, sizeof(src), "%s/%s%s", g_iso_path, dir, name);
1793 }
1794
1795 file = grub_file_open(src, VENTOY_FILE_TYPE);
1796 if (!file)
1797 {
1798 return 1;
1799 }
1800
1801 grub_memset(&vlnk, 0, sizeof(vlnk));
1802 grub_file_read(file, &vlnk, sizeof(vlnk));
1803 grub_file_close(file);
1804
1805 if (ventoy_check_vlnk_data(&vlnk, 0, dst, sizeof(dst)) == 0)
1806 {
1807 rc = grub_file_add_vlnk(src, dst);
1808 }
1809
1810 return rc;
1811 }
1812
1813 static int ventoy_collect_img_files(const char *filename, const struct grub_dirhook_info *info, void *data)
1814 {
1815 //int i = 0;
1816 int type = 0;
1817 int ignore = 0;
1818 int index = 0;
1819 int vlnk = 0;
1820 grub_size_t len;
1821 img_info *img;
1822 img_info *tail;
1823 const menu_tip *tip;
1824 img_iterator_node *tmp;
1825 img_iterator_node *new_node;
1826 img_iterator_node *node = (img_iterator_node *)data;
1827
1828 if (g_enumerate_time_checked == 0)
1829 {
1830 g_enumerate_finish_time_ms = grub_get_time_ms();
1831 if ((g_enumerate_finish_time_ms - g_enumerate_start_time_ms) >= 3000)
1832 {
1833 grub_cls();
1834 grub_printf("\n\n Ventoy scanning files, please wait...\n");
1835 grub_refresh();
1836 g_enumerate_time_checked = 1;
1837 }
1838 }
1839
1840 len = grub_strlen(filename);
1841
1842 if (info->dir)
1843 {
1844 if (node->level + 1 > g_img_max_search_level)
1845 {
1846 return 0;
1847 }
1848
1849 if ((len == 1 && filename[0] == '.') ||
1850 (len == 2 && filename[0] == '.' && filename[1] == '.'))
1851 {
1852 return 0;
1853 }
1854
1855 if (!ventoy_img_name_valid(filename, len))
1856 {
1857 return 0;
1858 }
1859
1860 if (filename[0] == '$' && 0 == grub_strncmp(filename, "$RECYCLE.BIN", 12))
1861 {
1862 return 0;
1863 }
1864
1865 if (g_plugin_image_list == VENTOY_IMG_WHITE_LIST)
1866 {
1867 grub_snprintf(g_img_swap_tmp_buf, sizeof(g_img_swap_tmp_buf), "%s%s/", node->dir, filename);
1868 index = ventoy_plugin_get_image_list_index(vtoy_class_directory, g_img_swap_tmp_buf);
1869 if (index == 0)
1870 {
1871 debug("Directory %s not found in image_list plugin config...\n", g_img_swap_tmp_buf);
1872 return 0;
1873 }
1874 }
1875
1876 new_node = grub_zalloc(sizeof(img_iterator_node));
1877 if (new_node)
1878 {
1879 new_node->level = node->level + 1;
1880 new_node->plugin_list_index = index;
1881 new_node->dirlen = grub_snprintf(new_node->dir, sizeof(new_node->dir), "%s%s/", node->dir, filename);
1882
1883 g_enum_fs->fs_dir(g_enum_dev, new_node->dir, ventoy_check_ignore_flag, &ignore);
1884 if (ignore)
1885 {
1886 debug("Directory %s ignored...\n", new_node->dir);
1887 grub_free(new_node);
1888 return 0;
1889 }
1890
1891 new_node->tail = node->tail;
1892
1893 new_node->parent = node;
1894 if (!node->firstchild)
1895 {
1896 node->firstchild = new_node;
1897 }
1898
1899 if (g_img_iterator_tail)
1900 {
1901 g_img_iterator_tail->next = new_node;
1902 g_img_iterator_tail = new_node;
1903 }
1904 else
1905 {
1906 g_img_iterator_head.next = new_node;
1907 g_img_iterator_tail = new_node;
1908 }
1909 }
1910 }
1911 else
1912 {
1913 debug("Find a file %s\n", filename);
1914 if (len < 4)
1915 {
1916 return 0;
1917 }
1918
1919 if (FILE_FLT(ISO) && 0 == grub_strcasecmp(filename + len - 4, ".iso"))
1920 {
1921 type = img_type_iso;
1922 }
1923 else if (FILE_FLT(WIM) && g_wimboot_enable && (0 == grub_strcasecmp(filename + len - 4, ".wim")))
1924 {
1925 type = img_type_wim;
1926 }
1927 else if (FILE_FLT(VHD) && g_vhdboot_enable && (0 == grub_strcasecmp(filename + len - 4, ".vhd") ||
1928 (len >= 5 && 0 == grub_strcasecmp(filename + len - 5, ".vhdx"))))
1929 {
1930 type = img_type_vhd;
1931 }
1932 #ifdef GRUB_MACHINE_EFI
1933 else if (FILE_FLT(EFI) && 0 == grub_strcasecmp(filename + len - 4, ".efi"))
1934 {
1935 type = img_type_efi;
1936 }
1937 #endif
1938 else if (FILE_FLT(IMG) && 0 == grub_strcasecmp(filename + len - 4, ".img"))
1939 {
1940 if (len == 18 && grub_strncmp(filename, "ventoy_", 7) == 0)
1941 {
1942 if (grub_strncmp(filename + 7, "wimboot", 7) == 0 ||
1943 grub_strncmp(filename + 7, "vhdboot", 7) == 0)
1944 {
1945 return 0;
1946 }
1947 }
1948 type = img_type_img;
1949 }
1950 else if (FILE_FLT(VTOY) && len >= 5 && 0 == grub_strcasecmp(filename + len - 5, ".vtoy"))
1951 {
1952 type = img_type_vtoy;
1953 }
1954 else if (len >= 9 && 0 == grub_strcasecmp(filename + len - 5, ".vcfg"))
1955 {
1956 if (filename[len - 9] == '.' || (len >= 10 && filename[len - 10] == '.'))
1957 {
1958 grub_snprintf(g_img_swap_tmp_buf, sizeof(g_img_swap_tmp_buf), "%s%s", node->dir, filename);
1959 ventoy_plugin_add_custom_boot(g_img_swap_tmp_buf);
1960 }
1961 return 0;
1962 }
1963 else
1964 {
1965 return 0;
1966 }
1967
1968 if (g_filt_dot_underscore_file && filename[0] == '.' && filename[1] == '_')
1969 {
1970 return 0;
1971 }
1972
1973 if (g_plugin_image_list)
1974 {
1975 grub_snprintf(g_img_swap_tmp_buf, sizeof(g_img_swap_tmp_buf), "%s%s", node->dir, filename);
1976 index = ventoy_plugin_get_image_list_index(vtoy_class_image_file, g_img_swap_tmp_buf);
1977 if (VENTOY_IMG_WHITE_LIST == g_plugin_image_list && index == 0)
1978 {
1979 debug("File %s not found in image_list plugin config...\n", g_img_swap_tmp_buf);
1980 return 0;
1981 }
1982 else if (VENTOY_IMG_BLACK_LIST == g_plugin_image_list && index > 0)
1983 {
1984 debug("File %s found in image_blacklist plugin config %d ...\n", g_img_swap_tmp_buf, index);
1985 return 0;
1986 }
1987 }
1988
1989 if (info->size == VTOY_FILT_MIN_FILE_SIZE || info->size == 0)
1990 {
1991 if (grub_file_is_vlnk_suffix(filename, len))
1992 {
1993 vlnk = 1;
1994 if (ventoy_add_vlnk_file(node->dir, filename) != 0)
1995 {
1996 return 0;
1997 }
1998 }
1999 }
2000
2001 img = grub_zalloc(sizeof(img_info));
2002 if (img)
2003 {
2004 img->type = type;
2005 img->plugin_list_index = index;
2006 grub_snprintf(img->name, sizeof(img->name), "%s", filename);
2007
2008 img->pathlen = grub_snprintf(img->path, sizeof(img->path), "%s%s", node->dir, img->name);
2009
2010 img->size = info->size;
2011 if (vlnk || 0 == img->size)
2012 {
2013 if (node->dir[0] == '/')
2014 {
2015 img->size = ventoy_grub_get_file_size("%s%s%s", g_iso_path, node->dir, filename);
2016 }
2017 else
2018 {
2019 img->size = ventoy_grub_get_file_size("%s/%s%s", g_iso_path, node->dir, filename);
2020 }
2021 }
2022
2023 if (img->size < VTOY_FILT_MIN_FILE_SIZE)
2024 {
2025 debug("img <%s> size too small %llu\n", img->name, (ulonglong)img->size);
2026 grub_free(img);
2027 return 0;
2028 }
2029
2030 if (g_ventoy_img_list)
2031 {
2032 tail = *(node->tail);
2033 img->prev = tail;
2034 tail->next = img;
2035 }
2036 else
2037 {
2038 g_ventoy_img_list = img;
2039 }
2040
2041 img->id = g_ventoy_img_count;
2042 img->parent = node;
2043 if (node && NULL == node->firstiso)
2044 {
2045 node->firstiso = img;
2046 }
2047
2048 node->isocnt++;
2049 tmp = node->parent;
2050 while (tmp)
2051 {
2052 tmp->isocnt++;
2053 tmp = tmp->parent;
2054 }
2055
2056 *((img_info **)(node->tail)) = img;
2057 g_ventoy_img_count++;
2058
2059 img->alias = ventoy_plugin_get_menu_alias(vtoy_alias_image_file, img->path);
2060
2061 tip = ventoy_plugin_get_menu_tip(vtoy_tip_image_file, img->path);
2062 if (tip)
2063 {
2064 img->tip1 = tip->tip1;
2065 img->tip2 = tip->tip2;
2066 }
2067
2068 img->class = ventoy_plugin_get_menu_class(vtoy_class_image_file, img->name, img->path);
2069 if (!img->class)
2070 {
2071 img->class = g_menu_class[type];
2072 }
2073 img->menu_prefix = g_menu_prefix[type];
2074
2075 if (img_type_iso == type)
2076 {
2077 if (ventoy_plugin_check_memdisk(img->path))
2078 {
2079 img->menu_prefix = "miso";
2080 }
2081 }
2082
2083 debug("Add %s%s to list %d\n", node->dir, filename, g_ventoy_img_count);
2084 }
2085 }
2086
2087 return 0;
2088 }
2089
2090 int ventoy_fill_data(grub_uint32_t buflen, char *buffer)
2091 {
2092 int len = GRUB_UINT_MAX;
2093 const char *value = NULL;
2094 char name[32] = {0};
2095 char plat[32] = {0};
2096 char guidstr[32] = {0};
2097 ventoy_guid guid = VENTOY_GUID;
2098 const char *fmt1 = NULL;
2099 const char *fmt2 = NULL;
2100 const char *fmt3 = NULL;
2101 grub_uint32_t *puint = (grub_uint32_t *)name;
2102 grub_uint32_t *puint2 = (grub_uint32_t *)plat;
2103 const char fmtdata[]={ 0x39, 0x35, 0x25, 0x00, 0x35, 0x00, 0x23, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x00 };
2104 const char fmtcode[]={
2105 0x22, 0x0A, 0x2B, 0x20, 0x68, 0x62, 0x6F, 0x78, 0x20, 0x7B, 0x0A, 0x20, 0x20, 0x74, 0x6F, 0x70,
2106 0x20, 0x3D, 0x20, 0x25, 0x73, 0x0A, 0x20, 0x20, 0x6C, 0x65, 0x66, 0x74, 0x20, 0x3D, 0x20, 0x25,
2107 0x73, 0x0A, 0x20, 0x20, 0x2B, 0x20, 0x6C, 0x61, 0x62, 0x65, 0x6C, 0x20, 0x7B, 0x74, 0x65, 0x78,
2108 0x74, 0x20, 0x3D, 0x20, 0x22, 0x25, 0x73, 0x20, 0x25, 0x73, 0x25, 0x73, 0x22, 0x20, 0x63, 0x6F,
2109 0x6C, 0x6F, 0x72, 0x20, 0x3D, 0x20, 0x22, 0x25, 0x73, 0x22, 0x20, 0x61, 0x6C, 0x69, 0x67, 0x6E,
2110 0x20, 0x3D, 0x20, 0x22, 0x6C, 0x65, 0x66, 0x74, 0x22, 0x7D, 0x0A, 0x7D, 0x0A, 0x22, 0x00
2111 };
2112
2113 grub_memset(name, 0, sizeof(name));
2114 puint[0] = grub_swap_bytes32(0x56454e54);
2115 puint[3] = grub_swap_bytes32(0x4f4e0000);
2116 puint[2] = grub_swap_bytes32(0x45525349);
2117 puint[1] = grub_swap_bytes32(0x4f595f56);
2118 value = ventoy_get_env(name);
2119
2120 grub_memset(name, 0, sizeof(name));
2121 puint[1] = grub_swap_bytes32(0x5f544f50);
2122 puint[0] = grub_swap_bytes32(0x56544c45);
2123 fmt1 = ventoy_get_env(name);
2124 if (!fmt1)
2125 {
2126 fmt1 = fmtdata;
2127 }
2128
2129 grub_memset(name, 0, sizeof(name));
2130 puint[1] = grub_swap_bytes32(0x5f4c4654);
2131 puint[0] = grub_swap_bytes32(0x56544c45);
2132 fmt2 = ventoy_get_env(name);
2133
2134 grub_memset(name, 0, sizeof(name));
2135 puint[1] = grub_swap_bytes32(0x5f434c52);
2136 puint[0] = grub_swap_bytes32(0x56544c45);
2137 fmt3 = ventoy_get_env(name);
2138
2139 grub_memcpy(guidstr, &guid, sizeof(guid));
2140
2141 puint2[0] = grub_swap_bytes32(g_ventoy_plat_data);
2142
2143 /* Easter egg :) It will be appreciated if you reserve it, but NOT mandatory. */
2144 #pragma GCC diagnostic push
2145 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
2146 len = grub_snprintf(buffer, buflen, fmtcode,
2147 fmt1 ? fmt1 : fmtdata,
2148 fmt2 ? fmt2 : fmtdata + 4,
2149 value ? value : "", plat, guidstr,
2150 fmt3 ? fmt3 : fmtdata + 6);
2151 #pragma GCC diagnostic pop
2152
2153 grub_memset(name, 0, sizeof(name));
2154 puint[0] = grub_swap_bytes32(0x76746f79);
2155 puint[2] = grub_swap_bytes32(0x656e7365);
2156 puint[1] = grub_swap_bytes32(0x5f6c6963);
2157 ventoy_set_env(name, guidstr);
2158
2159 return len;
2160 }
2161
2162 static int
2163 ventoy_password_get (char buf[], unsigned buf_size)
2164 {
2165 unsigned i, cur_len = 0;
2166 int key;
2167 struct grub_term_coordinate *pos = grub_term_save_pos ();
2168
2169 while (1)
2170 {
2171 key = grub_getkey ();
2172 if (key == '\n' || key == '\r')
2173 break;
2174
2175 if (key == GRUB_TERM_ESC)
2176 {
2177 cur_len = 0;
2178 break;
2179 }
2180
2181 if (key == '\b')
2182 {
2183 if (cur_len)
2184 {
2185 grub_term_restore_pos (pos);
2186 for (i = 0; i < cur_len; i++)
2187 grub_xputs (" ");
2188 grub_term_restore_pos (pos);
2189 cur_len--;
2190 for (i = 0; i < cur_len; i++)
2191 grub_xputs ("*");
2192 grub_refresh ();
2193 }
2194 continue;
2195 }
2196
2197 if (!grub_isprint (key))
2198 continue;
2199
2200 if (cur_len + 2 < buf_size)
2201 buf[cur_len++] = key;
2202 grub_xputs ("*");
2203 grub_refresh ();
2204 }
2205
2206 grub_memset (buf + cur_len, 0, buf_size - cur_len);
2207
2208 grub_xputs ("\n");
2209 grub_refresh ();
2210 grub_free (pos);
2211
2212 return (key != GRUB_TERM_ESC);
2213 }
2214
2215 static int ventoy_get_password(char buf[], unsigned buf_size)
2216 {
2217 const char *env = NULL;
2218
2219 env = grub_env_get("VTOY_SHOW_PASSWORD_ASTERISK");
2220 if (env && env[0] == '0' && env[1] == 0)
2221 {
2222 return grub_password_get(buf, buf_size);
2223 }
2224 else
2225 {
2226 return ventoy_password_get(buf, buf_size);
2227 }
2228 }
2229
2230 int ventoy_check_password(const vtoy_password *pwd, int retry)
2231 {
2232 int offset;
2233 char input[256];
2234 grub_uint8_t md5[16];
2235
2236 while (retry--)
2237 {
2238 grub_memset(input, 0, sizeof(input));
2239
2240 grub_printf("Enter password: ");
2241 grub_refresh();
2242
2243 if (pwd->type == VTOY_PASSWORD_TXT)
2244 {
2245 ventoy_get_password(input, 128);
2246 if (grub_strcmp(pwd->text, input) == 0)
2247 {
2248 return 0;
2249 }
2250 }
2251 else if (pwd->type == VTOY_PASSWORD_MD5)
2252 {
2253 ventoy_get_password(input, 128);
2254 grub_crypto_hash(GRUB_MD_MD5, md5, input, grub_strlen(input));
2255 if (grub_memcmp(pwd->md5, md5, 16) == 0)
2256 {
2257 return 0;
2258 }
2259 }
2260 else if (pwd->type == VTOY_PASSWORD_SALT_MD5)
2261 {
2262 offset = (int)grub_snprintf(input, 128, "%s", pwd->salt);
2263 ventoy_get_password(input + offset, 128);
2264
2265 grub_crypto_hash(GRUB_MD_MD5, md5, input, grub_strlen(input));
2266 if (grub_memcmp(pwd->md5, md5, 16) == 0)
2267 {
2268 return 0;
2269 }
2270 }
2271
2272 grub_printf("Invalid password!\n\n");
2273 grub_refresh();
2274 }
2275
2276 return 1;
2277 }
2278
2279 static img_info * ventoy_get_min_iso(img_iterator_node *node)
2280 {
2281 img_info *minimg = NULL;
2282 img_info *img = (img_info *)(node->firstiso);
2283
2284 while (img && (img_iterator_node *)(img->parent) == node)
2285 {
2286 if (img->select == 0 && (NULL == minimg || ventoy_cmp_img(img, minimg) < 0))
2287 {
2288 minimg = img;
2289 }
2290 img = img->next;
2291 }
2292
2293 if (minimg)
2294 {
2295 minimg->select = 1;
2296 }
2297
2298 return minimg;
2299 }
2300
2301 static img_iterator_node * ventoy_get_min_child(img_iterator_node *node)
2302 {
2303 img_iterator_node *Minchild = NULL;
2304 img_iterator_node *child = node->firstchild;
2305
2306 while (child && child->parent == node)
2307 {
2308 if (child->select == 0 && (NULL == Minchild || ventoy_cmp_subdir(child, Minchild) < 0))
2309 {
2310 Minchild = child;
2311 }
2312 child = child->next;
2313 }
2314
2315 if (Minchild)
2316 {
2317 Minchild->select = 1;
2318 }
2319
2320 return Minchild;
2321 }
2322
2323 static int ventoy_dynamic_tree_menu(img_iterator_node *node)
2324 {
2325 int offset = 1;
2326 img_info *img = NULL;
2327 const char *dir_class = NULL;
2328 const char *dir_alias = NULL;
2329 img_iterator_node *child = NULL;
2330 const menu_tip *tip = NULL;
2331
2332 if (node->isocnt == 0 || node->done == 1)
2333 {
2334 return 0;
2335 }
2336
2337 if (node->parent && node->parent->dirlen < node->dirlen)
2338 {
2339 offset = node->parent->dirlen;
2340 }
2341
2342 if (node == &g_img_iterator_head)
2343 {
2344 if (g_default_menu_mode == 0)
2345 {
2346 if (g_tree_view_menu_style == 0)
2347 {
2348 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos,
2349 "menuentry \"%-10s [Return to ListView]\" --class=\"vtoyret\" VTOY_RET {\n "
2350 " echo 'return ...' \n"
2351 "}\n", "<--");
2352 }
2353 else
2354 {
2355 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos,
2356 "menuentry \"[Return to ListView]\" --class=\"vtoyret\" VTOY_RET {\n "
2357 " echo 'return ...' \n"
2358 "}\n");
2359 }
2360 }
2361
2362 g_tree_script_pre = g_tree_script_pos;
2363 }
2364 else
2365 {
2366 node->dir[node->dirlen - 1] = 0;
2367 dir_class = ventoy_plugin_get_menu_class(vtoy_class_directory, node->dir, node->dir);
2368 if (!dir_class)
2369 {
2370 dir_class = "vtoydir";
2371 }
2372
2373 tip = ventoy_plugin_get_menu_tip(vtoy_tip_directory, node->dir);
2374
2375 dir_alias = ventoy_plugin_get_menu_alias(vtoy_alias_directory, node->dir);
2376 if (dir_alias)
2377 {
2378 if (g_tree_view_menu_style == 0)
2379 {
2380 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos,
2381 "submenu \"%-10s %s\" --class=\"%s\" --id=\"DIR_%s\" _VTIP_%p {\n",
2382 "DIR", dir_alias, dir_class, node->dir + offset, tip);
2383 }
2384 else
2385 {
2386 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos,
2387 "submenu \"%s\" --class=\"%s\" --id=\"DIR_%s\" _VTIP_%p {\n",
2388 dir_alias, dir_class, node->dir + offset, tip);
2389 }
2390 }
2391 else
2392 {
2393 dir_alias = node->dir + offset;
2394
2395 if (g_tree_view_menu_style == 0)
2396 {
2397 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos,
2398 "submenu \"%-10s [%s]\" --class=\"%s\" --id=\"DIR_%s\" _VTIP_%p {\n",
2399 "DIR", dir_alias, dir_class, node->dir + offset, tip);
2400 }
2401 else
2402 {
2403 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos,
2404 "submenu \"[%s]\" --class=\"%s\" --id=\"DIR_%s\" _VTIP_%p {\n",
2405 dir_alias, dir_class, node->dir + offset, tip);
2406 }
2407 }
2408
2409 if (g_tree_view_menu_style == 0)
2410 {
2411 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos,
2412 "menuentry \"%-10s [%s/..]\" --class=\"vtoyret\" VTOY_RET {\n "
2413 " echo 'return ...' \n"
2414 "}\n", "<--", node->dir);
2415 }
2416 else
2417 {
2418 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos,
2419 "menuentry \"[%s/..]\" --class=\"vtoyret\" VTOY_RET {\n "
2420 " echo 'return ...' \n"
2421 "}\n", node->dir);
2422 }
2423 }
2424
2425 while ((child = ventoy_get_min_child(node)) != NULL)
2426 {
2427 ventoy_dynamic_tree_menu(child);
2428 }
2429
2430 while ((img = ventoy_get_min_iso(node)) != NULL)
2431 {
2432 if (g_tree_view_menu_style == 0)
2433 {
2434 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos,
2435 "menuentry \"%-10s %s%s\" --class=\"%s\" --id=\"VID_%p\" {\n"
2436 " %s_%s \n"
2437 "}\n",
2438 grub_get_human_size(img->size, GRUB_HUMAN_SIZE_SHORT),
2439 img->unsupport ? "[***********] " : "",
2440 img->alias ? img->alias : img->name, img->class, img,
2441 img->menu_prefix,
2442 img->unsupport ? "unsupport_menuentry" : "common_menuentry");
2443 }
2444 else
2445 {
2446 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos,
2447 "menuentry \"%s%s\" --class=\"%s\" --id=\"VID_%p\" {\n"
2448 " %s_%s \n"
2449 "}\n",
2450 img->unsupport ? "[***********] " : "",
2451 img->alias ? img->alias : img->name, img->class, img,
2452 img->menu_prefix,
2453 img->unsupport ? "unsupport_menuentry" : "common_menuentry");
2454 }
2455 }
2456
2457 if (node != &g_img_iterator_head)
2458 {
2459 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos, "}\n");
2460 }
2461
2462 node->done = 1;
2463 return 0;
2464 }
2465
2466 static int ventoy_set_default_menu(void)
2467 {
2468 int img_len = 0;
2469 char *pos = NULL;
2470 char *end = NULL;
2471 char *def = NULL;
2472 const char *strdata = NULL;
2473 img_info *cur = NULL;
2474 img_info *default_node = NULL;
2475 const char *default_image = NULL;
2476
2477 default_image = ventoy_get_env("VTOY_DEFAULT_IMAGE");
2478 if (default_image && default_image[0] == '/')
2479 {
2480 img_len = grub_strlen(default_image);
2481
2482 for (cur = g_ventoy_img_list; cur; cur = cur->next)
2483 {
2484 if (img_len == cur->pathlen && grub_strcmp(default_image, cur->path) == 0)
2485 {
2486 default_node = cur;
2487 break;
2488 }
2489 }
2490
2491 if (!default_node)
2492 {
2493 return 1;
2494 }
2495
2496 if (0 == g_default_menu_mode)
2497 {
2498 vtoy_ssprintf(g_list_script_buf, g_list_script_pos, "set default='VID_%p'\n", default_node);
2499 }
2500 else
2501 {
2502 def = grub_strdup(default_image);
2503 if (!def)
2504 {
2505 return 1;
2506 }
2507
2508 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos, "set default=%c", '\'');
2509
2510 strdata = ventoy_get_env("VTOY_DEFAULT_SEARCH_ROOT");
2511 if (strdata && strdata[0] == '/')
2512 {
2513 pos = def + grub_strlen(strdata);
2514 if (*pos == '/')
2515 {
2516 pos++;
2517 }
2518 }
2519 else
2520 {
2521 pos = def + 1;
2522 }
2523
2524 while ((end = grub_strchr(pos, '/')) != NULL)
2525 {
2526 *end = 0;
2527 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos, "DIR_%s>", pos);
2528 pos = end + 1;
2529 }
2530
2531 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos, "VID_%p'\n", default_node);
2532 grub_free(def);
2533 }
2534 }
2535
2536 return 0;
2537 }
2538
2539 static grub_err_t ventoy_cmd_clear_img(grub_extcmd_context_t ctxt, int argc, char **args)
2540 {
2541 img_info *next = NULL;
2542 img_info *cur = g_ventoy_img_list;
2543
2544 (void)ctxt;
2545 (void)argc;
2546 (void)args;
2547
2548 while (cur)
2549 {
2550 next = cur->next;
2551 grub_free(cur);
2552 cur = next;
2553 }
2554
2555 g_ventoy_img_list = NULL;
2556 g_ventoy_img_count = 0;
2557
2558 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
2559 }
2560
2561 static grub_err_t ventoy_cmd_img_name(grub_extcmd_context_t ctxt, int argc, char **args)
2562 {
2563 long img_id = 0;
2564 img_info *cur = g_ventoy_img_list;
2565
2566 (void)ctxt;
2567
2568 if (argc != 2 || (!ventoy_is_decimal(args[0])))
2569 {
2570 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s {imageID} {var}", cmd_raw_name);
2571 }
2572
2573 img_id = grub_strtol(args[0], NULL, 10);
2574 if (img_id >= g_ventoy_img_count)
2575 {
2576 return grub_error(GRUB_ERR_BAD_ARGUMENT, "No such many images %ld %ld", img_id, g_ventoy_img_count);
2577 }
2578
2579 debug("Find image %ld name \n", img_id);
2580
2581 while (cur && img_id > 0)
2582 {
2583 img_id--;
2584 cur = cur->next;
2585 }
2586
2587 if (!cur)
2588 {
2589 return grub_error(GRUB_ERR_BAD_ARGUMENT, "No such many images");
2590 }
2591
2592 debug("image name is %s\n", cur->name);
2593
2594 grub_env_set(args[1], cur->name);
2595
2596 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
2597 }
2598
2599 static grub_err_t ventoy_cmd_ext_select_img_path(grub_extcmd_context_t ctxt, int argc, char **args)
2600 {
2601 int len = 0;
2602 char id[32] = {0};
2603 img_info *cur = g_ventoy_img_list;
2604
2605 (void)ctxt;
2606
2607 if (argc != 1)
2608 {
2609 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s {var}", cmd_raw_name);
2610 }
2611
2612 len = (int)grub_strlen(args[0]);
2613
2614 while (cur)
2615 {
2616 if (len == cur->pathlen && 0 == grub_strcmp(args[0], cur->path))
2617 {
2618 break;
2619 }
2620 cur = cur->next;
2621 }
2622
2623 if (!cur)
2624 {
2625 return grub_error(GRUB_ERR_BAD_ARGUMENT, "No such image");
2626 }
2627
2628 grub_snprintf(id, sizeof(id), "VID_%p", cur);
2629 grub_env_set("chosen", id);
2630 grub_env_export("chosen");
2631
2632 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
2633 }
2634
2635 static char g_fake_vlnk_src[512];
2636 static char g_fake_vlnk_dst[512];
2637 static grub_uint64_t g_fake_vlnk_size;
2638 static grub_err_t ventoy_cmd_set_fake_vlnk(grub_extcmd_context_t ctxt, int argc, char **args)
2639 {
2640 (void)ctxt;
2641 (void)argc;
2642 (void)args;
2643
2644 g_fake_vlnk_size = (grub_uint64_t)grub_strtoull(args[2], NULL, 10);
2645
2646 grub_strncpy(g_fake_vlnk_dst, args[0], sizeof(g_fake_vlnk_dst));
2647 grub_snprintf(g_fake_vlnk_src, sizeof(g_fake_vlnk_src), "%s/________VENTOYVLNK.vlnk.%s", g_iso_path, args[1]);
2648
2649 grub_file_vtoy_vlnk(g_fake_vlnk_src, g_fake_vlnk_dst);
2650
2651 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
2652 }
2653
2654 static grub_err_t ventoy_cmd_reset_fake_vlnk(grub_extcmd_context_t ctxt, int argc, char **args)
2655 {
2656 (void)ctxt;
2657 (void)argc;
2658 (void)args;
2659
2660 g_fake_vlnk_src[0] = 0;
2661 g_fake_vlnk_dst[0] = 0;
2662 g_fake_vlnk_size = 0;
2663 grub_file_vtoy_vlnk(NULL, NULL);
2664
2665 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
2666 }
2667
2668
2669 static grub_err_t ventoy_cmd_chosen_img_path(grub_extcmd_context_t ctxt, int argc, char **args)
2670 {
2671 char value[32];
2672 char *pos = NULL;
2673 char *last = NULL;
2674 const char *id = NULL;
2675 img_info *cur = NULL;
2676
2677 (void)ctxt;
2678
2679 if (argc < 1 || argc > 3)
2680 {
2681 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s {var}", cmd_raw_name);
2682 }
2683
2684 if (g_fake_vlnk_src[0] && g_fake_vlnk_dst[0])
2685 {
2686 pos = grub_strchr(g_fake_vlnk_src, '/');
2687 grub_env_set(args[0], pos);
2688 if (argc > 1)
2689 {
2690 grub_snprintf(value, sizeof(value), "%llu", (ulonglong)(g_fake_vlnk_size));
2691 grub_env_set(args[1], value);
2692 }
2693
2694 if (argc > 2)
2695 {
2696 for (last = pos; *pos; pos++)
2697 {
2698 if (*pos == '/')
2699 {
2700 last = pos;
2701 }
2702 }
2703 grub_env_set(args[2], last + 1);
2704 }
2705
2706 goto end;
2707 }
2708
2709 id = grub_env_get("chosen");
2710
2711 pos = grub_strstr(id, "VID_");
2712 if (pos)
2713 {
2714 cur = (img_info *)(void *)grub_strtoul(pos + 4, NULL, 16);
2715 }
2716 else
2717 {
2718 cur = g_ventoy_img_list;
2719 }
2720
2721 if (!cur)
2722 {
2723 return grub_error(GRUB_ERR_BAD_ARGUMENT, "No such image");
2724 }
2725
2726 grub_env_set(args[0], cur->path);
2727
2728 if (argc > 1)
2729 {
2730 grub_snprintf(value, sizeof(value), "%llu", (ulonglong)(cur->size));
2731 grub_env_set(args[1], value);
2732 }
2733
2734 if (argc > 2)
2735 {
2736 grub_snprintf(value, sizeof(value), "%llu", (ulonglong)(cur->size));
2737 grub_env_set(args[2], cur->name);
2738 }
2739
2740 end:
2741 g_svd_replace_offset = 0;
2742
2743 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
2744 }
2745
2746
2747 static grub_err_t ventoy_cmd_list_img(grub_extcmd_context_t ctxt, int argc, char **args)
2748 {
2749 int len;
2750 grub_fs_t fs;
2751 grub_device_t dev = NULL;
2752 img_info *cur = NULL;
2753 img_info *tail = NULL;
2754 img_info *min = NULL;
2755 img_info *head = NULL;
2756 const char *strdata = NULL;
2757 char *device_name = NULL;
2758 char buf[32];
2759 img_iterator_node *node = NULL;
2760 img_iterator_node *tmp = NULL;
2761
2762 (void)ctxt;
2763
2764 if (argc != 2)
2765 {
2766 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s {device} {cntvar}", cmd_raw_name);
2767 }
2768
2769 if (g_ventoy_img_list || g_ventoy_img_count)
2770 {
2771 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Must clear image before list");
2772 }
2773
2774 VTOY_CMD_CHECK(1);
2775
2776 g_enumerate_time_checked = 0;
2777 g_enumerate_start_time_ms = grub_get_time_ms();
2778
2779 strdata = ventoy_get_env("VTOY_FILT_DOT_UNDERSCORE_FILE");
2780 if (strdata && strdata[0] == '1' && strdata[1] == 0)
2781 {
2782 g_filt_dot_underscore_file = 1;
2783 }
2784
2785 strdata = ventoy_get_env("VTOY_SORT_CASE_SENSITIVE");
2786 if (strdata && strdata[0] == '1' && strdata[1] == 0)
2787 {
2788 g_sort_case_sensitive = 1;
2789 }
2790
2791 device_name = grub_file_get_device_name(args[0]);
2792 if (!device_name)
2793 {
2794 goto fail;
2795 }
2796
2797 g_enum_dev = dev = grub_device_open(device_name);
2798 if (!dev)
2799 {
2800 goto fail;
2801 }
2802
2803 g_enum_fs = fs = grub_fs_probe(dev);
2804 if (!fs)
2805 {
2806 goto fail;
2807 }
2808
2809 if (ventoy_get_fs_type(fs->name) >= ventoy_fs_max)
2810 {
2811 debug("unsupported fs:<%s>\n", fs->name);
2812 ventoy_set_env("VTOY_NO_ISO_TIP", "unsupported file system");
2813 goto fail;
2814 }
2815
2816 ventoy_set_env("vtoy_iso_fs", fs->name);
2817
2818 strdata = ventoy_get_env("VTOY_DEFAULT_MENU_MODE");
2819 if (strdata && strdata[0] == '1')
2820 {
2821 g_default_menu_mode = 1;
2822 }
2823
2824 grub_memset(&g_img_iterator_head, 0, sizeof(g_img_iterator_head));
2825
2826 grub_snprintf(g_iso_path, sizeof(g_iso_path), "%s", args[0]);
2827
2828 strdata = ventoy_get_env("VTOY_DEFAULT_SEARCH_ROOT");
2829 if (strdata && strdata[0] == '/')
2830 {
2831 len = grub_snprintf(g_img_iterator_head.dir, sizeof(g_img_iterator_head.dir) - 1, "%s", strdata);
2832 if (g_img_iterator_head.dir[len - 1] != '/')
2833 {
2834 g_img_iterator_head.dir[len++] = '/';
2835 }
2836 g_img_iterator_head.dirlen = len;
2837 }
2838 else
2839 {
2840 g_img_iterator_head.dirlen = 1;
2841 grub_strcpy(g_img_iterator_head.dir, "/");
2842 }
2843
2844 g_img_iterator_head.tail = &tail;
2845
2846 if (g_img_max_search_level < 0)
2847 {
2848 g_img_max_search_level = GRUB_INT_MAX;
2849 strdata = ventoy_get_env("VTOY_MAX_SEARCH_LEVEL");
2850 if (strdata && ventoy_is_decimal(strdata))
2851 {
2852 g_img_max_search_level = (int)grub_strtoul(strdata, NULL, 10);
2853 }
2854 }
2855
2856 g_vtoy_file_flt[VTOY_FILE_FLT_ISO] = ventoy_control_get_flag("VTOY_FILE_FLT_ISO");
2857 g_vtoy_file_flt[VTOY_FILE_FLT_WIM] = ventoy_control_get_flag("VTOY_FILE_FLT_WIM");
2858 g_vtoy_file_flt[VTOY_FILE_FLT_EFI] = ventoy_control_get_flag("VTOY_FILE_FLT_EFI");
2859 g_vtoy_file_flt[VTOY_FILE_FLT_IMG] = ventoy_control_get_flag("VTOY_FILE_FLT_IMG");
2860 g_vtoy_file_flt[VTOY_FILE_FLT_VHD] = ventoy_control_get_flag("VTOY_FILE_FLT_VHD");
2861 g_vtoy_file_flt[VTOY_FILE_FLT_VTOY] = ventoy_control_get_flag("VTOY_FILE_FLT_VTOY");
2862
2863 for (node = &g_img_iterator_head; node; node = node->next)
2864 {
2865 fs->fs_dir(dev, node->dir, ventoy_collect_img_files, node);
2866 }
2867
2868 strdata = ventoy_get_env("VTOY_TREE_VIEW_MENU_STYLE");
2869 if (strdata && strdata[0] == '1' && strdata[1] == 0)
2870 {
2871 g_tree_view_menu_style = 1;
2872 }
2873
2874 ventoy_set_default_menu();
2875
2876 for (node = &g_img_iterator_head; node; node = node->next)
2877 {
2878 ventoy_dynamic_tree_menu(node);
2879 }
2880
2881 /* free node */
2882 node = g_img_iterator_head.next;
2883 while (node)
2884 {
2885 tmp = node->next;
2886 grub_free(node);
2887 node = tmp;
2888 }
2889
2890 /* sort image list by image name */
2891 while (g_ventoy_img_list)
2892 {
2893 min = g_ventoy_img_list;
2894 for (cur = g_ventoy_img_list->next; cur; cur = cur->next)
2895 {
2896 if (ventoy_cmp_img(min, cur) > 0)
2897 {
2898 min = cur;
2899 }
2900 }
2901
2902 if (min->prev)
2903 {
2904 min->prev->next = min->next;
2905 }
2906
2907 if (min->next)
2908 {
2909 min->next->prev = min->prev;
2910 }
2911
2912 if (min == g_ventoy_img_list)
2913 {
2914 g_ventoy_img_list = min->next;
2915 }
2916
2917 if (head == NULL)
2918 {
2919 head = tail = min;
2920 min->prev = NULL;
2921 min->next = NULL;
2922 }
2923 else
2924 {
2925 tail->next = min;
2926 min->prev = tail;
2927 min->next = NULL;
2928 tail = min;
2929 }
2930 }
2931
2932 g_ventoy_img_list = head;
2933
2934 if (g_default_menu_mode == 1)
2935 {
2936 vtoy_ssprintf(g_list_script_buf, g_list_script_pos,
2937 "menuentry \"%s [Return to TreeView]\" --class=\"vtoyret\" VTOY_RET {\n "
2938 " echo 'return ...' \n"
2939 "}\n", "<--");
2940 }
2941
2942 for (cur = g_ventoy_img_list; cur; cur = cur->next)
2943 {
2944 vtoy_ssprintf(g_list_script_buf, g_list_script_pos,
2945 "menuentry \"%s%s\" --class=\"%s\" --id=\"VID_%p\" {\n"
2946 " %s_%s \n"
2947 "}\n",
2948 cur->unsupport ? "[***********] " : "",
2949 cur->alias ? cur->alias : cur->name, cur->class, cur,
2950 cur->menu_prefix,
2951 cur->unsupport ? "unsupport_menuentry" : "common_menuentry");
2952 }
2953
2954 g_tree_script_buf[g_tree_script_pos] = 0;
2955 g_list_script_buf[g_list_script_pos] = 0;
2956
2957 grub_snprintf(buf, sizeof(buf), "%d", g_ventoy_img_count);
2958 grub_env_set(args[1], buf);
2959
2960 fail:
2961
2962 check_free(device_name, grub_free);
2963 check_free(dev, grub_device_close);
2964
2965 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
2966 }
2967
2968 int ventoy_get_disk_guid(const char *filename, grub_uint8_t *guid, grub_uint8_t *signature)
2969 {
2970 grub_disk_t disk;
2971 char *device_name;
2972 char *pos;
2973 char *pos2;
2974
2975 device_name = grub_file_get_device_name(filename);
2976 if (!device_name)
2977 {
2978 return 1;
2979 }
2980
2981 pos = device_name;
2982 if (pos[0] == '(')
2983 {
2984 pos++;
2985 }
2986
2987 pos2 = grub_strstr(pos, ",");
2988 if (!pos2)
2989 {
2990 pos2 = grub_strstr(pos, ")");
2991 }
2992
2993 if (pos2)
2994 {
2995 *pos2 = 0;
2996 }
2997
2998 disk = grub_disk_open(pos);
2999 if (disk)
3000 {
3001 grub_disk_read(disk, 0, 0x180, 16, guid);
3002 grub_disk_read(disk, 0, 0x1b8, 4, signature);
3003 grub_disk_close(disk);
3004 }
3005 else
3006 {
3007 return 1;
3008 }
3009
3010 grub_free(device_name);
3011 return 0;
3012 }
3013
3014 grub_uint32_t ventoy_get_iso_boot_catlog(grub_file_t file)
3015 {
3016 eltorito_descriptor desc;
3017
3018 grub_memset(&desc, 0, sizeof(desc));
3019 grub_file_seek(file, 17 * 2048);
3020 grub_file_read(file, &desc, sizeof(desc));
3021
3022 if (desc.type != 0 || desc.version != 1)
3023 {
3024 return 0;
3025 }
3026
3027 if (grub_strncmp((char *)desc.id, "CD001", 5) != 0 ||
3028 grub_strncmp((char *)desc.system_id, "EL TORITO SPECIFICATION", 23) != 0)
3029 {
3030 return 0;
3031 }
3032
3033 return desc.sector;
3034 }
3035
3036 static grub_uint32_t ventoy_get_bios_eltorito_rba(grub_file_t file, grub_uint32_t sector)
3037 {
3038 grub_uint8_t buf[512];
3039
3040 grub_file_seek(file, sector * 2048);
3041 grub_file_read(file, buf, sizeof(buf));
3042
3043 if (buf[0] == 0x01 && buf[1] == 0x00 &&
3044 buf[30] == 0x55 && buf[31] == 0xaa && buf[32] == 0x88)
3045 {
3046 return *((grub_uint32_t *)(buf + 40));
3047 }
3048
3049 return 0;
3050 }
3051
3052 int ventoy_has_efi_eltorito(grub_file_t file, grub_uint32_t sector)
3053 {
3054 int i;
3055 int x86count = 0;
3056 grub_uint8_t buf[512];
3057 grub_uint8_t parttype[] = { 0x04, 0x06, 0x0B, 0x0C };
3058
3059 grub_file_seek(file, sector * 2048);
3060 grub_file_read(file, buf, sizeof(buf));
3061
3062 if (buf[0] == 0x01 && buf[1] == 0xEF)
3063 {
3064 debug("%s efi eltorito in Validation Entry\n", file->name);
3065 return 1;
3066 }
3067
3068 if (buf[0] == 0x01 && buf[1] == 0x00)
3069 {
3070 x86count++;
3071 }
3072
3073 for (i = 64; i < (int)sizeof(buf); i += 32)
3074 {
3075 if ((buf[i] == 0x90 || buf[i] == 0x91) && buf[i + 1] == 0xEF)
3076 {
3077 debug("%s efi eltorito offset %d 0x%02x\n", file->name, i, buf[i]);
3078 return 1;
3079 }
3080
3081 if ((buf[i] == 0x90 || buf[i] == 0x91) && buf[i + 1] == 0x00 && x86count == 1)
3082 {
3083 debug("0x9100 assume %s efi eltorito offset %d 0x%02x\n", file->name, i, buf[i]);
3084 return 1;
3085 }
3086 }
3087
3088 if (x86count && buf[32] == 0x88 && buf[33] == 0x04)
3089 {
3090 for (i = 0; i < (int)(ARRAY_SIZE(parttype)); i++)
3091 {
3092 if (buf[36] == parttype[i])
3093 {
3094 debug("hard disk image assume %s efi eltorito, part type 0x%x\n", file->name, buf[36]);
3095 return 1;
3096 }
3097 }
3098 }
3099
3100 debug("%s does not contain efi eltorito\n", file->name);
3101 return 0;
3102 }
3103
3104 void ventoy_fill_os_param(grub_file_t file, ventoy_os_param *param)
3105 {
3106 char *pos;
3107 const char *fs = NULL;
3108 const char *val = NULL;
3109 const char *cdprompt = NULL;
3110 grub_uint32_t i;
3111 grub_uint8_t chksum = 0;
3112 grub_disk_t disk;
3113
3114 disk = file->device->disk;
3115 grub_memcpy(&param->guid, &g_ventoy_guid, sizeof(ventoy_guid));
3116
3117 param->vtoy_disk_size = disk->total_sectors * (1 << disk->log_sector_size);
3118 param->vtoy_disk_part_id = disk->partition->number + 1;
3119 param->vtoy_disk_part_type = ventoy_get_fs_type(file->fs->name);
3120
3121 pos = grub_strstr(file->name, "/");
3122 if (!pos)
3123 {
3124 pos = file->name;
3125 }
3126
3127 grub_snprintf(param->vtoy_img_path, sizeof(param->vtoy_img_path), "%s", pos);
3128
3129 ventoy_get_disk_guid(file->name, param->vtoy_disk_guid, param->vtoy_disk_signature);
3130
3131 param->vtoy_img_size = file->size;
3132
3133 param->vtoy_reserved[0] = g_ventoy_break_level;
3134 param->vtoy_reserved[1] = g_ventoy_debug_level;
3135
3136 param->vtoy_reserved[2] = g_ventoy_chain_type;
3137
3138 /* Windows CD/DVD prompt 0:suppress 1:reserved */
3139 param->vtoy_reserved[4] = 0;
3140 if (g_ventoy_chain_type == 1) /* Windows */
3141 {
3142 cdprompt = ventoy_get_env("VTOY_WINDOWS_CD_PROMPT");
3143 if (cdprompt && cdprompt[0] == '1' && cdprompt[1] == 0)
3144 {
3145 param->vtoy_reserved[4] = 1;
3146 }
3147 }
3148
3149 fs = ventoy_get_env("ventoy_fs_probe");
3150 if (fs && grub_strcmp(fs, "udf") == 0)
3151 {
3152 param->vtoy_reserved[3] = 1;
3153 }
3154
3155 param->vtoy_reserved[5] = 0;
3156 val = ventoy_get_env("VTOY_LINUX_REMOUNT");
3157 if (val && val[0] == '1' && val[1] == 0)
3158 {
3159 param->vtoy_reserved[5] = 1;
3160 }
3161
3162 /* ventoy_disk_signature used for vlnk */
3163 param->vtoy_reserved[6] = file->vlnk;
3164 grub_memcpy(param->vtoy_reserved + 7, g_ventoy_part_info->MBR.BootCode + 0x1b8, 4);
3165
3166 /* calculate checksum */
3167 for (i = 0; i < sizeof(ventoy_os_param); i++)
3168 {
3169 chksum += *((grub_uint8_t *)param + i);
3170 }
3171 param->chksum = (grub_uint8_t)(0x100 - chksum);
3172
3173 return;
3174 }
3175
3176 int ventoy_check_block_list(grub_file_t file, ventoy_img_chunk_list *chunklist, grub_disk_addr_t start)
3177 {
3178 grub_uint32_t i = 0;
3179 grub_uint64_t total = 0;
3180 grub_uint64_t fileblk = 0;
3181 ventoy_img_chunk *chunk = NULL;
3182
3183 for (i = 0; i < chunklist->cur_chunk; i++)
3184 {
3185 chunk = chunklist->chunk + i;
3186
3187 if (chunk->disk_start_sector <= start)
3188 {
3189 debug("%u disk start invalid %lu\n", i, (ulong)start);
3190 return 1;
3191 }
3192
3193 total += chunk->disk_end_sector + 1 - chunk->disk_start_sector;
3194 }
3195
3196 fileblk = (file->size + 511) / 512;
3197
3198 if (total != fileblk)
3199 {
3200 debug("Invalid total: %llu %llu\n", (ulonglong)total, (ulonglong)fileblk);
3201 if ((file->size % 512) && (total + 1 == fileblk))
3202 {
3203 debug("maybe img file to be processed.\n");
3204 return 0;
3205 }
3206
3207 return 1;
3208 }
3209
3210 return 0;
3211 }
3212
3213 int ventoy_get_block_list(grub_file_t file, ventoy_img_chunk_list *chunklist, grub_disk_addr_t start)
3214 {
3215 int fs_type;
3216 int len;
3217 grub_uint32_t i = 0;
3218 grub_uint32_t sector = 0;
3219 grub_uint32_t count = 0;
3220 grub_off_t size = 0;
3221 grub_off_t read = 0;
3222
3223 fs_type = ventoy_get_fs_type(file->fs->name);
3224 if (fs_type == ventoy_fs_exfat)
3225 {
3226 grub_fat_get_file_chunk(start, file, chunklist);
3227 }
3228 else if (fs_type == ventoy_fs_ext)
3229 {
3230 grub_ext_get_file_chunk(start, file, chunklist);
3231 }
3232 else
3233 {
3234 file->read_hook = (grub_disk_read_hook_t)(void *)grub_disk_blocklist_read;
3235 file->read_hook_data = chunklist;
3236
3237 for (size = file->size; size > 0; size -= read)
3238 {
3239 read = (size > VTOY_SIZE_1GB) ? VTOY_SIZE_1GB : size;
3240 grub_file_read(file, NULL, read);
3241 }
3242
3243 for (i = 0; start > 0 && i < chunklist->cur_chunk; i++)
3244 {
3245 chunklist->chunk[i].disk_start_sector += start;
3246 chunklist->chunk[i].disk_end_sector += start;
3247 }
3248
3249 if (ventoy_fs_udf == fs_type)
3250 {
3251 for (i = 0; i < chunklist->cur_chunk; i++)
3252 {
3253 count = (chunklist->chunk[i].disk_end_sector + 1 - chunklist->chunk[i].disk_start_sector) >> 2;
3254 chunklist->chunk[i].img_start_sector = sector;
3255 chunklist->chunk[i].img_end_sector = sector + count - 1;
3256 sector += count;
3257 }
3258 }
3259 }
3260
3261 len = (int)grub_strlen(file->name);
3262 if ((len > 4 && grub_strncasecmp(file->name + len - 4, ".img", 4) == 0) ||
3263 (len > 4 && grub_strncasecmp(file->name + len - 4, ".vhd", 4) == 0) ||
3264 (len > 5 && grub_strncasecmp(file->name + len - 5, ".vhdx", 5) == 0) ||
3265 (len > 5 && grub_strncasecmp(file->name + len - 5, ".vtoy", 5) == 0))
3266 {
3267 for (i = 0; i < chunklist->cur_chunk; i++)
3268 {
3269 count = chunklist->chunk[i].disk_end_sector + 1 - chunklist->chunk[i].disk_start_sector;
3270 if (count < 4)
3271 {
3272 count = 1;
3273 }
3274 else
3275 {
3276 count >>= 2;
3277 }
3278
3279 chunklist->chunk[i].img_start_sector = sector;
3280 chunklist->chunk[i].img_end_sector = sector + count - 1;
3281 sector += count;
3282 }
3283 }
3284
3285 return 0;
3286 }
3287
3288 static grub_err_t ventoy_cmd_img_sector(grub_extcmd_context_t ctxt, int argc, char **args)
3289 {
3290 int rc;
3291 grub_file_t file;
3292 grub_disk_addr_t start;
3293
3294 (void)ctxt;
3295 (void)argc;
3296
3297 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", args[0]);
3298 if (!file)
3299 {
3300 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Can't open file %s\n", args[0]);
3301 }
3302
3303 g_conf_replace_count = 0;
3304 grub_memset(g_conf_replace_node, 0, sizeof(g_conf_replace_node ));
3305 grub_memset(g_conf_replace_offset, 0, sizeof(g_conf_replace_offset ));
3306
3307 if (g_img_chunk_list.chunk)
3308 {
3309 grub_free(g_img_chunk_list.chunk);
3310 }
3311
3312 if (ventoy_get_fs_type(file->fs->name) >= ventoy_fs_max)
3313 {
3314 grub_file_close(file);
3315 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Unsupported filesystem %s\n", file->fs->name);
3316 }
3317
3318 /* get image chunk data */
3319 grub_memset(&g_img_chunk_list, 0, sizeof(g_img_chunk_list));
3320 g_img_chunk_list.chunk = grub_malloc(sizeof(ventoy_img_chunk) * DEFAULT_CHUNK_NUM);
3321 if (NULL == g_img_chunk_list.chunk)
3322 {
3323 return grub_error(GRUB_ERR_OUT_OF_MEMORY, "Can't allocate image chunk memoty\n");
3324 }
3325
3326 g_img_chunk_list.max_chunk = DEFAULT_CHUNK_NUM;
3327 g_img_chunk_list.cur_chunk = 0;
3328
3329 start = file->device->disk->partition->start;
3330
3331 ventoy_get_block_list(file, &g_img_chunk_list, start);
3332
3333 rc = ventoy_check_block_list(file, &g_img_chunk_list, start);
3334 grub_file_close(file);
3335
3336 if (rc)
3337 {
3338 return grub_error(GRUB_ERR_NOT_IMPLEMENTED_YET, "Unsupported chunk list.\n");
3339 }
3340
3341 grub_memset(&g_grub_param->file_replace, 0, sizeof(g_grub_param->file_replace));
3342 grub_memset(&g_grub_param->img_replace, 0, sizeof(g_grub_param->img_replace));
3343 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
3344 }
3345
3346 static grub_err_t ventoy_select_conf_replace(grub_extcmd_context_t ctxt, int argc, char **args)
3347 {
3348 int i;
3349 int n;
3350 grub_uint64_t offset = 0;
3351 grub_uint32_t align = 0;
3352 grub_file_t file = NULL;
3353 conf_replace *node = NULL;
3354 conf_replace *nodes[VTOY_MAX_CONF_REPLACE] = { NULL };
3355 ventoy_grub_param_file_replace *replace = NULL;
3356
3357 (void)ctxt;
3358 (void)argc;
3359 (void)args;
3360
3361 debug("select conf replace argc:%d\n", argc);
3362
3363 if (argc < 2)
3364 {
3365 return 0;
3366 }
3367
3368 n = ventoy_plugin_find_conf_replace(args[1], nodes);
3369 if (!n)
3370 {
3371 debug("Conf replace not found for %s\n", args[1]);
3372 goto end;
3373 }
3374
3375 debug("Find %d conf replace for %s\n", n, args[1]);
3376
3377 g_conf_replace_count = n;
3378 for (i = 0; i < n; i++)
3379 {
3380 node = nodes[i];
3381
3382 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "(loop)%s", node->orgconf);
3383 if (file)
3384 {
3385 offset = grub_iso9660_get_last_file_dirent_pos(file);
3386 grub_file_close(file);
3387 }
3388 else if (node->img > 0)
3389 {
3390 offset = 0;
3391 }
3392 else
3393 {
3394 debug("<(loop)%s> NOT exist\n", node->orgconf);
3395 continue;
3396 }
3397
3398 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s%s", args[0], node->newconf);
3399 if (!file)
3400 {
3401 debug("New config file <%s%s> NOT exist\n", args[0], node->newconf);
3402 continue;
3403 }
3404
3405 align = ((int)file->size + 2047) / 2048 * 2048;
3406
3407 if (align > vtoy_max_replace_file_size)
3408 {
3409 debug("New config file <%s%s> too big\n", args[0], node->newconf);
3410 grub_file_close(file);
3411 continue;
3412 }
3413
3414 grub_file_read(file, g_conf_replace_new_buf[i], file->size);
3415 grub_file_close(file);
3416 g_conf_replace_new_len[i] = (int)file->size;
3417 g_conf_replace_new_len_align[i] = align;
3418
3419 g_conf_replace_node[i] = node;
3420 g_conf_replace_offset[i] = offset + 2;
3421
3422 if (node->img > 0)
3423 {
3424 replace = &(g_grub_param->img_replace[i]);
3425 replace->magic = GRUB_IMG_REPLACE_MAGIC;
3426 grub_snprintf(replace->old_file_name[replace->old_name_cnt], 256, "%s", node->orgconf);
3427 replace->old_name_cnt++;
3428 }
3429
3430 debug("conf_replace OK: newlen[%d]: %d img:%d\n", i, g_conf_replace_new_len[i], node->img);
3431 }
3432
3433 end:
3434 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
3435 }
3436
3437 static int ventoy_var_expand(int *record, int *flag, const char *var, char *expand, int len)
3438 {
3439 int i = 0;
3440 int n = 0;
3441 char c;
3442 const char *ch = var;
3443
3444 *record = 0;
3445 expand[0] = 0;
3446
3447 while (*ch)
3448 {
3449 if (*ch == '_' || (*ch >= '0' && *ch <= '9') || (*ch >= 'A' && *ch <= 'Z') || (*ch >= 'a' && *ch <= 'z'))
3450 {
3451 ch++;
3452 n++;
3453 }
3454 else
3455 {
3456 debug("Invalid variable letter <%c>\n", *ch);
3457 goto end;
3458 }
3459 }
3460
3461 if (n > 32)
3462 {
3463 debug("Invalid variable length:%d <%s>\n", n, var);
3464 goto end;
3465 }
3466
3467 if (grub_strncmp(var, "VT_", 3) == 0) /* built-in variables */
3468 {
3469
3470 }
3471 else
3472 {
3473 if (*flag == 0)
3474 {
3475 *flag = 1;
3476 grub_printf("\n=================== Variables Expansion ===================\n\n");
3477 }
3478
3479 grub_printf("<%s>: ", var);
3480 grub_refresh();
3481
3482 while (i < (len - 1))
3483 {
3484 c = grub_getkey();
3485 if ((c == '\n') || (c == '\r'))
3486 {
3487 if (i > 0)
3488 {
3489 grub_printf("\n");
3490 grub_refresh();
3491 *record = 1;
3492 break;
3493 }
3494 }
3495 else if (grub_isprint(c))
3496 {
3497 if (i + 1 < (len - 1))
3498 {
3499 grub_printf("%c", c);
3500 grub_refresh();
3501 expand[i++] = c;
3502 expand[i] = 0;
3503 }
3504 }
3505 else if (c == '\b')
3506 {
3507 if (i > 0)
3508 {
3509 expand[i - 1] = ' ';
3510 grub_printf("\r<%s>: %s", var, expand);
3511
3512 expand[i - 1] = 0;
3513 grub_printf("\r<%s>: %s", var, expand);
3514
3515 grub_refresh();
3516 i--;
3517 }
3518 }
3519 }
3520 }
3521
3522 end:
3523 if (expand[0] == 0)
3524 {
3525 grub_snprintf(expand, len, "$$%s$$", var);
3526 }
3527
3528 return 0;
3529 }
3530
3531 static int ventoy_auto_install_var_expand(install_template *node)
3532 {
3533 int pos = 0;
3534 int flag = 0;
3535 int record = 0;
3536 int newlen = 0;
3537 char *start = NULL;
3538 char *end = NULL;
3539 char *newbuf = NULL;
3540 char *curline = NULL;
3541 char *nextline = NULL;
3542 grub_uint8_t *code = NULL;
3543 char value[512];
3544 var_node *CurNode = NULL;
3545 var_node *pVarList = NULL;
3546
3547 code = (grub_uint8_t *)node->filebuf;
3548
3549 if (node->filelen >= VTOY_SIZE_1MB)
3550 {
3551 debug("auto install script too long %d\n", node->filelen);
3552 return 0;
3553 }
3554
3555 if ((code[0] == 0xff && code[1] == 0xfe) || (code[0] == 0xfe && code[1] == 0xff))
3556 {
3557 debug("UCS-2 encoding NOT supported\n");
3558 return 0;
3559 }
3560
3561 start = grub_strstr(node->filebuf, "$$");
3562 if (!start)
3563 {
3564 debug("no need to expand variable, no start.\n");
3565 return 0;
3566 }
3567
3568 end = grub_strstr(start + 2, "$$");
3569 if (!end)
3570 {
3571 debug("no need to expand variable, no end.\n");
3572 return 0;
3573 }
3574
3575 newlen = grub_max(node->filelen * 10, VTOY_SIZE_128KB);
3576 newbuf = grub_malloc(newlen);
3577 if (!newbuf)
3578 {
3579 debug("Failed to alloc newbuf %d\n", newlen);
3580 return 0;
3581 }
3582
3583 for (curline = node->filebuf; curline; curline = nextline)
3584 {
3585 nextline = ventoy_get_line(curline);
3586
3587 start = grub_strstr(curline, "$$");
3588 if (start)
3589 {
3590 end = grub_strstr(start + 2, "$$");
3591 }
3592
3593 if (start && end)
3594 {
3595 *start = *end = 0;
3596 VTOY_APPEND_NEWBUF(curline);
3597
3598 for (CurNode = pVarList; CurNode; CurNode = CurNode->next)
3599 {
3600 if (grub_strcmp(start + 2, CurNode->var) == 0)
3601 {
3602 grub_snprintf(value, sizeof(value) - 1, "%s", CurNode->val);
3603 break;
3604 }
3605 }
3606
3607 if (!CurNode)
3608 {
3609 value[sizeof(value) - 1] = 0;
3610 ventoy_var_expand(&record, &flag, start + 2, value, sizeof(value) - 1);
3611
3612 if (record)
3613 {
3614 CurNode = grub_zalloc(sizeof(var_node));
3615 if (CurNode)
3616 {
3617 grub_snprintf(CurNode->var, sizeof(CurNode->var), "%s", start + 2);
3618 grub_snprintf(CurNode->val, sizeof(CurNode->val), "%s", value);
3619 CurNode->next = pVarList;
3620 pVarList = CurNode;
3621 }
3622 }
3623 }
3624
3625 VTOY_APPEND_NEWBUF(value);
3626
3627 VTOY_APPEND_NEWBUF(end + 2);
3628 }
3629 else
3630 {
3631 VTOY_APPEND_NEWBUF(curline);
3632 }
3633
3634 if (pos > 0 && newbuf[pos - 1] == '\r')
3635 {
3636 newbuf[pos - 1] = '\n';
3637 }
3638 else
3639 {
3640 newbuf[pos++] = '\n';
3641 }
3642 }
3643
3644 grub_free(node->filebuf);
3645 node->filebuf = newbuf;
3646 node->filelen = pos;
3647
3648 while (pVarList)
3649 {
3650 CurNode = pVarList->next;
3651 grub_free(pVarList);
3652 pVarList = CurNode;
3653 }
3654
3655 return 0;
3656 }
3657
3658 static grub_err_t ventoy_cmd_sel_auto_install(grub_extcmd_context_t ctxt, int argc, char **args)
3659 {
3660 int i = 0;
3661 int pos = 0;
3662 int defidx = 1;
3663 char *buf = NULL;
3664 grub_file_t file = NULL;
3665 char configfile[128];
3666 install_template *node = NULL;
3667
3668 (void)ctxt;
3669 (void)argc;
3670 (void)args;
3671
3672 debug("select auto installation argc:%d\n", argc);
3673
3674 if (argc < 1)
3675 {
3676 return 0;
3677 }
3678
3679 node = ventoy_plugin_find_install_template(args[0]);
3680 if (!node)
3681 {
3682 debug("Auto install template not found for %s\n", args[0]);
3683 return 0;
3684 }
3685
3686 if (node->autosel >= 0 && node->autosel <= node->templatenum)
3687 {
3688 defidx = node->autosel;
3689 if (node->timeout < 0)
3690 {
3691 node->cursel = node->autosel - 1;
3692 debug("Auto install template auto select %d\n", node->autosel);
3693 goto load;
3694 }
3695 }
3696
3697 buf = (char *)grub_malloc(VTOY_MAX_SCRIPT_BUF);
3698 if (!buf)
3699 {
3700 return 0;
3701 }
3702
3703 if (node->timeout > 0)
3704 {
3705 vtoy_ssprintf(buf, pos, "set timeout=%d\n", node->timeout);
3706 }
3707
3708 vtoy_ssprintf(buf, pos, "menuentry \"Boot without auto installation template\" --class=\"sel_auto_install\" {\n"
3709 " echo %s\n}\n", "");
3710
3711 for (i = 0; i < node->templatenum; i++)
3712 {
3713 vtoy_ssprintf(buf, pos, "menuentry \"Boot with %s\" --class=\"sel_auto_install\" {\n"
3714 " echo \"\"\n}\n",
3715 node->templatepath[i].path);
3716 }
3717
3718 g_ventoy_menu_esc = 1;
3719 g_ventoy_suppress_esc = 1;
3720 g_ventoy_suppress_esc_default = defidx;
3721
3722 grub_snprintf(configfile, sizeof(configfile), "configfile mem:0x%llx:size:%d", (ulonglong)(ulong)buf, pos);
3723 grub_script_execute_sourcecode(configfile);
3724
3725 g_ventoy_menu_esc = 0;
3726 g_ventoy_suppress_esc = 0;
3727 g_ventoy_suppress_esc_default = 1;
3728
3729 grub_free(buf);
3730
3731 node->cursel = g_ventoy_last_entry - 1;
3732
3733 load:
3734 grub_check_free(node->filebuf);
3735 node->filelen = 0;
3736
3737 if (node->cursel >= 0 && node->cursel < node->templatenum)
3738 {
3739 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s%s", ventoy_get_env("vtoy_iso_part"),
3740 node->templatepath[node->cursel].path);
3741 if (file)
3742 {
3743 node->filebuf = grub_malloc(file->size + 8);
3744 if (node->filebuf)
3745 {
3746 grub_file_read(file, node->filebuf, file->size);
3747 grub_file_close(file);
3748
3749 grub_memset(node->filebuf + file->size, 0, 8);
3750 node->filelen = (int)file->size;
3751
3752 ventoy_auto_install_var_expand(node);
3753 }
3754 }
3755 else
3756 {
3757 debug("Failed to open auto install script <%s%s>\n",
3758 ventoy_get_env("vtoy_iso_part"), node->templatepath[node->cursel].path);
3759 }
3760 }
3761
3762 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
3763 }
3764
3765 static grub_err_t ventoy_cmd_sel_persistence(grub_extcmd_context_t ctxt, int argc, char **args)
3766 {
3767 int i = 0;
3768 int pos = 0;
3769 int defidx = 1;
3770 char *buf = NULL;
3771 char configfile[128];
3772 persistence_config *node;
3773
3774 (void)ctxt;
3775 (void)argc;
3776 (void)args;
3777
3778 debug("select persistence argc:%d\n", argc);
3779
3780 if (argc < 1)
3781 {
3782 return 0;
3783 }
3784
3785 node = ventoy_plugin_find_persistent(args[0]);
3786 if (!node)
3787 {
3788 debug("Persistence image not found for %s\n", args[0]);
3789 return 0;
3790 }
3791
3792 if (node->autosel >= 0 && node->autosel <= node->backendnum)
3793 {
3794 defidx = node->autosel;
3795 if (node->timeout < 0)
3796 {
3797 node->cursel = node->autosel - 1;
3798 debug("Persistence image auto select %d\n", node->autosel);
3799 return 0;
3800 }
3801 }
3802
3803 buf = (char *)grub_malloc(VTOY_MAX_SCRIPT_BUF);
3804 if (!buf)
3805 {
3806 return 0;
3807 }
3808
3809 if (node->timeout > 0)
3810 {
3811 vtoy_ssprintf(buf, pos, "set timeout=%d\n", node->timeout);
3812 }
3813
3814 vtoy_ssprintf(buf, pos, "menuentry \"Boot without persistence\" --class=\"sel_persistence\" {\n"
3815 " echo %s\n}\n", "");
3816
3817 for (i = 0; i < node->backendnum; i++)
3818 {
3819 vtoy_ssprintf(buf, pos, "menuentry \"Boot with %s\" --class=\"sel_persistence\" {\n"
3820 " echo \"\"\n}\n",
3821 node->backendpath[i].path);
3822
3823 }
3824
3825 g_ventoy_menu_esc = 1;
3826 g_ventoy_suppress_esc = 1;
3827 g_ventoy_suppress_esc_default = defidx;
3828
3829 grub_snprintf(configfile, sizeof(configfile), "configfile mem:0x%llx:size:%d", (ulonglong)(ulong)buf, pos);
3830 grub_script_execute_sourcecode(configfile);
3831
3832 g_ventoy_menu_esc = 0;
3833 g_ventoy_suppress_esc = 0;
3834 g_ventoy_suppress_esc_default = 1;
3835
3836 grub_free(buf);
3837
3838 node->cursel = g_ventoy_last_entry - 1;
3839
3840 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
3841 }
3842
3843 static grub_err_t ventoy_cmd_dump_img_sector(grub_extcmd_context_t ctxt, int argc, char **args)
3844 {
3845 grub_uint32_t i;
3846 ventoy_img_chunk *cur;
3847
3848 (void)ctxt;
3849 (void)argc;
3850 (void)args;
3851
3852 for (i = 0; i < g_img_chunk_list.cur_chunk; i++)
3853 {
3854 cur = g_img_chunk_list.chunk + i;
3855 grub_printf("image:[%u - %u] <==> disk:[%llu - %llu]\n",
3856 cur->img_start_sector, cur->img_end_sector,
3857 (unsigned long long)cur->disk_start_sector, (unsigned long long)cur->disk_end_sector
3858 );
3859 }
3860
3861 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
3862 }
3863
3864 static grub_err_t ventoy_cmd_test_block_list(grub_extcmd_context_t ctxt, int argc, char **args)
3865 {
3866 grub_uint32_t i;
3867 grub_file_t file;
3868 ventoy_img_chunk_list chunklist;
3869
3870 (void)ctxt;
3871 (void)argc;
3872
3873 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", args[0]);
3874 if (!file)
3875 {
3876 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Can't open file %s\n", args[0]);
3877 }
3878
3879 /* get image chunk data */
3880 grub_memset(&chunklist, 0, sizeof(chunklist));
3881 chunklist.chunk = grub_malloc(sizeof(ventoy_img_chunk) * DEFAULT_CHUNK_NUM);
3882 if (NULL == chunklist.chunk)
3883 {
3884 return grub_error(GRUB_ERR_OUT_OF_MEMORY, "Can't allocate image chunk memoty\n");
3885 }
3886
3887 chunklist.max_chunk = DEFAULT_CHUNK_NUM;
3888 chunklist.cur_chunk = 0;
3889
3890 ventoy_get_block_list(file, &chunklist, 0);
3891
3892 if (0 != ventoy_check_block_list(file, &chunklist, 0))
3893 {
3894 grub_printf("########## UNSUPPORTED ###############\n");
3895 }
3896
3897 grub_printf("filesystem: <%s> entry number:<%u>\n", file->fs->name, chunklist.cur_chunk);
3898
3899 for (i = 0; i < chunklist.cur_chunk; i++)
3900 {
3901 grub_printf("%llu+%llu,", (ulonglong)chunklist.chunk[i].disk_start_sector,
3902 (ulonglong)(chunklist.chunk[i].disk_end_sector + 1 - chunklist.chunk[i].disk_start_sector));
3903 }
3904
3905 grub_printf("\n==================================\n");
3906
3907 for (i = 0; i < chunklist.cur_chunk; i++)
3908 {
3909 grub_printf("%2u: [%llu %llu] - [%llu %llu]\n", i,
3910 (ulonglong)chunklist.chunk[i].img_start_sector,
3911 (ulonglong)chunklist.chunk[i].img_end_sector,
3912 (ulonglong)chunklist.chunk[i].disk_start_sector,
3913 (ulonglong)chunklist.chunk[i].disk_end_sector
3914 );
3915 }
3916
3917 grub_free(chunklist.chunk);
3918 grub_file_close(file);
3919
3920 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
3921 }
3922
3923 static grub_err_t ventoy_cmd_add_replace_file(grub_extcmd_context_t ctxt, int argc, char **args)
3924 {
3925 int i;
3926 ventoy_grub_param_file_replace *replace = NULL;
3927
3928 (void)ctxt;
3929 (void)argc;
3930 (void)args;
3931
3932 if (argc >= 2)
3933 {
3934 replace = &(g_grub_param->file_replace);
3935 replace->magic = GRUB_FILE_REPLACE_MAGIC;
3936
3937 replace->old_name_cnt = 0;
3938 for (i = 0; i < 4 && i + 1 < argc; i++)
3939 {
3940 replace->old_name_cnt++;
3941 grub_snprintf(replace->old_file_name[i], sizeof(replace->old_file_name[i]), "%s", args[i + 1]);
3942 }
3943
3944 replace->new_file_virtual_id = (grub_uint32_t)grub_strtoul(args[0], NULL, 10);
3945 }
3946
3947 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
3948 }
3949
3950 static grub_err_t ventoy_cmd_get_replace_file_cnt(grub_extcmd_context_t ctxt, int argc, char **args)
3951 {
3952 char buf[32];
3953 ventoy_grub_param_file_replace *replace = &(g_grub_param->file_replace);
3954
3955 (void)ctxt;
3956
3957 if (argc >= 1)
3958 {
3959 grub_snprintf(buf, sizeof(buf), "%u", replace->old_name_cnt);
3960 grub_env_set(args[0], buf);
3961 }
3962
3963 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
3964 }
3965
3966 static grub_err_t ventoy_cmd_dump_menu(grub_extcmd_context_t ctxt, int argc, char **args)
3967 {
3968 (void)ctxt;
3969 (void)argc;
3970 (void)args;
3971
3972 if (argc == 0)
3973 {
3974 grub_printf("List Mode: CurLen:%d MaxLen:%u\n", g_list_script_pos, VTOY_MAX_SCRIPT_BUF);
3975 grub_printf("%s", g_list_script_buf);
3976 }
3977 else
3978 {
3979 grub_printf("Tree Mode: CurLen:%d MaxLen:%u\n", g_tree_script_pos, VTOY_MAX_SCRIPT_BUF);
3980 grub_printf("%s", g_tree_script_buf);
3981 }
3982
3983 return 0;
3984 }
3985
3986 static grub_err_t ventoy_cmd_dump_img_list(grub_extcmd_context_t ctxt, int argc, char **args)
3987 {
3988 img_info *cur = g_ventoy_img_list;
3989
3990 (void)ctxt;
3991 (void)argc;
3992 (void)args;
3993
3994 while (cur)
3995 {
3996 grub_printf("path:<%s> id=%d list_index=%d\n", cur->path, cur->id, cur->plugin_list_index);
3997 grub_printf("name:<%s>\n\n", cur->name);
3998 cur = cur->next;
3999 }
4000
4001 return 0;
4002 }
4003
4004 static grub_err_t ventoy_cmd_dump_injection(grub_extcmd_context_t ctxt, int argc, char **args)
4005 {
4006 (void)ctxt;
4007 (void)argc;
4008 (void)args;
4009
4010 ventoy_plugin_dump_injection();
4011
4012 return 0;
4013 }
4014
4015 static grub_err_t ventoy_cmd_dump_auto_install(grub_extcmd_context_t ctxt, int argc, char **args)
4016 {
4017 (void)ctxt;
4018 (void)argc;
4019 (void)args;
4020
4021 ventoy_plugin_dump_auto_install();
4022
4023 return 0;
4024 }
4025
4026 static grub_err_t ventoy_cmd_dump_persistence(grub_extcmd_context_t ctxt, int argc, char **args)
4027 {
4028 (void)ctxt;
4029 (void)argc;
4030 (void)args;
4031
4032 ventoy_plugin_dump_persistence();
4033
4034 return 0;
4035 }
4036
4037 static int ventoy_check_mode_by_name(char *filename, const char *suffix)
4038 {
4039 int i;
4040 int len1;
4041 int len2;
4042
4043 len1 = (int)grub_strlen(filename);
4044 len2 = (int)grub_strlen(suffix);
4045
4046 if (len1 <= len2)
4047 {
4048 return 0;
4049 }
4050
4051 for (i = len1 - 1; i >= 0; i--)
4052 {
4053 if (filename[i] == '.')
4054 {
4055 break;
4056 }
4057 }
4058
4059 if (i < len2 + 1)
4060 {
4061 return 0;
4062 }
4063
4064 if (filename[i - len2 - 1] != '_')
4065 {
4066 return 0;
4067 }
4068
4069 if (grub_strncasecmp(filename + (i - len2), suffix, len2) == 0)
4070 {
4071 return 1;
4072 }
4073
4074 return 0;
4075 }
4076
4077 static grub_err_t ventoy_cmd_check_mode(grub_extcmd_context_t ctxt, int argc, char **args)
4078 {
4079 (void)ctxt;
4080 (void)argc;
4081 (void)args;
4082
4083 if (argc != 1 && argc != 2)
4084 {
4085 return 1;
4086 }
4087
4088 if (args[0][0] == '0')
4089 {
4090 if (g_ventoy_memdisk_mode)
4091 {
4092 return 0;
4093 }
4094
4095 if (argc == 2 && ventoy_check_mode_by_name(args[1], "vtmemdisk"))
4096 {
4097 return 0;
4098 }
4099
4100 return 1;
4101 }
4102 else if (args[0][0] == '1')
4103 {
4104 return g_ventoy_iso_raw ? 0 : 1;
4105 }
4106 else if (args[0][0] == '2')
4107 {
4108 return g_ventoy_iso_uefi_drv ? 0 : 1;
4109 }
4110 else if (args[0][0] == '3')
4111 {
4112 if (g_ventoy_grub2_mode)
4113 {
4114 return 0;
4115 }
4116
4117 if (argc == 2 && ventoy_check_mode_by_name(args[1], "vtgrub2"))
4118 {
4119 return 0;
4120 }
4121
4122 return 1;
4123 }
4124 else if (args[0][0] == '4')
4125 {
4126 if (g_ventoy_wimboot_mode)
4127 {
4128 return 0;
4129 }
4130
4131 if (argc == 2 && ventoy_check_mode_by_name(args[1], "vtwimboot"))
4132 {
4133 return 0;
4134 }
4135
4136 return 1;
4137 }
4138
4139 return 1;
4140 }
4141
4142 static grub_err_t ventoy_cmd_dynamic_menu(grub_extcmd_context_t ctxt, int argc, char **args)
4143 {
4144 static int configfile_mode = 0;
4145 char memfile[128] = {0};
4146
4147 (void)ctxt;
4148 (void)argc;
4149 (void)args;
4150
4151 /*
4152 * args[0]: 0:normal 1:configfile
4153 * args[1]: 0:list_buf 1:tree_buf
4154 */
4155
4156 if (argc != 2)
4157 {
4158 debug("Invalid argc %d\n", argc);
4159 return 0;
4160 }
4161
4162 VTOY_CMD_CHECK(1);
4163
4164 if (args[0][0] == '0')
4165 {
4166 if (args[1][0] == '0')
4167 {
4168 grub_script_execute_sourcecode(g_list_script_buf);
4169 }
4170 else
4171 {
4172 grub_script_execute_sourcecode(g_tree_script_buf);
4173 }
4174 }
4175 else
4176 {
4177 if (configfile_mode)
4178 {
4179 debug("Now already in F3 mode %d\n", configfile_mode);
4180 return 0;
4181 }
4182
4183 if (args[1][0] == '0')
4184 {
4185 grub_snprintf(memfile, sizeof(memfile), "configfile mem:0x%llx:size:%d",
4186 (ulonglong)(ulong)g_list_script_buf, g_list_script_pos);
4187 }
4188 else
4189 {
4190 g_ventoy_last_entry = -1;
4191 grub_snprintf(memfile, sizeof(memfile), "configfile mem:0x%llx:size:%d",
4192 (ulonglong)(ulong)g_tree_script_buf, g_tree_script_pos);
4193 }
4194
4195 configfile_mode = 1;
4196 grub_script_execute_sourcecode(memfile);
4197 configfile_mode = 0;
4198 }
4199
4200 return 0;
4201 }
4202
4203 static grub_err_t ventoy_cmd_file_exist_nocase(grub_extcmd_context_t ctxt, int argc, char **args)
4204 {
4205 grub_file_t file;
4206
4207 (void)ctxt;
4208
4209 if (argc != 1)
4210 {
4211 return 1;
4212 }
4213
4214 g_ventoy_case_insensitive = 1;
4215 file = grub_file_open(args[0], VENTOY_FILE_TYPE);
4216 g_ventoy_case_insensitive = 0;
4217
4218 grub_errno = 0;
4219
4220 if (file)
4221 {
4222 grub_file_close(file);
4223 return 0;
4224 }
4225 return 1;
4226 }
4227
4228 static grub_err_t ventoy_cmd_find_bootable_hdd(grub_extcmd_context_t ctxt, int argc, char **args)
4229 {
4230 int id = 0;
4231 int find = 0;
4232 grub_disk_t disk;
4233 const char *isopath = NULL;
4234 char hdname[32];
4235 ventoy_mbr_head mbr;
4236
4237 (void)ctxt;
4238 (void)argc;
4239
4240 if (argc != 1)
4241 {
4242 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s variable\n", cmd_raw_name);
4243 }
4244
4245 isopath = grub_env_get("vtoy_iso_part");
4246 if (!isopath)
4247 {
4248 debug("isopath is null %p\n", isopath);
4249 return 0;
4250 }
4251
4252 debug("isopath is %s\n", isopath);
4253
4254 for (id = 0; id < 30 && (find == 0); id++)
4255 {
4256 grub_snprintf(hdname, sizeof(hdname), "hd%d,", id);
4257 if (grub_strstr(isopath, hdname))
4258 {
4259 debug("skip %s ...\n", hdname);
4260 continue;
4261 }
4262
4263 grub_snprintf(hdname, sizeof(hdname), "hd%d", id);
4264
4265 disk = grub_disk_open(hdname);
4266 if (!disk)
4267 {
4268 debug("%s not exist\n", hdname);
4269 break;
4270 }
4271
4272 grub_memset(&mbr, 0, sizeof(mbr));
4273 if (0 == grub_disk_read(disk, 0, 0, 512, &mbr))
4274 {
4275 if (mbr.Byte55 == 0x55 && mbr.ByteAA == 0xAA)
4276 {
4277 if (mbr.PartTbl[0].Active == 0x80 || mbr.PartTbl[1].Active == 0x80 ||
4278 mbr.PartTbl[2].Active == 0x80 || mbr.PartTbl[3].Active == 0x80)
4279 {
4280
4281 grub_env_set(args[0], hdname);
4282 find = 1;
4283 }
4284 }
4285 debug("%s is %s\n", hdname, find ? "bootable" : "NOT bootable");
4286 }
4287 else
4288 {
4289 debug("read %s failed\n", hdname);
4290 }
4291
4292 grub_disk_close(disk);
4293 }
4294
4295 return 0;
4296 }
4297
4298 static grub_err_t ventoy_cmd_read_1st_line(grub_extcmd_context_t ctxt, int argc, char **args)
4299 {
4300 int len = 1024;
4301 grub_file_t file;
4302 char *buf = NULL;
4303
4304 (void)ctxt;
4305 (void)argc;
4306
4307 if (argc != 2)
4308 {
4309 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s file var \n", cmd_raw_name);
4310 }
4311
4312 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", args[0]);
4313 if (!file)
4314 {
4315 debug("failed to open file %s\n", args[0]);
4316 return 0;
4317 }
4318
4319 buf = grub_malloc(len);
4320 if (!buf)
4321 {
4322 goto end;
4323 }
4324
4325 buf[len - 1] = 0;
4326 grub_file_read(file, buf, len - 1);
4327
4328 ventoy_get_line(buf);
4329 ventoy_set_env(args[1], buf);
4330
4331 end:
4332
4333 grub_check_free(buf);
4334 grub_file_close(file);
4335
4336 return 0;
4337 }
4338
4339 static int ventoy_img_partition_callback (struct grub_disk *disk, const grub_partition_t partition, void *data)
4340 {
4341 grub_uint64_t end_max = 0;
4342 int *pCnt = (int *)data;
4343
4344 (void)disk;
4345
4346 (*pCnt)++;
4347 g_part_list_pos += grub_snprintf(g_part_list_buf + g_part_list_pos, VTOY_MAX_SCRIPT_BUF - g_part_list_pos,
4348 "0 %llu linear /dev/ventoy %llu\n",
4349 (ulonglong)partition->len, (ulonglong)partition->start);
4350
4351 end_max = (partition->len + partition->start) * 512;
4352 if (end_max > g_part_end_max)
4353 {
4354 g_part_end_max = end_max;
4355 }
4356
4357 return 0;
4358 }
4359
4360 static grub_err_t ventoy_cmd_img_part_info(grub_extcmd_context_t ctxt, int argc, char **args)
4361 {
4362 int cnt = 0;
4363 char *device_name = NULL;
4364 grub_device_t dev = NULL;
4365 char buf[64];
4366
4367 (void)ctxt;
4368
4369 g_part_list_pos = 0;
4370 g_part_end_max = 0;
4371 grub_env_unset("vtoy_img_part_file");
4372
4373 if (argc != 1)
4374 {
4375 return 1;
4376 }
4377
4378 device_name = grub_file_get_device_name(args[0]);
4379 if (!device_name)
4380 {
4381 debug("ventoy_cmd_img_part_info failed, %s\n", args[0]);
4382 goto end;
4383 }
4384
4385 dev = grub_device_open(device_name);
4386 if (!dev)
4387 {
4388 debug("grub_device_open failed, %s\n", device_name);
4389 goto end;
4390 }
4391
4392 grub_partition_iterate(dev->disk, ventoy_img_partition_callback, &cnt);
4393
4394 grub_snprintf(buf, sizeof(buf), "newc:vtoy_dm_table:mem:0x%llx:size:%d", (ulonglong)(ulong)g_part_list_buf, g_part_list_pos);
4395 grub_env_set("vtoy_img_part_file", buf);
4396
4397 grub_snprintf(buf, sizeof(buf), "%d", cnt);
4398 grub_env_set("vtoy_img_part_cnt", buf);
4399
4400 grub_snprintf(buf, sizeof(buf), "%llu", (ulonglong)g_part_end_max);
4401 grub_env_set("vtoy_img_max_part_end", buf);
4402
4403 end:
4404
4405 check_free(device_name, grub_free);
4406 check_free(dev, grub_device_close);
4407
4408 return 0;
4409 }
4410
4411
4412 static grub_err_t ventoy_cmd_file_strstr(grub_extcmd_context_t ctxt, int argc, char **args)
4413 {
4414 int rc = 1;
4415 grub_file_t file;
4416 char *buf = NULL;
4417
4418 (void)ctxt;
4419 (void)argc;
4420
4421 if (argc != 2)
4422 {
4423 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s file str \n", cmd_raw_name);
4424 }
4425
4426 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", args[0]);
4427 if (!file)
4428 {
4429 debug("failed to open file %s\n", args[0]);
4430 return 1;
4431 }
4432
4433 buf = grub_malloc(file->size + 1);
4434 if (!buf)
4435 {
4436 goto end;
4437 }
4438
4439 buf[file->size] = 0;
4440 grub_file_read(file, buf, file->size);
4441
4442 if (grub_strstr(buf, args[1]))
4443 {
4444 rc = 0;
4445 }
4446
4447 end:
4448
4449 grub_check_free(buf);
4450 grub_file_close(file);
4451
4452 return rc;
4453 }
4454
4455 static grub_err_t ventoy_cmd_parse_volume(grub_extcmd_context_t ctxt, int argc, char **args)
4456 {
4457 int len;
4458 grub_file_t file;
4459 char buf[64];
4460 grub_uint64_t size;
4461 ventoy_iso9660_vd pvd;
4462
4463 (void)ctxt;
4464 (void)argc;
4465
4466 if (argc != 4)
4467 {
4468 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s sysid volid space \n", cmd_raw_name);
4469 }
4470
4471 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", args[0]);
4472 if (!file)
4473 {
4474 debug("failed to open file %s\n", args[0]);
4475 return 0;
4476 }
4477
4478 grub_file_seek(file, 16 * 2048);
4479 len = (int)grub_file_read(file, &pvd, sizeof(pvd));
4480 if (len != sizeof(pvd))
4481 {
4482 debug("failed to read pvd %d\n", len);
4483 goto end;
4484 }
4485
4486 grub_memset(buf, 0, sizeof(buf));
4487 grub_memcpy(buf, pvd.sys, sizeof(pvd.sys));
4488 ventoy_set_env(args[1], buf);
4489
4490 grub_memset(buf, 0, sizeof(buf));
4491 grub_memcpy(buf, pvd.vol, sizeof(pvd.vol));
4492 ventoy_set_env(args[2], buf);
4493
4494 size = pvd.space;
4495 size *= 2048;
4496 grub_snprintf(buf, sizeof(buf), "%llu", (ulonglong)size);
4497 ventoy_set_env(args[3], buf);
4498
4499 end:
4500 grub_file_close(file);
4501
4502 return 0;
4503 }
4504
4505 static grub_err_t ventoy_cmd_parse_create_date(grub_extcmd_context_t ctxt, int argc, char **args)
4506 {
4507 int len;
4508 grub_file_t file;
4509 char buf[64];
4510
4511 (void)ctxt;
4512 (void)argc;
4513
4514 if (argc != 2)
4515 {
4516 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s var \n", cmd_raw_name);
4517 }
4518
4519 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", args[0]);
4520 if (!file)
4521 {
4522 debug("failed to open file %s\n", args[0]);
4523 return 0;
4524 }
4525
4526 grub_memset(buf, 0, sizeof(buf));
4527 grub_file_seek(file, 16 * 2048 + 813);
4528 len = (int)grub_file_read(file, buf, 17);
4529 if (len != 17)
4530 {
4531 debug("failed to read create date %d\n", len);
4532 goto end;
4533 }
4534
4535 ventoy_set_env(args[1], buf);
4536
4537 end:
4538 grub_file_close(file);
4539
4540 return 0;
4541 }
4542
4543 static grub_err_t ventoy_cmd_img_hook_root(grub_extcmd_context_t ctxt, int argc, char **args)
4544 {
4545 (void)ctxt;
4546 (void)argc;
4547 (void)args;
4548
4549 ventoy_env_hook_root(1);
4550
4551 return 0;
4552 }
4553
4554 static grub_err_t ventoy_cmd_img_unhook_root(grub_extcmd_context_t ctxt, int argc, char **args)
4555 {
4556 (void)ctxt;
4557 (void)argc;
4558 (void)args;
4559
4560 ventoy_env_hook_root(0);
4561
4562 return 0;
4563 }
4564
4565 #ifdef GRUB_MACHINE_EFI
4566 static grub_err_t ventoy_cmd_check_secureboot_var(grub_extcmd_context_t ctxt, int argc, char **args)
4567 {
4568 int ret = 1;
4569 grub_uint8_t *var;
4570 grub_size_t size;
4571 grub_efi_guid_t global = GRUB_EFI_GLOBAL_VARIABLE_GUID;
4572
4573 (void)ctxt;
4574 (void)argc;
4575 (void)args;
4576
4577 var = grub_efi_get_variable("SecureBoot", &global, &size);
4578 if (var && *var == 1)
4579 {
4580 return 0;
4581 }
4582
4583 return ret;
4584 }
4585 #else
4586 static grub_err_t ventoy_cmd_check_secureboot_var(grub_extcmd_context_t ctxt, int argc, char **args)
4587 {
4588 (void)ctxt;
4589 (void)argc;
4590 (void)args;
4591 return 1;
4592 }
4593 #endif
4594
4595 static grub_err_t ventoy_cmd_img_check_range(grub_extcmd_context_t ctxt, int argc, char **args)
4596 {
4597 int i;
4598 int ret = 1;
4599 grub_file_t file;
4600 grub_uint64_t FileSectors = 0;
4601 ventoy_gpt_info *gpt = NULL;
4602 ventoy_part_table *pt = NULL;
4603 grub_uint8_t zeroguid[16] = {0};
4604
4605 (void)ctxt;
4606 (void)argc;
4607
4608 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", args[0]);
4609 if (!file)
4610 {
4611 debug("failed to open file %s\n", args[0]);
4612 return 1;
4613 }
4614
4615 if (file->size % 512)
4616 {
4617 debug("unaligned file size: %llu\n", (ulonglong)file->size);
4618 goto out;
4619 }
4620
4621 gpt = grub_zalloc(sizeof(ventoy_gpt_info));
4622 if (!gpt)
4623 {
4624 goto out;
4625 }
4626
4627 FileSectors = file->size / 512;
4628
4629 grub_file_read(file, gpt, sizeof(ventoy_gpt_info));
4630 if (grub_strncmp(gpt->Head.Signature, "EFI PART", 8) == 0)
4631 {
4632 debug("This is EFI partition table\n");
4633
4634 for (i = 0; i < 128; i++)
4635 {
4636 if (grub_memcmp(gpt->PartTbl[i].PartGuid, zeroguid, 16))
4637 {
4638 if (FileSectors < gpt->PartTbl[i].LastLBA)
4639 {
4640 debug("out of range: part[%d] LastLBA:%llu FileSectors:%llu\n", i,
4641 (ulonglong)gpt->PartTbl[i].LastLBA, (ulonglong)FileSectors);
4642 goto out;
4643 }
4644 }
4645 }
4646 }
4647 else
4648 {
4649 debug("This is MBR partition table\n");
4650
4651 for (i = 0; i < 4; i++)
4652 {
4653 pt = gpt->MBR.PartTbl + i;
4654 if (FileSectors < pt->StartSectorId + pt->SectorCount)
4655 {
4656 debug("out of range: part[%d] LastLBA:%llu FileSectors:%llu\n", i,
4657 (ulonglong)(pt->StartSectorId + pt->SectorCount),
4658 (ulonglong)FileSectors);
4659 goto out;
4660 }
4661 }
4662 }
4663
4664 ret = 0;
4665
4666 out:
4667 grub_file_close(file);
4668 grub_check_free(gpt);
4669 grub_errno = GRUB_ERR_NONE;
4670 return ret;
4671 }
4672
4673 static grub_err_t ventoy_cmd_clear_key(grub_extcmd_context_t ctxt, int argc, char **args)
4674 {
4675 int i;
4676 int ret;
4677
4678 (void)ctxt;
4679 (void)argc;
4680 (void)args;
4681
4682 for (i = 0; i < 500; i++)
4683 {
4684 ret = grub_getkey_noblock();
4685 if (ret == GRUB_TERM_NO_KEY)
4686 {
4687 break;
4688 }
4689 }
4690
4691 if (i >= 500)
4692 {
4693 grub_cls();
4694 grub_printf("\n\n Still have key input after clear.\n");
4695 grub_refresh();
4696 grub_sleep(5);
4697 }
4698
4699 return 0;
4700 }
4701
4702 static grub_err_t ventoy_cmd_acpi_param(grub_extcmd_context_t ctxt, int argc, char **args)
4703 {
4704 int i;
4705 int buflen;
4706 int datalen;
4707 int loclen;
4708 int img_chunk_num;
4709 int image_sector_size;
4710 char cmd[64];
4711 ventoy_chain_head *chain;
4712 ventoy_img_chunk *chunk;
4713 ventoy_os_param *osparam;
4714 ventoy_image_location *location;
4715 ventoy_image_disk_region *region;
4716 struct grub_acpi_table_header *acpi;
4717
4718 (void)ctxt;
4719
4720 if (argc != 2)
4721 {
4722 return 1;
4723 }
4724
4725 debug("ventoy_cmd_acpi_param %s %s\n", args[0], args[1]);
4726
4727 chain = (ventoy_chain_head *)(ulong)grub_strtoul(args[0], NULL, 16);
4728 if (!chain)
4729 {
4730 return 1;
4731 }
4732
4733 image_sector_size = (int)grub_strtol(args[1], NULL, 10);
4734
4735 if (grub_memcmp(&g_ventoy_guid, &(chain->os_param.guid), 16))
4736 {
4737 debug("Invalid ventoy guid 0x%x\n", chain->os_param.guid.data1);
4738 return 1;
4739 }
4740
4741 img_chunk_num = chain->img_chunk_num;
4742
4743 loclen = sizeof(ventoy_image_location) + (img_chunk_num - 1) * sizeof(ventoy_image_disk_region);
4744 datalen = sizeof(ventoy_os_param) + loclen;
4745
4746 buflen = sizeof(struct grub_acpi_table_header) + datalen;
4747 acpi = grub_zalloc(buflen);
4748 if (!acpi)
4749 {
4750 return 1;
4751 }
4752
4753 /* Step1: Fill acpi table header */
4754 grub_memcpy(acpi->signature, "VTOY", 4);
4755 acpi->length = buflen;
4756 acpi->revision = 1;
4757 grub_memcpy(acpi->oemid, "VENTOY", 6);
4758 grub_memcpy(acpi->oemtable, "OSPARAMS", 8);
4759 acpi->oemrev = 1;
4760 acpi->creator_id[0] = 1;
4761 acpi->creator_rev = 1;
4762
4763 /* Step2: Fill data */
4764 osparam = (ventoy_os_param *)(acpi + 1);
4765 grub_memcpy(osparam, &chain->os_param, sizeof(ventoy_os_param));
4766 osparam->vtoy_img_location_addr = 0;
4767 osparam->vtoy_img_location_len = loclen;
4768 osparam->chksum = 0;
4769 osparam->chksum = 0x100 - grub_byte_checksum(osparam, sizeof(ventoy_os_param));
4770
4771 location = (ventoy_image_location *)(osparam + 1);
4772 grub_memcpy(&location->guid, &osparam->guid, sizeof(ventoy_guid));
4773 location->image_sector_size = image_sector_size;
4774 location->disk_sector_size = chain->disk_sector_size;
4775 location->region_count = img_chunk_num;
4776
4777 region = location->regions;
4778 chunk = (ventoy_img_chunk *)((char *)chain + chain->img_chunk_offset);
4779 if (512 == image_sector_size)
4780 {
4781 for (i = 0; i < img_chunk_num; i++)
4782 {
4783 region->image_sector_count = chunk->disk_end_sector - chunk->disk_start_sector + 1;
4784 region->image_start_sector = chunk->img_start_sector * 4;
4785 region->disk_start_sector = chunk->disk_start_sector;
4786 region++;
4787 chunk++;
4788 }
4789 }
4790 else
4791 {
4792 for (i = 0; i < img_chunk_num; i++)
4793 {
4794 region->image_sector_count = chunk->img_end_sector - chunk->img_start_sector + 1;
4795 region->image_start_sector = chunk->img_start_sector;
4796 region->disk_start_sector = chunk->disk_start_sector;
4797 region++;
4798 chunk++;
4799 }
4800 }
4801
4802 /* Step3: Fill acpi checksum */
4803 acpi->checksum = 0;
4804 acpi->checksum = 0x100 - grub_byte_checksum(acpi, acpi->length);
4805
4806 /* load acpi table */
4807 grub_snprintf(cmd, sizeof(cmd), "acpi mem:0x%lx:size:%d", (ulong)acpi, acpi->length);
4808 grub_script_execute_sourcecode(cmd);
4809
4810 grub_free(acpi);
4811
4812 VENTOY_CMD_RETURN(0);
4813 }
4814
4815 static grub_err_t ventoy_cmd_push_last_entry(grub_extcmd_context_t ctxt, int argc, char **args)
4816 {
4817 (void)ctxt;
4818 (void)argc;
4819 (void)args;
4820
4821 g_ventoy_last_entry_back = g_ventoy_last_entry;
4822 g_ventoy_last_entry = -1;
4823
4824 return 0;
4825 }
4826
4827 static grub_err_t ventoy_cmd_pop_last_entry(grub_extcmd_context_t ctxt, int argc, char **args)
4828 {
4829 (void)ctxt;
4830 (void)argc;
4831 (void)args;
4832
4833 g_ventoy_last_entry = g_ventoy_last_entry_back;
4834
4835 return 0;
4836 }
4837
4838 static int ventoy_lib_module_callback(const char *filename, const struct grub_dirhook_info *info, void *data)
4839 {
4840 const char *pos = filename + 1;
4841
4842 if (info->dir)
4843 {
4844 while (*pos)
4845 {
4846 if (*pos == '.')
4847 {
4848 if ((*(pos - 1) >= '0' && *(pos - 1) <= '9') && (*(pos + 1) >= '0' && *(pos + 1) <= '9'))
4849 {
4850 grub_strncpy((char *)data, filename, 128);
4851 return 1;
4852 }
4853 }
4854 pos++;
4855 }
4856 }
4857
4858 return 0;
4859 }
4860
4861 static grub_err_t ventoy_cmd_lib_module_ver(grub_extcmd_context_t ctxt, int argc, char **args)
4862 {
4863 int rc = 1;
4864 char *device_name = NULL;
4865 grub_device_t dev = NULL;
4866 grub_fs_t fs = NULL;
4867 char buf[128] = {0};
4868
4869 (void)ctxt;
4870
4871 if (argc != 3)
4872 {
4873 debug("ventoy_cmd_lib_module_ver, invalid param num %d\n", argc);
4874 return 1;
4875 }
4876
4877 debug("ventoy_cmd_lib_module_ver %s %s %s\n", args[0], args[1], args[2]);
4878
4879 device_name = grub_file_get_device_name(args[0]);
4880 if (!device_name)
4881 {
4882 debug("grub_file_get_device_name failed, %s\n", args[0]);
4883 goto end;
4884 }
4885
4886 dev = grub_device_open(device_name);
4887 if (!dev)
4888 {
4889 debug("grub_device_open failed, %s\n", device_name);
4890 goto end;
4891 }
4892
4893 fs = grub_fs_probe(dev);
4894 if (!fs)
4895 {
4896 debug("grub_fs_probe failed, %s\n", device_name);
4897 goto end;
4898 }
4899
4900 fs->fs_dir(dev, args[1], ventoy_lib_module_callback, buf);
4901
4902 if (buf[0])
4903 {
4904 ventoy_set_env(args[2], buf);
4905 }
4906
4907 rc = 0;
4908
4909 end:
4910
4911 check_free(device_name, grub_free);
4912 check_free(dev, grub_device_close);
4913
4914 return rc;
4915 }
4916
4917 int ventoy_load_part_table(const char *diskname)
4918 {
4919 char name[64];
4920 int ret;
4921 grub_disk_t disk;
4922 grub_device_t dev;
4923
4924 g_ventoy_part_info = grub_zalloc(sizeof(ventoy_gpt_info));
4925 if (!g_ventoy_part_info)
4926 {
4927 return 1;
4928 }
4929
4930 disk = grub_disk_open(diskname);
4931 if (!disk)
4932 {
4933 debug("Failed to open disk %s\n", diskname);
4934 return 1;
4935 }
4936
4937 g_ventoy_disk_size = disk->total_sectors * (1U << disk->log_sector_size);
4938
4939 g_ventoy_disk_bios_id = disk->id;
4940
4941 grub_disk_read(disk, 0, 0, sizeof(ventoy_gpt_info), g_ventoy_part_info);
4942 grub_disk_close(disk);
4943
4944 grub_snprintf(name, sizeof(name), "%s,1", diskname);
4945 dev = grub_device_open(name);
4946 if (dev)
4947 {
4948 /* Check for official Ventoy device */
4949 ret = ventoy_check_official_device(dev);
4950 grub_device_close(dev);
4951
4952 if (ret)
4953 {
4954 return 1;
4955 }
4956 }
4957
4958 g_ventoy_disk_part_size[0] = ventoy_get_vtoy_partsize(0);
4959 g_ventoy_disk_part_size[1] = ventoy_get_vtoy_partsize(1);
4960
4961 return 0;
4962 }
4963
4964 static grub_err_t ventoy_cmd_load_part_table(grub_extcmd_context_t ctxt, int argc, char **args)
4965 {
4966 int ret;
4967
4968 (void)argc;
4969 (void)ctxt;
4970
4971 ret = ventoy_load_part_table(args[0]);
4972 if (ret)
4973 {
4974 grub_exit();
4975 }
4976
4977 g_ventoy_disk_part_size[0] = ventoy_get_vtoy_partsize(0);
4978 g_ventoy_disk_part_size[1] = ventoy_get_vtoy_partsize(1);
4979
4980 return 0;
4981 }
4982
4983 static grub_err_t ventoy_cmd_check_custom_boot(grub_extcmd_context_t ctxt, int argc, char **args)
4984 {
4985 int ret = 1;
4986 const char *vcfg = NULL;
4987
4988 (void)argc;
4989 (void)ctxt;
4990
4991 vcfg = ventoy_plugin_get_custom_boot(args[0]);
4992 if (vcfg)
4993 {
4994 debug("custom boot <%s>:<%s>\n", args[0], vcfg);
4995 grub_env_set(args[1], vcfg);
4996 ret = 0;
4997 }
4998 else
4999 {
5000 debug("custom boot <%s>:<NOT FOUND>\n", args[0]);
5001 }
5002
5003 grub_errno = 0;
5004 return ret;
5005 }
5006
5007
5008 static grub_err_t ventoy_cmd_part_exist(grub_extcmd_context_t ctxt, int argc, char **args)
5009 {
5010 int id;
5011 grub_uint8_t zeroguid[16] = {0};
5012
5013 (void)argc;
5014 (void)ctxt;
5015
5016 id = (int)grub_strtoul(args[0], NULL, 10);
5017 grub_errno = 0;
5018
5019 if (grub_memcmp(g_ventoy_part_info->Head.Signature, "EFI PART", 8) == 0)
5020 {
5021 if (id >= 1 && id <= 128)
5022 {
5023 if (grub_memcmp(g_ventoy_part_info->PartTbl[id - 1].PartGuid, zeroguid, 16))
5024 {
5025 return 0;
5026 }
5027 }
5028 }
5029 else
5030 {
5031 if (id >= 1 && id <= 4)
5032 {
5033 if (g_ventoy_part_info->MBR.PartTbl[id - 1].FsFlag)
5034 {
5035 return 0;
5036 }
5037 }
5038 }
5039
5040 return 1;
5041 }
5042
5043 static grub_err_t ventoy_cmd_get_fs_label(grub_extcmd_context_t ctxt, int argc, char **args)
5044 {
5045 int rc = 1;
5046 char *device_name = NULL;
5047 grub_device_t dev = NULL;
5048 grub_fs_t fs = NULL;
5049 char *label = NULL;
5050
5051 (void)ctxt;
5052
5053 debug("get fs label for %s\n", args[0]);
5054
5055 if (argc != 2)
5056 {
5057 debug("ventoy_cmd_get_fs_label, invalid param num %d\n", argc);
5058 return 1;
5059 }
5060
5061 device_name = grub_file_get_device_name(args[0]);
5062 if (!device_name)
5063 {
5064 debug("grub_file_get_device_name failed, %s\n", args[0]);
5065 goto end;
5066 }
5067
5068 dev = grub_device_open(device_name);
5069 if (!dev)
5070 {
5071 debug("grub_device_open failed, %s\n", device_name);
5072 goto end;
5073 }
5074
5075 fs = grub_fs_probe(dev);
5076 if (NULL == fs || NULL == fs->fs_label)
5077 {
5078 debug("grub_fs_probe failed, %s %p %p\n", device_name, fs, fs->fs_label);
5079 goto end;
5080 }
5081
5082 fs->fs_label(dev, &label);
5083 if (label)
5084 {
5085 debug("label=<%s>\n", label);
5086 ventoy_set_env(args[1], label);
5087 grub_free(label);
5088 }
5089
5090 rc = 0;
5091
5092 end:
5093
5094 check_free(device_name, grub_free);
5095 check_free(dev, grub_device_close);
5096
5097 return rc;
5098 }
5099
5100 static int ventoy_fs_enum_1st_file(const char *filename, const struct grub_dirhook_info *info, void *data)
5101 {
5102 if (!info->dir)
5103 {
5104 grub_snprintf((char *)data, 256, "%s", filename);
5105 return 1;
5106 }
5107
5108 return 0;
5109 }
5110
5111 static int ventoy_fs_enum_1st_dir(const char *filename, const struct grub_dirhook_info *info, void *data)
5112 {
5113 if (info->dir && filename && filename[0] != '.')
5114 {
5115 grub_snprintf((char *)data, 256, "%s", filename);
5116 return 1;
5117 }
5118
5119 return 0;
5120 }
5121
5122 static grub_err_t ventoy_fs_enum_1st_child(int argc, char **args, grub_fs_dir_hook_t hook)
5123 {
5124 int rc = 1;
5125 char *device_name = NULL;
5126 grub_device_t dev = NULL;
5127 grub_fs_t fs = NULL;
5128 char name[256] ={0};
5129
5130 if (argc != 3)
5131 {
5132 debug("ventoy_fs_enum_1st_child, invalid param num %d\n", argc);
5133 return 1;
5134 }
5135
5136 device_name = grub_file_get_device_name(args[0]);
5137 if (!device_name)
5138 {
5139 debug("grub_file_get_device_name failed, %s\n", args[0]);
5140 goto end;
5141 }
5142
5143 dev = grub_device_open(device_name);
5144 if (!dev)
5145 {
5146 debug("grub_device_open failed, %s\n", device_name);
5147 goto end;
5148 }
5149
5150 fs = grub_fs_probe(dev);
5151 if (!fs)
5152 {
5153 debug("grub_fs_probe failed, %s\n", device_name);
5154 goto end;
5155 }
5156
5157 fs->fs_dir(dev, args[1], hook, name);
5158 if (name[0])
5159 {
5160 ventoy_set_env(args[2], name);
5161 }
5162
5163 rc = 0;
5164
5165 end:
5166
5167 check_free(device_name, grub_free);
5168 check_free(dev, grub_device_close);
5169
5170 return rc;
5171 }
5172
5173 static grub_err_t ventoy_cmd_fs_enum_1st_file(grub_extcmd_context_t ctxt, int argc, char **args)
5174 {
5175 (void)ctxt;
5176 return ventoy_fs_enum_1st_child(argc, args, ventoy_fs_enum_1st_file);
5177 }
5178
5179 static grub_err_t ventoy_cmd_fs_enum_1st_dir(grub_extcmd_context_t ctxt, int argc, char **args)
5180 {
5181 (void)ctxt;
5182 return ventoy_fs_enum_1st_child(argc, args, ventoy_fs_enum_1st_dir);
5183 }
5184
5185 static grub_err_t ventoy_cmd_basename(grub_extcmd_context_t ctxt, int argc, char **args)
5186 {
5187 char c;
5188 char *pos = NULL;
5189 char *end = NULL;
5190
5191 (void)ctxt;
5192
5193 if (argc != 2)
5194 {
5195 debug("ventoy_cmd_basename, invalid param num %d\n", argc);
5196 return 1;
5197 }
5198
5199 for (pos = args[0]; *pos; pos++)
5200 {
5201 if (*pos == '.')
5202 {
5203 end = pos;
5204 }
5205 }
5206
5207 if (end)
5208 {
5209 c = *end;
5210 *end = 0;
5211 }
5212
5213 grub_env_set(args[1], args[0]);
5214
5215 if (end)
5216 {
5217 *end = c;
5218 }
5219
5220 return 0;
5221 }
5222
5223 static grub_err_t ventoy_cmd_basefile(grub_extcmd_context_t ctxt, int argc, char **args)
5224 {
5225 int i;
5226 int len;
5227 const char *buf;
5228
5229 (void)ctxt;
5230
5231 if (argc != 2)
5232 {
5233 debug("ventoy_cmd_basefile, invalid param num %d\n", argc);
5234 return 1;
5235 }
5236
5237 buf = args[0];
5238 len = (int)grub_strlen(buf);
5239 for (i = len; i > 0; i--)
5240 {
5241 if (buf[i - 1] == '/')
5242 {
5243 grub_env_set(args[1], buf + i);
5244 return 0;
5245 }
5246 }
5247
5248 grub_env_set(args[1], buf);
5249
5250 return 0;
5251 }
5252
5253 static grub_err_t ventoy_cmd_enum_video_mode(grub_extcmd_context_t ctxt, int argc, char **args)
5254 {
5255 struct grub_video_mode_info info;
5256 char buf[32];
5257
5258 (void)ctxt;
5259 (void)argc;
5260 (void)args;
5261
5262 if (!g_video_mode_list)
5263 {
5264 ventoy_enum_video_mode();
5265 }
5266
5267 if (grub_video_get_info(&info) == GRUB_ERR_NONE)
5268 {
5269 grub_snprintf(buf, sizeof(buf), "Resolution (%ux%u)", info.width, info.height);
5270 }
5271 else
5272 {
5273 grub_snprintf(buf, sizeof(buf), "Resolution (0x0)");
5274 }
5275
5276 grub_env_set("VTOY_CUR_VIDEO_MODE", buf);
5277
5278 grub_snprintf(buf, sizeof(buf), "%d", g_video_mode_num);
5279 grub_env_set("VTOY_VIDEO_MODE_NUM", buf);
5280
5281 VENTOY_CMD_RETURN(0);
5282 }
5283
5284 static grub_err_t vt_cmd_update_cur_video_mode(grub_extcmd_context_t ctxt, int argc, char **args)
5285 {
5286 struct grub_video_mode_info info;
5287 char buf[32];
5288
5289 (void)ctxt;
5290 (void)argc;
5291 (void)args;
5292
5293 if (grub_video_get_info(&info) == GRUB_ERR_NONE)
5294 {
5295 grub_snprintf(buf, sizeof(buf), "%ux%ux%u", info.width, info.height, info.bpp);
5296 }
5297 else
5298 {
5299 grub_snprintf(buf, sizeof(buf), "0x0x0");
5300 }
5301
5302 grub_env_set(args[0], buf);
5303
5304 VENTOY_CMD_RETURN(0);
5305 }
5306
5307 static grub_err_t ventoy_cmd_get_video_mode(grub_extcmd_context_t ctxt, int argc, char **args)
5308 {
5309 int id;
5310 char buf[32];
5311
5312 (void)ctxt;
5313 (void)argc;
5314
5315 if (!g_video_mode_list)
5316 {
5317 return 0;
5318 }
5319
5320 id = (int)grub_strtoul(args[0], NULL, 10);
5321 if (id < g_video_mode_num)
5322 {
5323 grub_snprintf(buf, sizeof(buf), "%ux%ux%u",
5324 g_video_mode_list[id].width, g_video_mode_list[id].height, g_video_mode_list[id].bpp);
5325 }
5326
5327 grub_env_set(args[1], buf);
5328
5329 VENTOY_CMD_RETURN(0);
5330 }
5331
5332 static grub_err_t ventoy_cmd_get_efivdisk_offset(grub_extcmd_context_t ctxt, int argc, char **args)
5333 {
5334 grub_uint32_t i;
5335 grub_uint32_t loadsector = 0;
5336 grub_file_t file;
5337 char value[32];
5338 grub_uint32_t boot_catlog = 0;
5339 grub_uint8_t buf[512];
5340
5341 (void)ctxt;
5342
5343 if (argc != 2)
5344 {
5345 debug("ventoy_cmd_get_efivdisk_offset, invalid param num %d\n", argc);
5346 return 1;
5347 }
5348
5349 file = grub_file_open(args[0], VENTOY_FILE_TYPE);
5350 if (!file)
5351 {
5352 debug("failed to open %s\n", args[0]);
5353 return 1;
5354 }
5355
5356 boot_catlog = ventoy_get_iso_boot_catlog(file);
5357 if (boot_catlog == 0)
5358 {
5359 debug("No bootcatlog found\n");
5360 grub_file_close(file);
5361 return 1;
5362 }
5363
5364 grub_memset(buf, 0, sizeof(buf));
5365 grub_file_seek(file, boot_catlog * 2048);
5366 grub_file_read(file, buf, sizeof(buf));
5367 grub_file_close(file);
5368
5369 for (i = 0; i < sizeof(buf); i += 32)
5370 {
5371 if ((buf[i] == 0 || buf[i] == 0x90 || buf[i] == 0x91) && buf[i + 1] == 0xEF)
5372 {
5373 if (buf[i + 32] == 0x88)
5374 {
5375 loadsector = *(grub_uint32_t *)(buf + i + 32 + 8);
5376 grub_snprintf(value, sizeof(value), "%u", loadsector * 4); //change to sector size 512
5377 break;
5378 }
5379 }
5380 }
5381
5382 if (loadsector == 0)
5383 {
5384 debug("No EFI eltorito info found\n");
5385 return 1;
5386 }
5387
5388 debug("ventoy_cmd_get_efivdisk_offset <%s>\n", value);
5389 grub_env_set(args[1], value);
5390 VENTOY_CMD_RETURN(0);
5391 }
5392
5393 static int ventoy_collect_replace_initrd(const char *filename, const struct grub_dirhook_info *info, void *data)
5394 {
5395 int curpos;
5396 int printlen;
5397 grub_size_t len;
5398 replace_fs_dir *pfsdir = (replace_fs_dir *)data;
5399
5400 if (pfsdir->initrd[0])
5401 {
5402 return 1;
5403 }
5404
5405 curpos = pfsdir->curpos;
5406 len = grub_strlen(filename);
5407
5408 if (info->dir)
5409 {
5410 if ((len == 1 && filename[0] == '.') ||
5411 (len == 2 && filename[0] == '.' && filename[1] == '.'))
5412 {
5413 return 0;
5414 }
5415
5416 //debug("#### [DIR] <%s> <%s>\n", pfsdir->fullpath, filename);
5417 pfsdir->dircnt++;
5418
5419 printlen = grub_snprintf(pfsdir->fullpath + curpos, 512 - curpos, "%s/", filename);
5420 pfsdir->curpos = curpos + printlen;
5421 pfsdir->fs->fs_dir(pfsdir->dev, pfsdir->fullpath, ventoy_collect_replace_initrd, pfsdir);
5422 pfsdir->curpos = curpos;
5423 pfsdir->fullpath[curpos] = 0;
5424 }
5425 else
5426 {
5427 //debug("#### [FILE] <%s> <%s>\n", pfsdir->fullpath, filename);
5428 pfsdir->filecnt++;
5429
5430 /* We consider the xxx.img file bigger than 32MB is the initramfs file */
5431 if (len > 4 && grub_strncmp(filename + len - 4, ".img", 4) == 0)
5432 {
5433 if (info->size > 32 * VTOY_SIZE_1MB)
5434 {
5435 grub_snprintf(pfsdir->initrd, sizeof(pfsdir->initrd), "%s%s", pfsdir->fullpath, filename);
5436 return 1;
5437 }
5438 }
5439 }
5440
5441 return 0;
5442 }
5443
5444 static grub_err_t ventoy_cmd_search_replace_initrd(grub_extcmd_context_t ctxt, int argc, char **args)
5445 {
5446 int i;
5447 char *pos = NULL;
5448 char *device_name = NULL;
5449 grub_device_t dev = NULL;
5450 grub_fs_t fs = NULL;
5451 replace_fs_dir *pfsdir = NULL;
5452
5453 (void)ctxt;
5454
5455 if (argc != 2)
5456 {
5457 debug("ventoy_cmd_search_replace_initrd, invalid param num %d\n", argc);
5458 return 1;
5459 }
5460
5461 pfsdir = grub_zalloc(sizeof(replace_fs_dir));
5462 if (!pfsdir)
5463 {
5464 return 1;
5465 }
5466
5467 device_name = grub_file_get_device_name(args[0]);
5468 if (!device_name)
5469 {
5470 goto fail;
5471 }
5472
5473 dev = grub_device_open(device_name);
5474 if (!dev)
5475 {
5476 goto fail;
5477 }
5478
5479 fs = grub_fs_probe(dev);
5480 if (!fs)
5481 {
5482 goto fail;
5483 }
5484
5485 pfsdir->dev = dev;
5486 pfsdir->fs = fs;
5487 pfsdir->curpos = 1;
5488 pfsdir->fullpath[0] = '/';
5489 fs->fs_dir(dev, "/", ventoy_collect_replace_initrd, pfsdir);
5490
5491 if (pfsdir->initrd[0])
5492 {
5493 debug("Replace initrd <%s> <%d %d>\n", pfsdir->initrd, pfsdir->dircnt, pfsdir->filecnt);
5494
5495 for (i = 0; i < (int)sizeof(pfsdir->initrd) && pfsdir->initrd[i]; i++)
5496 {
5497 if (pfsdir->initrd[i] == '/')
5498 {
5499 pfsdir->initrd[i] = '\\';
5500 }
5501 }
5502
5503 pos = (pfsdir->initrd[0] == '\\') ? pfsdir->initrd + 1 : pfsdir->initrd;
5504 grub_env_set(args[1], pos);
5505 }
5506 else
5507 {
5508 debug("Replace initrd NOT found <%s> <%d %d>\n", args[0], pfsdir->dircnt, pfsdir->filecnt);
5509 }
5510
5511 fail:
5512
5513 grub_check_free(pfsdir);
5514 grub_check_free(device_name);
5515 check_free(dev, grub_device_close);
5516
5517 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
5518 }
5519
5520 static grub_err_t ventoy_cmd_push_pager(grub_extcmd_context_t ctxt, int argc, char **args)
5521 {
5522 const char *pager = NULL;
5523
5524 (void)ctxt;
5525 (void)argc;
5526 (void)args;
5527
5528 pager = grub_env_get("pager");
5529 if (NULL == pager)
5530 {
5531 g_pager_flag = 1;
5532 grub_env_set("pager", "1");
5533 }
5534 else if (pager[0] == '1')
5535 {
5536 g_pager_flag = 0;
5537 }
5538 else
5539 {
5540 grub_snprintf(g_old_pager, sizeof(g_old_pager), "%s", pager);
5541 g_pager_flag = 2;
5542 grub_env_set("pager", "1");
5543 }
5544
5545 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
5546 }
5547
5548 static grub_err_t ventoy_cmd_pop_pager(grub_extcmd_context_t ctxt, int argc, char **args)
5549 {
5550 (void)ctxt;
5551 (void)argc;
5552 (void)args;
5553
5554 if (g_pager_flag == 1)
5555 {
5556 grub_env_unset("pager");
5557 }
5558 else if (g_pager_flag == 2)
5559 {
5560 grub_env_set("pager", g_old_pager);
5561 }
5562
5563 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
5564 }
5565
5566 static int ventoy_chk_case_file(const char *filename, const struct grub_dirhook_info *info, void *data)
5567 {
5568 if (g_json_case_mis_path[0])
5569 {
5570 return 1;
5571 }
5572
5573 if (0 == info->dir && grub_strcasecmp(filename, "ventoy.json") == 0)
5574 {
5575 grub_snprintf(g_json_case_mis_path, 32, "%s/%s", (char *)data, filename);
5576 return 1;
5577 }
5578 return 0;
5579 }
5580
5581 static int ventoy_chk_case_dir(const char *filename, const struct grub_dirhook_info *info, void *data)
5582 {
5583 char path[16];
5584 chk_case_fs_dir *fs_dir = (chk_case_fs_dir *)data;
5585
5586 if (g_json_case_mis_path[0])
5587 {
5588 return 1;
5589 }
5590
5591 if (info->dir && (filename[0] == 'v' || filename[0] == 'V'))
5592 {
5593 if (grub_strcasecmp(filename, "ventoy") == 0)
5594 {
5595 grub_snprintf(path, sizeof(path), "/%s", filename);
5596 fs_dir->fs->fs_dir(fs_dir->dev, path, ventoy_chk_case_file, path);
5597 if (g_json_case_mis_path[0])
5598 {
5599 return 1;
5600 }
5601 }
5602 }
5603
5604 return 0;
5605 }
5606
5607 static grub_err_t ventoy_cmd_chk_json_pathcase(grub_extcmd_context_t ctxt, int argc, char **args)
5608 {
5609 int fstype = 0;
5610 char *device_name = NULL;
5611 grub_device_t dev = NULL;
5612 grub_fs_t fs = NULL;
5613 chk_case_fs_dir fs_dir;
5614
5615 (void)ctxt;
5616 (void)argc;
5617 (void)args;
5618
5619 device_name = grub_file_get_device_name(args[0]);
5620 if (!device_name)
5621 {
5622 goto out;
5623 }
5624
5625 dev = grub_device_open(device_name);
5626 if (!dev)
5627 {
5628 goto out;
5629 }
5630
5631 fs = grub_fs_probe(dev);
5632 if (!fs)
5633 {
5634 goto out;
5635 }
5636
5637 fstype = ventoy_get_fs_type(fs->name);
5638 if (fstype == ventoy_fs_fat || fstype == ventoy_fs_exfat || fstype >= ventoy_fs_max)
5639 {
5640 goto out;
5641 }
5642
5643 g_json_case_mis_path[0] = 0;
5644 fs_dir.dev = dev;
5645 fs_dir.fs = fs;
5646 fs->fs_dir(dev, "/", ventoy_chk_case_dir, &fs_dir);
5647
5648 if (g_json_case_mis_path[0])
5649 {
5650 grub_env_set("VTOY_PLUGIN_PATH_CASE_MISMATCH", g_json_case_mis_path);
5651 }
5652
5653 out:
5654
5655 grub_check_free(device_name);
5656 check_free(dev, grub_device_close);
5657
5658 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
5659 }
5660
5661 static grub_err_t grub_cmd_gptpriority(grub_extcmd_context_t ctxt, int argc, char **args)
5662 {
5663 grub_disk_t disk;
5664 grub_partition_t part;
5665 char priority_str[3]; /* Maximum value 15 */
5666
5667 (void)ctxt;
5668
5669 if (argc < 2 || argc > 3)
5670 return grub_error (GRUB_ERR_BAD_ARGUMENT,
5671 "gptpriority DISKNAME PARTITIONNUM [VARNAME]");
5672
5673 /* Open the disk if it exists */
5674 disk = grub_disk_open (args[0]);
5675 if (!disk)
5676 {
5677 return grub_error (GRUB_ERR_BAD_ARGUMENT,
5678 "Not a disk");
5679 }
5680
5681 part = grub_partition_probe (disk, args[1]);
5682 if (!part)
5683 {
5684 grub_disk_close (disk);
5685 return grub_error (GRUB_ERR_BAD_ARGUMENT,
5686 "No such partition");
5687 }
5688
5689 if (grub_strcmp (part->partmap->name, "gpt"))
5690 {
5691 grub_disk_close (disk);
5692 return grub_error (GRUB_ERR_BAD_PART_TABLE,
5693 "Not a GPT partition");
5694 }
5695
5696 grub_snprintf (priority_str, sizeof(priority_str), "%u",
5697 (grub_uint32_t)((part->gpt_attrib >> 48) & 0xfULL));
5698
5699 if (argc == 3)
5700 {
5701 grub_env_set (args[2], priority_str);
5702 grub_env_export (args[2]);
5703 }
5704 else
5705 {
5706 grub_printf ("Priority is %s\n", priority_str);
5707 }
5708
5709 grub_disk_close (disk);
5710 return GRUB_ERR_NONE;
5711 }
5712
5713
5714 static grub_err_t grub_cmd_syslinux_nojoliet(grub_extcmd_context_t ctxt, int argc, char **args)
5715 {
5716 int ret = 1;
5717 int joliet = 0;
5718 grub_file_t file = NULL;
5719 grub_uint32_t loadrba = 0;
5720 grub_uint32_t boot_catlog = 0;
5721 grub_uint8_t sector[512];
5722 boot_info_table *info = NULL;
5723
5724 (void)ctxt;
5725 (void)argc;
5726
5727 /* This also trigger a iso9660 fs parse */
5728 if (ventoy_check_file_exist("(loop)/isolinux/isolinux.cfg"))
5729 {
5730 return 0;
5731 }
5732
5733 joliet = grub_iso9660_is_joliet();
5734 if (joliet == 0)
5735 {
5736 return 1;
5737 }
5738
5739 file = grub_file_open(args[0], VENTOY_FILE_TYPE);
5740 if (!file)
5741 {
5742 debug("failed to open %s\n", args[0]);
5743 return 1;
5744 }
5745
5746 boot_catlog = ventoy_get_iso_boot_catlog(file);
5747 if (boot_catlog == 0)
5748 {
5749 debug("no bootcatlog found %u\n", boot_catlog);
5750 goto out;
5751 }
5752
5753 loadrba = ventoy_get_bios_eltorito_rba(file, boot_catlog);
5754 if (loadrba == 0)
5755 {
5756 debug("no bios eltorito rba found %u\n", loadrba);
5757 goto out;
5758 }
5759
5760 grub_file_seek(file, loadrba * 2048);
5761 grub_file_read(file, sector, 512);
5762
5763 info = (boot_info_table *)sector;
5764 if (info->bi_data0 == 0x7c6ceafa &&
5765 info->bi_data1 == 0x90900000 &&
5766 info->bi_PrimaryVolumeDescriptor == 16 &&
5767 info->bi_BootFileLocation == loadrba)
5768 {
5769 debug("bootloader is syslinux, %u.\n", loadrba);
5770 ret = 0;
5771 }
5772
5773 out:
5774
5775 grub_file_close(file);
5776 grub_errno = GRUB_ERR_NONE;
5777 return ret;
5778 }
5779
5780 static grub_err_t grub_cmd_vlnk_dump_part(grub_extcmd_context_t ctxt, int argc, char **args)
5781 {
5782 int n = 0;
5783 ventoy_vlnk_part *node;
5784
5785 (void)ctxt;
5786 (void)argc;
5787 (void)args;
5788
5789 for (node = g_vlnk_part_list; node; node = node->next)
5790 {
5791 grub_printf("[%d] %s disksig:%08x offset:%llu fs:%s\n",
5792 ++n, node->device, node->disksig,
5793 (ulonglong)node->partoffset, (node->fs ? node->fs->name : "N/A"));
5794 }
5795
5796 return 0;
5797 }
5798
5799 static grub_err_t grub_cmd_is_vlnk_name(grub_extcmd_context_t ctxt, int argc, char **args)
5800 {
5801 int len = 0;
5802
5803 (void)ctxt;
5804
5805 if (argc == 1)
5806 {
5807 len = (int)grub_strlen(args[0]);
5808 if (grub_file_is_vlnk_suffix(args[0], len))
5809 {
5810 return 0;
5811 }
5812 }
5813
5814 return 1;
5815 }
5816
5817 static grub_err_t grub_cmd_get_vlnk_dst(grub_extcmd_context_t ctxt, int argc, char **args)
5818 {
5819 int vlnk = 0;
5820 const char *name = NULL;
5821
5822 (void)ctxt;
5823
5824 if (argc == 2)
5825 {
5826 grub_env_unset(args[1]);
5827 name = grub_file_get_vlnk(args[0], &vlnk);
5828 if (vlnk)
5829 {
5830 debug("VLNK SRC: <%s>\n", args[0]);
5831 debug("VLNK DST: <%s>\n", name);
5832 grub_env_set(args[1], name);
5833 return 0;
5834 }
5835 }
5836
5837 return 1;
5838 }
5839
5840 static grub_err_t grub_cmd_check_vlnk(grub_extcmd_context_t ctxt, int argc, char **args)
5841 {
5842 int ret = 1;
5843 int len = 0;
5844 grub_file_t file = NULL;
5845 ventoy_vlnk vlnk;
5846 char dst[512];
5847
5848 (void)ctxt;
5849
5850 if (argc != 1)
5851 {
5852 goto out;
5853 }
5854
5855 len = (int)grub_strlen(args[0]);
5856 if (!grub_file_is_vlnk_suffix(args[0], len))
5857 {
5858 grub_printf("Invalid vlnk suffix\n");
5859 goto out;
5860 }
5861
5862 file = grub_file_open(args[0], VENTOY_FILE_TYPE | GRUB_FILE_TYPE_NO_VLNK);
5863 if (!file)
5864 {
5865 grub_printf("Failed to open %s\n", args[0]);
5866 goto out;
5867 }
5868
5869 if (file->size != 32768)
5870 {
5871 grub_printf("Invalid vlnk file (size=%llu).\n", (ulonglong)file->size);
5872 goto out;
5873 }
5874
5875 grub_memset(&vlnk, 0, sizeof(vlnk));
5876 grub_file_read(file, &vlnk, sizeof(vlnk));
5877
5878 ret = ventoy_check_vlnk_data(&vlnk, 1, dst, sizeof(dst));
5879
5880 out:
5881
5882 grub_refresh();
5883 check_free(file, grub_file_close);
5884 grub_errno = GRUB_ERR_NONE;
5885 return ret;
5886 }
5887
5888 static grub_err_t ventoy_iso_vd_id_clear(grub_extcmd_context_t ctxt, int argc, char **args)
5889 {
5890 (void)ctxt;
5891 (void)argc;
5892 (void)args;
5893
5894 g_iso_vd_id_publisher[0] = 0;
5895 g_iso_vd_id_prepare[0] = 0;
5896 g_iso_vd_id_application[0] = 0;
5897
5898 return 0;
5899 }
5900
5901 static grub_err_t ventoy_cmd_iso_vd_id_parse(grub_extcmd_context_t ctxt, int argc, char **args)
5902 {
5903 int ret = 1;
5904 int offset = 318;
5905 grub_file_t file = NULL;
5906
5907 (void)ctxt;
5908 (void)argc;
5909
5910 file = grub_file_open(args[0], VENTOY_FILE_TYPE);
5911 if (!file)
5912 {
5913 grub_printf("Failed to open %s\n", args[0]);
5914 goto out;
5915 }
5916
5917 grub_file_seek(file, 16 * 2048 + offset);
5918 grub_file_read(file, g_iso_vd_id_publisher, 128);
5919
5920 offset += 128;
5921 grub_file_seek(file, 16 * 2048 + offset);
5922 grub_file_read(file, g_iso_vd_id_prepare, 128);
5923
5924 offset += 128;
5925 grub_file_seek(file, 16 * 2048 + offset);
5926 grub_file_read(file, g_iso_vd_id_application, 128);
5927
5928 out:
5929
5930 check_free(file, grub_file_close);
5931 grub_errno = GRUB_ERR_NONE;
5932 return ret;
5933 }
5934
5935 static grub_err_t ventoy_cmd_iso_vd_id_begin(grub_extcmd_context_t ctxt, int argc, char **args)
5936 {
5937 int ret = 1;
5938 char *id = g_iso_vd_id_publisher;
5939
5940 (void)ctxt;
5941 (void)argc;
5942
5943 if (args[0][0] == '1')
5944 {
5945 id = g_iso_vd_id_prepare;
5946 }
5947 else if (args[0][0] == '2')
5948 {
5949 id = g_iso_vd_id_application;
5950 }
5951
5952 if (args[1][0] == '0' && grub_strncasecmp(id, args[2], grub_strlen(args[2])) == 0)
5953 {
5954 ret = 0;
5955 }
5956
5957 if (args[1][0] == '1' && grub_strncmp(id, args[2], grub_strlen(args[2])) == 0)
5958 {
5959 ret = 0;
5960 }
5961
5962 grub_errno = GRUB_ERR_NONE;
5963 return ret;
5964 }
5965
5966 static grub_err_t ventoy_cmd_fn_mutex_lock(grub_extcmd_context_t ctxt, int argc, char **args)
5967 {
5968 (void)ctxt;
5969 (void)argc;
5970
5971 g_ventoy_fn_mutex = 0;
5972 if (argc == 1 && args[0][0] == '1' && args[0][1] == 0)
5973 {
5974 g_ventoy_fn_mutex = 1;
5975 }
5976
5977 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
5978 }
5979
5980 static grub_err_t ventoy_cmd_dump_rsv_page(grub_extcmd_context_t ctxt, int argc, char **args)
5981 {
5982 grub_uint64_t total;
5983 grub_uint64_t org_required;
5984 grub_uint64_t new_required;
5985
5986 (void)ctxt;
5987 (void)argc;
5988 (void)args;
5989
5990 #ifdef GRUB_MACHINE_EFI
5991 grub_efi_get_reserved_page_num(&total, &org_required, &new_required);
5992 grub_printf("Total pages: %llu\n", (unsigned long long)total);
5993 grub_printf("OrgReq pages: %llu\n", (unsigned long long)org_required);
5994 grub_printf("NewReq pages: %llu\n", (unsigned long long)new_required);
5995 #else
5996 (void)total;
5997 (void)org_required;
5998 (void)new_required;
5999 grub_printf("Non EFI mode!\n");
6000 #endif
6001
6002 grub_refresh();
6003
6004 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
6005 }
6006
6007 static grub_err_t ventoy_cmd_need_secondary_menu(grub_extcmd_context_t ctxt, int argc, char **args)
6008 {
6009 const char *env = NULL;
6010
6011 (void)ctxt;
6012 (void)argc;
6013
6014 if (g_ventoy_memdisk_mode || g_ventoy_grub2_mode || g_ventoy_wimboot_mode || g_ventoy_iso_raw)
6015 {
6016 return 1;
6017 }
6018
6019 if (ventoy_check_mode_by_name(args[0], "vtgrub2") ||
6020 ventoy_check_mode_by_name(args[0], "vtwimboot") ||
6021 ventoy_check_mode_by_name(args[0], "vtmemdisk") ||
6022 ventoy_check_mode_by_name(args[0], "vtnormal")
6023 )
6024 {
6025 return 1;
6026 }
6027
6028 env = grub_env_get("VTOY_SECONDARY_BOOT_MENU");
6029 if (env && env[0] == '0' && env[1] == 0)
6030 {
6031 return 1;
6032 }
6033
6034 return 0;
6035 }
6036
6037 static grub_err_t ventoy_cmd_show_secondary_menu(grub_extcmd_context_t ctxt, int argc, char **args)
6038 {
6039 int n = 0;
6040 int pos = 0;
6041 int len = 0;
6042 int select = 0;
6043 int timeout = 0;
6044 char *cmd = NULL;
6045 const char *env = NULL;
6046 ulonglong fsize = 0;
6047 char cfgfile[128];
6048 int seldata[16] = {0};
6049
6050 (void)ctxt;
6051 (void)argc;
6052
6053 len = 8 * VTOY_SIZE_1KB;
6054 cmd = (char *)grub_malloc(len);
6055 if (!cmd)
6056 {
6057 return 1;
6058 }
6059
6060 g_vtoy_secondary_need_recover = 0;
6061 grub_env_unset("VTOY_CHKSUM_FILE_PATH");
6062
6063 env = grub_env_get("VTOY_SECONDARY_TIMEOUT");
6064 if (env)
6065 {
6066 timeout = (int)grub_strtol(env, NULL, 10);
6067 }
6068
6069 if (timeout > 0)
6070 {
6071 vtoy_len_ssprintf(cmd, pos, len, "set timeout=%d\n", timeout);
6072 }
6073
6074 fsize = grub_strtoull(args[2], NULL, 10);
6075
6076 vtoy_dummy_menuentry(cmd, pos, len, "Boot in normal mode", "second_normal"); seldata[n++] = 1;
6077
6078 if (grub_strcmp(args[1], "Unix") != 0)
6079 {
6080 if (grub_strcmp(args[1], "Windows") == 0)
6081 {
6082 vtoy_dummy_menuentry(cmd, pos, len, "Boot in wimboot mode", "second_wimboot"); seldata[n++] = 2;
6083 }
6084 else
6085 {
6086 vtoy_dummy_menuentry(cmd, pos, len, "Boot in grub2 mode", "second_grub2"); seldata[n++] = 3;
6087 }
6088
6089 if (fsize <= VTOY_SIZE_1GB)
6090 {
6091 vtoy_dummy_menuentry(cmd, pos, len, "Boot in memdisk mode", "second_memdisk"); seldata[n++] = 4;
6092 }
6093 }
6094
6095 vtoy_dummy_menuentry(cmd, pos, len, "File checksum", "second_checksum"); seldata[n++] = 5;
6096
6097 do {
6098 g_ventoy_menu_esc = 1;
6099 g_ventoy_suppress_esc = 1;
6100 g_ventoy_suppress_esc_default = 0;
6101 g_ventoy_secondary_menu_on = 1;
6102 grub_snprintf(cfgfile, sizeof(cfgfile), "configfile mem:0x%llx:size:%d", (ulonglong)(ulong)cmd, pos);
6103 grub_script_execute_sourcecode(cfgfile);
6104 g_ventoy_menu_esc = 0;
6105 g_ventoy_suppress_esc = 0;
6106 g_ventoy_suppress_esc_default = 1;
6107 g_ventoy_secondary_menu_on = 0;
6108
6109 select = seldata[g_ventoy_last_entry];
6110
6111 if (select == 2)
6112 {
6113 g_ventoy_wimboot_mode = 1;
6114 g_vtoy_secondary_need_recover = 1;
6115 }
6116 else if (select == 3)
6117 {
6118 g_ventoy_grub2_mode = 1;
6119 g_vtoy_secondary_need_recover = 2;
6120 }
6121 else if (select == 4)
6122 {
6123 g_ventoy_memdisk_mode = 1;
6124 g_vtoy_secondary_need_recover = 3;
6125 }
6126 else if (select == 5)
6127 {
6128 grub_env_set("VTOY_CHKSUM_FILE_PATH", args[0]);
6129 grub_script_execute_sourcecode("configfile $vtoy_efi_part/grub/checksum.cfg");
6130 }
6131 }while (select == 5);
6132
6133 grub_free(cmd);
6134 return 0;
6135 }
6136
6137 static grub_err_t ventoy_cmd_secondary_recover_mode(grub_extcmd_context_t ctxt, int argc, char **args)
6138 {
6139 (void)ctxt;
6140 (void)argc;
6141 (void)args;
6142
6143 if (g_vtoy_secondary_need_recover == 1)
6144 {
6145 g_ventoy_wimboot_mode = 0;
6146 }
6147 else if (g_vtoy_secondary_need_recover == 2)
6148 {
6149 g_ventoy_grub2_mode = 0;
6150 }
6151 else if (g_vtoy_secondary_need_recover == 3)
6152 {
6153 g_ventoy_memdisk_mode = 0;
6154 }
6155
6156 g_vtoy_secondary_need_recover = 0;
6157
6158 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
6159 }
6160
6161 static grub_err_t ventoy_cmd_fs_ignore_case(grub_extcmd_context_t ctxt, int argc, char **args)
6162 {
6163 (void)ctxt;
6164 (void)argc;
6165
6166 if (args[0][0] == '0')
6167 {
6168 g_ventoy_case_insensitive = 0;
6169 }
6170 else
6171 {
6172 g_ventoy_case_insensitive = 1;
6173 }
6174
6175 return 0;
6176 }
6177
6178 int ventoy_env_init(void)
6179 {
6180 int i;
6181 char buf[64];
6182
6183 grub_env_set("vtdebug_flag", "");
6184
6185 g_part_list_buf = grub_malloc(VTOY_PART_BUF_LEN);
6186 g_tree_script_buf = grub_malloc(VTOY_MAX_SCRIPT_BUF);
6187 g_list_script_buf = grub_malloc(VTOY_MAX_SCRIPT_BUF);
6188 for (i = 0; i < VTOY_MAX_CONF_REPLACE; i++)
6189 {
6190 g_conf_replace_new_buf[i] = grub_malloc(vtoy_max_replace_file_size);
6191 }
6192
6193 ventoy_filt_register(0, ventoy_wrapper_open);
6194
6195 g_grub_param = (ventoy_grub_param *)grub_zalloc(sizeof(ventoy_grub_param));
6196 if (g_grub_param)
6197 {
6198 g_grub_param->grub_env_get = grub_env_get;
6199 g_grub_param->grub_env_set = (grub_env_set_pf)grub_env_set;
6200 g_grub_param->grub_env_printf = (grub_env_printf_pf)grub_printf;
6201 grub_snprintf(buf, sizeof(buf), "%p", g_grub_param);
6202 grub_env_set("env_param", buf);
6203 grub_env_set("ventoy_env_param", buf);
6204
6205 grub_env_export("env_param");
6206 grub_env_export("ventoy_env_param");
6207 }
6208
6209 grub_env_export("vtoy_winpeshl_ini_addr");
6210 grub_env_export("vtoy_winpeshl_ini_size");
6211
6212 grub_snprintf(buf, sizeof(buf), "0x%lx", (ulong)ventoy_chain_file_size);
6213 grub_env_set("vtoy_chain_file_size", buf);
6214 grub_env_export("vtoy_chain_file_size");
6215
6216 grub_snprintf(buf, sizeof(buf), "0x%lx", (ulong)ventoy_chain_file_read);
6217 grub_env_set("vtoy_chain_file_read", buf);
6218 grub_env_export("vtoy_chain_file_read");
6219
6220 return 0;
6221 }
6222
6223
6224
6225 static cmd_para ventoy_cmds[] =
6226 {
6227 { "vt_browser_disk", ventoy_cmd_browser_disk, 0, NULL, "", "", NULL },
6228 { "vt_browser_dir", ventoy_cmd_browser_dir, 0, NULL, "", "", NULL },
6229 { "vt_incr", ventoy_cmd_incr, 0, NULL, "{Var} {INT}", "Increase integer variable", NULL },
6230 { "vt_mod", ventoy_cmd_mod, 0, NULL, "{Int} {Int} {Var}", "mod integer variable", NULL },
6231 { "vt_strstr", ventoy_cmd_strstr, 0, NULL, "", "", NULL },
6232 { "vt_str_begin", ventoy_cmd_strbegin, 0, NULL, "", "", NULL },
6233 { "vt_str_casebegin", ventoy_cmd_strcasebegin, 0, NULL, "", "", NULL },
6234 { "vt_debug", ventoy_cmd_debug, 0, NULL, "{on|off}", "turn debug on/off", NULL },
6235 { "vtdebug", ventoy_cmd_debug, 0, NULL, "{on|off}", "turn debug on/off", NULL },
6236 { "vtbreak", ventoy_cmd_break, 0, NULL, "{level}", "set debug break", NULL },
6237 { "vt_cmp", ventoy_cmd_cmp, 0, NULL, "{Int1} { eq|ne|gt|lt|ge|le } {Int2}", "Comare two integers", NULL },
6238 { "vt_device", ventoy_cmd_device, 0, NULL, "path var", "", NULL },
6239 { "vt_check_compatible", ventoy_cmd_check_compatible, 0, NULL, "", "", NULL },
6240 { "vt_list_img", ventoy_cmd_list_img, 0, NULL, "{device} {cntvar}", "find all iso file in device", NULL },
6241 { "vt_clear_img", ventoy_cmd_clear_img, 0, NULL, "", "clear image list", NULL },
6242 { "vt_img_name", ventoy_cmd_img_name, 0, NULL, "{imageID} {var}", "get image name", NULL },
6243 { "vt_chosen_img_path", ventoy_cmd_chosen_img_path, 0, NULL, "{var}", "get chosen img path", NULL },
6244 { "vt_ext_select_img_path", ventoy_cmd_ext_select_img_path, 0, NULL, "{var}", "select chosen img path", NULL },
6245 { "vt_img_sector", ventoy_cmd_img_sector, 0, NULL, "{imageName}", "", NULL },
6246 { "vt_dump_img_sector", ventoy_cmd_dump_img_sector, 0, NULL, "", "", NULL },
6247 { "vt_load_wimboot", ventoy_cmd_load_wimboot, 0, NULL, "", "", NULL },
6248 { "vt_load_vhdboot", ventoy_cmd_load_vhdboot, 0, NULL, "", "", NULL },
6249 { "vt_patch_vhdboot", ventoy_cmd_patch_vhdboot, 0, NULL, "", "", NULL },
6250 { "vt_raw_chain_data", ventoy_cmd_raw_chain_data, 0, NULL, "", "", NULL },
6251 { "vt_get_vtoy_type", ventoy_cmd_get_vtoy_type, 0, NULL, "", "", NULL },
6252 { "vt_check_custom_boot", ventoy_cmd_check_custom_boot, 0, NULL, "", "", NULL },
6253 { "vt_dump_custom_boot", ventoy_cmd_dump_custom_boot, 0, NULL, "", "", NULL },
6254
6255 { "vt_skip_svd", ventoy_cmd_skip_svd, 0, NULL, "", "", NULL },
6256 { "vt_cpio_busybox64", ventoy_cmd_cpio_busybox_64, 0, NULL, "", "", NULL },
6257 { "vt_load_cpio", ventoy_cmd_load_cpio, 0, NULL, "", "", NULL },
6258 { "vt_trailer_cpio", ventoy_cmd_trailer_cpio, 0, NULL, "", "", NULL },
6259 { "vt_push_last_entry", ventoy_cmd_push_last_entry, 0, NULL, "", "", NULL },
6260 { "vt_pop_last_entry", ventoy_cmd_pop_last_entry, 0, NULL, "", "", NULL },
6261 { "vt_get_lib_module_ver", ventoy_cmd_lib_module_ver, 0, NULL, "", "", NULL },
6262
6263 { "vt_load_part_table", ventoy_cmd_load_part_table, 0, NULL, "", "", NULL },
6264 { "vt_check_part_exist", ventoy_cmd_part_exist, 0, NULL, "", "", NULL },
6265 { "vt_get_fs_label", ventoy_cmd_get_fs_label, 0, NULL, "", "", NULL },
6266 { "vt_fs_enum_1st_file", ventoy_cmd_fs_enum_1st_file, 0, NULL, "", "", NULL },
6267 { "vt_fs_enum_1st_dir", ventoy_cmd_fs_enum_1st_dir, 0, NULL, "", "", NULL },
6268 { "vt_file_basename", ventoy_cmd_basename, 0, NULL, "", "", NULL },
6269 { "vt_file_basefile", ventoy_cmd_basefile, 0, NULL, "", "", NULL },
6270 { "vt_enum_video_mode", ventoy_cmd_enum_video_mode, 0, NULL, "", "", NULL },
6271 { "vt_get_video_mode", ventoy_cmd_get_video_mode, 0, NULL, "", "", NULL },
6272 { "vt_update_cur_video_mode", vt_cmd_update_cur_video_mode, 0, NULL, "", "", NULL },
6273
6274
6275 { "vt_find_first_bootable_hd", ventoy_cmd_find_bootable_hdd, 0, NULL, "", "", NULL },
6276 { "vt_dump_menu", ventoy_cmd_dump_menu, 0, NULL, "", "", NULL },
6277 { "vt_dynamic_menu", ventoy_cmd_dynamic_menu, 0, NULL, "", "", NULL },
6278 { "vt_check_mode", ventoy_cmd_check_mode, 0, NULL, "", "", NULL },
6279 { "vt_dump_img_list", ventoy_cmd_dump_img_list, 0, NULL, "", "", NULL },
6280 { "vt_dump_injection", ventoy_cmd_dump_injection, 0, NULL, "", "", NULL },
6281 { "vt_dump_auto_install", ventoy_cmd_dump_auto_install, 0, NULL, "", "", NULL },
6282 { "vt_dump_persistence", ventoy_cmd_dump_persistence, 0, NULL, "", "", NULL },
6283 { "vt_select_auto_install", ventoy_cmd_sel_auto_install, 0, NULL, "", "", NULL },
6284 { "vt_select_persistence", ventoy_cmd_sel_persistence, 0, NULL, "", "", NULL },
6285 { "vt_select_conf_replace", ventoy_select_conf_replace, 0, NULL, "", "", NULL },
6286
6287 { "vt_iso9660_nojoliet", ventoy_cmd_iso9660_nojoliet, 0, NULL, "", "", NULL },
6288 { "vt_iso9660_isjoliet", ventoy_cmd_iso9660_is_joliet, 0, NULL, "", "", NULL },
6289 { "vt_is_udf", ventoy_cmd_is_udf, 0, NULL, "", "", NULL },
6290 { "vt_file_size", ventoy_cmd_file_size, 0, NULL, "", "", NULL },
6291 { "vt_load_file_to_mem", ventoy_cmd_load_file_to_mem, 0, NULL, "", "", NULL },
6292 { "vt_load_img_memdisk", ventoy_cmd_load_img_memdisk, 0, NULL, "", "", NULL },
6293 { "vt_concat_efi_iso", ventoy_cmd_concat_efi_iso, 0, NULL, "", "", NULL },
6294
6295 { "vt_linux_parse_initrd_isolinux", ventoy_cmd_isolinux_initrd_collect, 0, NULL, "{cfgfile}", "", NULL },
6296 { "vt_linux_parse_initrd_grub", ventoy_cmd_grub_initrd_collect, 0, NULL, "{cfgfile}", "", NULL },
6297 { "vt_linux_specify_initrd_file", ventoy_cmd_specify_initrd_file, 0, NULL, "", "", NULL },
6298 { "vt_linux_clear_initrd", ventoy_cmd_clear_initrd_list, 0, NULL, "", "", NULL },
6299 { "vt_linux_dump_initrd", ventoy_cmd_dump_initrd_list, 0, NULL, "", "", NULL },
6300 { "vt_linux_initrd_count", ventoy_cmd_initrd_count, 0, NULL, "", "", NULL },
6301 { "vt_linux_valid_initrd_count", ventoy_cmd_valid_initrd_count, 0, NULL, "", "", NULL },
6302 { "vt_linux_locate_initrd", ventoy_cmd_linux_locate_initrd, 0, NULL, "", "", NULL },
6303 { "vt_linux_chain_data", ventoy_cmd_linux_chain_data, 0, NULL, "", "", NULL },
6304 { "vt_linux_get_main_initrd_index", ventoy_cmd_linux_get_main_initrd_index, 0, NULL, "", "", NULL },
6305
6306 { "vt_windows_reset", ventoy_cmd_wimdows_reset, 0, NULL, "", "", NULL },
6307 { "vt_windows_chain_data", ventoy_cmd_windows_chain_data, 0, NULL, "", "", NULL },
6308 { "vt_windows_wimboot_data", ventoy_cmd_windows_wimboot_data, 0, NULL, "", "", NULL },
6309 { "vt_windows_collect_wim_patch", ventoy_cmd_collect_wim_patch, 0, NULL, "", "", NULL },
6310 { "vt_windows_locate_wim_patch", ventoy_cmd_locate_wim_patch, 0, NULL, "", "", NULL },
6311 { "vt_windows_count_wim_patch", ventoy_cmd_wim_patch_count, 0, NULL, "", "", NULL },
6312 { "vt_dump_wim_patch", ventoy_cmd_dump_wim_patch, 0, NULL, "", "", NULL },
6313 { "vt_wim_check_bootable", ventoy_cmd_wim_check_bootable, 0, NULL, "", "", NULL },
6314 { "vt_wim_chain_data", ventoy_cmd_wim_chain_data, 0, NULL, "", "", NULL },
6315
6316 { "vt_add_replace_file", ventoy_cmd_add_replace_file, 0, NULL, "", "", NULL },
6317 { "vt_get_replace_file_cnt", ventoy_cmd_get_replace_file_cnt, 0, NULL, "", "", NULL },
6318 { "vt_test_block_list", ventoy_cmd_test_block_list, 0, NULL, "", "", NULL },
6319 { "vt_file_exist_nocase", ventoy_cmd_file_exist_nocase, 0, NULL, "", "", NULL },
6320
6321
6322 { "vt_load_plugin", ventoy_cmd_load_plugin, 0, NULL, "", "", NULL },
6323 { "vt_check_plugin_json", ventoy_cmd_plugin_check_json, 0, NULL, "", "", NULL },
6324 { "vt_check_password", ventoy_cmd_check_password, 0, NULL, "", "", NULL },
6325
6326 { "vt_1st_line", ventoy_cmd_read_1st_line, 0, NULL, "", "", NULL },
6327 { "vt_file_strstr", ventoy_cmd_file_strstr, 0, NULL, "", "", NULL },
6328 { "vt_img_part_info", ventoy_cmd_img_part_info, 0, NULL, "", "", NULL },
6329
6330
6331 { "vt_parse_iso_volume", ventoy_cmd_parse_volume, 0, NULL, "", "", NULL },
6332 { "vt_parse_iso_create_date", ventoy_cmd_parse_create_date, 0, NULL, "", "", NULL },
6333 { "vt_parse_freenas_ver", ventoy_cmd_parse_freenas_ver, 0, NULL, "", "", NULL },
6334 { "vt_unix_parse_freebsd_ver", ventoy_cmd_unix_freebsd_ver, 0, NULL, "", "", NULL },
6335 { "vt_unix_parse_freebsd_ver_elf", ventoy_cmd_unix_freebsd_ver_elf, 0, NULL, "", "", NULL },
6336 { "vt_unix_reset", ventoy_cmd_unix_reset, 0, NULL, "", "", NULL },
6337 { "vt_unix_check_vlnk", ventoy_cmd_unix_check_vlnk, 0, NULL, "", "", NULL },
6338 { "vt_unix_replace_conf", ventoy_cmd_unix_replace_conf, 0, NULL, "", "", NULL },
6339 { "vt_unix_replace_grub_conf", ventoy_cmd_unix_replace_grub_conf, 0, NULL, "", "", NULL },
6340 { "vt_unix_replace_ko", ventoy_cmd_unix_replace_ko, 0, NULL, "", "", NULL },
6341 { "vt_unix_ko_fillmap", ventoy_cmd_unix_ko_fillmap, 0, NULL, "", "", NULL },
6342 { "vt_unix_fill_image_desc", ventoy_cmd_unix_fill_image_desc, 0, NULL, "", "", NULL },
6343 { "vt_unix_gzip_new_ko", ventoy_cmd_unix_gzip_newko, 0, NULL, "", "", NULL },
6344 { "vt_unix_chain_data", ventoy_cmd_unix_chain_data, 0, NULL, "", "", NULL },
6345
6346 { "vt_img_hook_root", ventoy_cmd_img_hook_root, 0, NULL, "", "", NULL },
6347 { "vt_img_unhook_root", ventoy_cmd_img_unhook_root, 0, NULL, "", "", NULL },
6348 { "vt_acpi_param", ventoy_cmd_acpi_param, 0, NULL, "", "", NULL },
6349 { "vt_check_secureboot_var", ventoy_cmd_check_secureboot_var, 0, NULL, "", "", NULL },
6350 { "vt_clear_key", ventoy_cmd_clear_key, 0, NULL, "", "", NULL },
6351 { "vt_img_check_range", ventoy_cmd_img_check_range, 0, NULL, "", "", NULL },
6352 { "vt_is_pe64", ventoy_cmd_is_pe64, 0, NULL, "", "", NULL },
6353 { "vt_sel_wimboot", ventoy_cmd_sel_wimboot, 0, NULL, "", "", NULL },
6354 { "vt_set_wim_load_prompt", ventoy_cmd_set_wim_prompt, 0, NULL, "", "", NULL },
6355 { "vt_set_theme", ventoy_cmd_set_theme, 0, NULL, "", "", NULL },
6356 { "vt_set_theme_path", ventoy_cmd_set_theme_path, 0, NULL, "", "", NULL },
6357 { "vt_select_theme_cfg", ventoy_cmd_select_theme_cfg, 0, NULL, "", "", NULL },
6358
6359 { "vt_get_efi_vdisk_offset", ventoy_cmd_get_efivdisk_offset, 0, NULL, "", "", NULL },
6360 { "vt_search_replace_initrd", ventoy_cmd_search_replace_initrd, 0, NULL, "", "", NULL },
6361 { "vt_push_pager", ventoy_cmd_push_pager, 0, NULL, "", "", NULL },
6362 { "vt_pop_pager", ventoy_cmd_pop_pager, 0, NULL, "", "", NULL },
6363 { "vt_check_json_path_case", ventoy_cmd_chk_json_pathcase, 0, NULL, "", "", NULL },
6364 { "vt_append_extra_sector", ventoy_cmd_append_ext_sector, 0, NULL, "", "", NULL },
6365 { "gptpriority", grub_cmd_gptpriority, 0, NULL, "", "", NULL },
6366 { "vt_syslinux_need_nojoliet", grub_cmd_syslinux_nojoliet, 0, NULL, "", "", NULL },
6367 { "vt_vlnk_check", grub_cmd_check_vlnk, 0, NULL, "", "", NULL },
6368 { "vt_vlnk_dump_part", grub_cmd_vlnk_dump_part, 0, NULL, "", "", NULL },
6369 { "vt_is_vlnk_name", grub_cmd_is_vlnk_name, 0, NULL, "", "", NULL },
6370 { "vt_get_vlnk_dst", grub_cmd_get_vlnk_dst, 0, NULL, "", "", NULL },
6371 { "vt_set_fake_vlnk", ventoy_cmd_set_fake_vlnk, 0, NULL, "", "", NULL },
6372 { "vt_reset_fake_vlnk", ventoy_cmd_reset_fake_vlnk, 0, NULL, "", "", NULL },
6373 { "vt_iso_vd_id_parse", ventoy_cmd_iso_vd_id_parse, 0, NULL, "", "", NULL },
6374 { "vt_iso_vd_id_clear", ventoy_iso_vd_id_clear, 0, NULL, "", "", NULL },
6375 { "vt_iso_vd_id_begin", ventoy_cmd_iso_vd_id_begin, 0, NULL, "", "", NULL },
6376 { "vt_fn_mutex_lock", ventoy_cmd_fn_mutex_lock, 0, NULL, "", "", NULL },
6377 { "vt_efi_dump_rsv_page", ventoy_cmd_dump_rsv_page, 0, NULL, "", "", NULL },
6378 { "vt_is_standard_winiso", ventoy_cmd_is_standard_winiso, 0, NULL, "", "", NULL },
6379 { "vt_sel_winpe_wim", ventoy_cmd_sel_winpe_wim, 0, NULL, "", "", NULL },
6380 { "vt_need_secondary_menu", ventoy_cmd_need_secondary_menu, 0, NULL, "", "", NULL },
6381 { "vt_show_secondary_menu", ventoy_cmd_show_secondary_menu, 0, NULL, "", "", NULL },
6382 { "vt_fs_ignore_case", ventoy_cmd_fs_ignore_case, 0, NULL, "", "", NULL },
6383 { "vt_systemd_menu", ventoy_cmd_linux_systemd_menu, 0, NULL, "", "", NULL },
6384 { "vt_limine_menu", ventoy_cmd_linux_limine_menu, 0, NULL, "", "", NULL },
6385 { "vt_secondary_recover_mode", ventoy_cmd_secondary_recover_mode, 0, NULL, "", "", NULL },
6386 };
6387
6388 int ventoy_register_all_cmd(void)
6389 {
6390 grub_uint32_t i;
6391 cmd_para *cur = NULL;
6392
6393 for (i = 0; i < ARRAY_SIZE(ventoy_cmds); i++)
6394 {
6395 cur = ventoy_cmds + i;
6396 cur->cmd = grub_register_extcmd(cur->name, cur->func, cur->flags,
6397 cur->summary, cur->description, cur->parser);
6398 }
6399
6400 return 0;
6401 }
6402
6403 int ventoy_unregister_all_cmd(void)
6404 {
6405 grub_uint32_t i;
6406
6407 for (i = 0; i < ARRAY_SIZE(ventoy_cmds); i++)
6408 {
6409 grub_unregister_extcmd(ventoy_cmds[i].cmd);
6410 }
6411
6412 return 0;
6413 }
6414
6415
https://github.com/ventoy/Ventoy