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


708d4c1516b1a15acbd4bdb6aff788bfdcb78aac
[Ventoy.git] / GRUB2 / MOD_SRC / grub-2.04 / grub-core / ventoy / ventoy.c
1 /******************************************************************************
2 * ventoy.c
3 *
4 * Copyright (c) 2020, 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 #ifdef GRUB_MACHINE_EFI
38 #include <grub/efi/efi.h>
39 #endif
40 #include <grub/time.h>
41 #include <grub/relocator.h>
42 #include <grub/ventoy.h>
43 #include "ventoy_def.h"
44
45 GRUB_MOD_LICENSE ("GPLv3+");
46
47 int g_ventoy_debug = 0;
48 static int g_efi_os = 0xFF;
49 initrd_info *g_initrd_img_list = NULL;
50 initrd_info *g_initrd_img_tail = NULL;
51 int g_initrd_img_count = 0;
52 int g_valid_initrd_count = 0;
53 int g_default_menu_mode = 0;
54 int g_filt_dot_underscore_file = 0;
55 static grub_file_t g_old_file;
56
57 char g_iso_path[256];
58 char g_img_swap_tmp_buf[1024];
59 img_info g_img_swap_tmp;
60 img_info *g_ventoy_img_list = NULL;
61
62 int g_ventoy_img_count = 0;
63
64 grub_device_t g_enum_dev = NULL;
65 grub_fs_t g_enum_fs = NULL;
66 img_iterator_node g_img_iterator_head;
67 img_iterator_node *g_img_iterator_tail = NULL;
68
69 grub_uint8_t g_ventoy_break_level = 0;
70 grub_uint8_t g_ventoy_debug_level = 0;
71 grub_uint8_t g_ventoy_chain_type = 0;
72
73 grub_uint8_t *g_ventoy_cpio_buf = NULL;
74 grub_uint32_t g_ventoy_cpio_size = 0;
75 cpio_newc_header *g_ventoy_initrd_head = NULL;
76 grub_uint8_t *g_ventoy_runtime_buf = NULL;
77
78 ventoy_grub_param *g_grub_param = NULL;
79
80 ventoy_guid g_ventoy_guid = VENTOY_GUID;
81
82 ventoy_img_chunk_list g_img_chunk_list;
83
84 int g_wimboot_enable = 0;
85 ventoy_img_chunk_list g_wimiso_chunk_list;
86 char *g_wimiso_path = NULL;
87
88 static char *g_tree_script_buf = NULL;
89 static int g_tree_script_pos = 0;
90
91 static char *g_list_script_buf = NULL;
92 static int g_list_script_pos = 0;
93
94 static const char *g_menu_class[] =
95 {
96 "vtoyiso", "vtoywim", "vtoyefi", "vtoyimg"
97 };
98
99 static const char *g_menu_prefix[] =
100 {
101 "iso", "wim", "efi", "img"
102 };
103
104 void ventoy_debug(const char *fmt, ...)
105 {
106 va_list args;
107
108 va_start (args, fmt);
109 grub_vprintf (fmt, args);
110 va_end (args);
111 }
112
113 int ventoy_is_efi_os(void)
114 {
115 if (g_efi_os > 1)
116 {
117 g_efi_os = (grub_strstr(GRUB_PLATFORM, "efi")) ? 1 : 0;
118 }
119
120 return g_efi_os;
121 }
122
123 static int ventoy_get_fs_type(const char *fs)
124 {
125 if (NULL == fs)
126 {
127 return ventoy_fs_max;
128 }
129 else if (grub_strncmp(fs, "exfat", 5) == 0)
130 {
131 return ventoy_fs_exfat;
132 }
133 else if (grub_strncmp(fs, "ntfs", 4) == 0)
134 {
135 return ventoy_fs_ntfs;
136 }
137 else if (grub_strncmp(fs, "ext", 3) == 0)
138 {
139 return ventoy_fs_ext;
140 }
141 else if (grub_strncmp(fs, "xfs", 3) == 0)
142 {
143 return ventoy_fs_xfs;
144 }
145 else if (grub_strncmp(fs, "udf", 3) == 0)
146 {
147 return ventoy_fs_udf;
148 }
149 else if (grub_strncmp(fs, "fat", 3) == 0)
150 {
151 return ventoy_fs_fat;
152 }
153
154 return ventoy_fs_max;
155 }
156
157 static int ventoy_string_check(const char *str, grub_char_check_func check)
158 {
159 if (!str)
160 {
161 return 0;
162 }
163
164 for ( ; *str; str++)
165 {
166 if (!check(*str))
167 {
168 return 0;
169 }
170 }
171
172 return 1;
173 }
174
175
176 static grub_ssize_t ventoy_fs_read(grub_file_t file, char *buf, grub_size_t len)
177 {
178 grub_memcpy(buf, (char *)file->data + file->offset, len);
179 return len;
180 }
181
182 static grub_err_t ventoy_fs_close(grub_file_t file)
183 {
184 grub_file_close(g_old_file);
185 grub_free(file->data);
186
187 file->device = 0;
188 file->name = 0;
189
190 return 0;
191 }
192
193 static grub_file_t ventoy_wrapper_open(grub_file_t rawFile, enum grub_file_type type)
194 {
195 int len;
196 grub_file_t file;
197 static struct grub_fs vtoy_fs =
198 {
199 .name = "vtoy",
200 .fs_dir = 0,
201 .fs_open = 0,
202 .fs_read = ventoy_fs_read,
203 .fs_close = ventoy_fs_close,
204 .fs_label = 0,
205 .next = 0
206 };
207
208 if (type != 52)
209 {
210 return rawFile;
211 }
212
213 file = (grub_file_t)grub_zalloc(sizeof (*file));
214 if (!file)
215 {
216 return 0;
217 }
218
219 file->data = grub_malloc(rawFile->size + 4096);
220 if (!file->data)
221 {
222 return 0;
223 }
224
225 grub_file_read(rawFile, file->data, rawFile->size);
226 len = ventoy_fill_data(4096, (char *)file->data + rawFile->size);
227
228 g_old_file = rawFile;
229
230 file->size = rawFile->size + len;
231 file->device = rawFile->device;
232 file->fs = &vtoy_fs;
233 file->not_easily_seekable = 1;
234
235 return file;
236 }
237
238 static int ventoy_check_decimal_var(const char *name, long *value)
239 {
240 const char *value_str = NULL;
241
242 value_str = grub_env_get(name);
243 if (NULL == value_str)
244 {
245 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Variable %s not found", name);
246 }
247
248 if (!ventoy_is_decimal(value_str))
249 {
250 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Variable %s value '%s' is not an integer", name, value_str);
251 }
252
253 *value = grub_strtol(value_str, NULL, 10);
254
255 return GRUB_ERR_NONE;
256 }
257
258 static grub_err_t ventoy_cmd_debug(grub_extcmd_context_t ctxt, int argc, char **args)
259 {
260 if (argc != 1)
261 {
262 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s {on|off}", cmd_raw_name);
263 }
264
265 if (0 == grub_strcmp(args[0], "on"))
266 {
267 g_ventoy_debug = 1;
268 grub_env_set("vtdebug_flag", "debug");
269 }
270 else
271 {
272 g_ventoy_debug = 0;
273 grub_env_set("vtdebug_flag", "");
274 }
275
276 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
277 }
278
279 static grub_err_t ventoy_cmd_break(grub_extcmd_context_t ctxt, int argc, char **args)
280 {
281 (void)ctxt;
282
283 if (argc < 1 || (args[0][0] != '0' && args[0][0] != '1'))
284 {
285 grub_printf("Usage: %s {level} [debug]\r\n", cmd_raw_name);
286 grub_printf(" level:\r\n");
287 grub_printf(" 01/11: busybox / (+cat log)\r\n");
288 grub_printf(" 02/12: initrd / (+cat log)\r\n");
289 grub_printf(" 03/13: hook / (+cat log)\r\n");
290 grub_printf("\r\n");
291 grub_printf(" debug:\r\n");
292 grub_printf(" 0: debug is on\r\n");
293 grub_printf(" 1: debug is off\r\n");
294 grub_printf("\r\n");
295 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
296 }
297
298 g_ventoy_break_level = (grub_uint8_t)grub_strtoul(args[0], NULL, 16);
299
300 if (argc > 1 && grub_strtoul(args[1], NULL, 10) > 0)
301 {
302 g_ventoy_debug_level = 1;
303 }
304
305 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
306 }
307
308 static grub_err_t ventoy_cmd_incr(grub_extcmd_context_t ctxt, int argc, char **args)
309 {
310 long value_long = 0;
311 char buf[32];
312
313 if ((argc != 2) || (!ventoy_is_decimal(args[1])))
314 {
315 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s {Variable} {Int}", cmd_raw_name);
316 }
317
318 if (GRUB_ERR_NONE != ventoy_check_decimal_var(args[0], &value_long))
319 {
320 return grub_errno;
321 }
322
323 value_long += grub_strtol(args[1], NULL, 10);
324
325 grub_snprintf(buf, sizeof(buf), "%ld", value_long);
326 grub_env_set(args[0], buf);
327
328 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
329 }
330
331 static grub_err_t ventoy_cmd_file_size(grub_extcmd_context_t ctxt, int argc, char **args)
332 {
333 int rc = 1;
334 char buf[32];
335 grub_file_t file;
336
337 (void)ctxt;
338 (void)argc;
339 (void)args;
340
341 if (argc != 2)
342 {
343 return rc;
344 }
345
346 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", args[0]);
347 if (file == NULL)
348 {
349 debug("failed to open file <%s> for udf check\n", args[0]);
350 return 1;
351 }
352
353 grub_snprintf(buf, sizeof(buf), "%llu", (unsigned long long)file->size);
354
355 grub_env_set(args[1], buf);
356
357 grub_file_close(file);
358 rc = 0;
359
360 return rc;
361 }
362
363 static grub_err_t ventoy_cmd_load_wimboot(grub_extcmd_context_t ctxt, int argc, char **args)
364 {
365 grub_file_t file;
366
367 (void)ctxt;
368 (void)argc;
369 (void)args;
370
371 g_wimboot_enable = 0;
372 grub_check_free(g_wimiso_path);
373 grub_check_free(g_wimiso_chunk_list.chunk);
374
375 file = grub_file_open(args[0], VENTOY_FILE_TYPE);
376 if (!file)
377 {
378 return 0;
379 }
380
381 grub_memset(&g_wimiso_chunk_list, 0, sizeof(g_wimiso_chunk_list));
382 g_wimiso_chunk_list.chunk = grub_malloc(sizeof(ventoy_img_chunk) * DEFAULT_CHUNK_NUM);
383 if (NULL == g_wimiso_chunk_list.chunk)
384 {
385 return grub_error(GRUB_ERR_OUT_OF_MEMORY, "Can't allocate image chunk memoty\n");
386 }
387
388 g_wimiso_chunk_list.max_chunk = DEFAULT_CHUNK_NUM;
389 g_wimiso_chunk_list.cur_chunk = 0;
390
391 ventoy_get_block_list(file, &g_wimiso_chunk_list, file->device->disk->partition->start);
392
393 g_wimboot_enable = 1;
394 g_wimiso_path = grub_strdup(args[0]);
395
396 grub_file_close(file);
397
398 return 0;
399 }
400
401 static grub_err_t ventoy_cmd_load_iso_to_mem(grub_extcmd_context_t ctxt, int argc, char **args)
402 {
403 int rc = 1;
404 char name[32];
405 char value[32];
406 char *buf = NULL;
407 grub_file_t file;
408
409 (void)ctxt;
410 (void)argc;
411 (void)args;
412
413 if (argc != 2)
414 {
415 return rc;
416 }
417
418 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", args[0]);
419 if (file == NULL)
420 {
421 debug("failed to open file <%s> for udf check\n", args[0]);
422 return 1;
423 }
424
425 #ifdef GRUB_MACHINE_EFI
426 buf = (char *)grub_efi_allocate_iso_buf(file->size);
427 #else
428 buf = (char *)grub_malloc(file->size);
429 #endif
430
431 grub_file_read(file, buf, file->size);
432
433 grub_snprintf(name, sizeof(name), "%s_addr", args[1]);
434 grub_snprintf(value, sizeof(value), "0x%llx", (unsigned long long)(unsigned long)buf);
435 grub_env_set(name, value);
436
437 grub_snprintf(name, sizeof(name), "%s_size", args[1]);
438 grub_snprintf(value, sizeof(value), "%llu", (unsigned long long)file->size);
439 grub_env_set(name, value);
440
441 grub_file_close(file);
442 rc = 0;
443
444 return rc;
445 }
446
447 static grub_err_t ventoy_cmd_iso9660_nojoliet(grub_extcmd_context_t ctxt, int argc, char **args)
448 {
449 (void)ctxt;
450
451 if (argc != 1)
452 {
453 return 1;
454 }
455
456 if (args[0][0] == '1')
457 {
458 grub_iso9660_set_nojoliet(1);
459 }
460 else
461 {
462 grub_iso9660_set_nojoliet(0);
463 }
464
465 return 0;
466 }
467
468 static grub_err_t ventoy_cmd_is_udf(grub_extcmd_context_t ctxt, int argc, char **args)
469 {
470 int i;
471 int rc = 1;
472 grub_file_t file;
473 grub_uint8_t buf[32];
474
475 (void)ctxt;
476 (void)argc;
477 (void)args;
478
479 if (argc != 1)
480 {
481 return rc;
482 }
483
484 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", args[0]);
485 if (file == NULL)
486 {
487 debug("failed to open file <%s> for udf check\n", args[0]);
488 return 1;
489 }
490
491 for (i = 16; i < 32; i++)
492 {
493 grub_file_seek(file, i * 2048);
494 grub_file_read(file, buf, sizeof(buf));
495 if (buf[0] == 255)
496 {
497 break;
498 }
499 }
500
501 i++;
502 grub_file_seek(file, i * 2048);
503 grub_file_read(file, buf, sizeof(buf));
504
505 if (grub_memcmp(buf + 1, "BEA01", 5) == 0)
506 {
507 i++;
508 grub_file_seek(file, i * 2048);
509 grub_file_read(file, buf, sizeof(buf));
510
511 if (grub_memcmp(buf + 1, "NSR02", 5) == 0 ||
512 grub_memcmp(buf + 1, "NSR03", 5) == 0)
513 {
514 rc = 0;
515 }
516 }
517
518 grub_file_close(file);
519
520 debug("ISO UDF: %s\n", rc ? "NO" : "YES");
521
522 return rc;
523 }
524
525 static grub_err_t ventoy_cmd_cmp(grub_extcmd_context_t ctxt, int argc, char **args)
526 {
527 long value_long1 = 0;
528 long value_long2 = 0;
529
530 if ((argc != 3) || (!ventoy_is_decimal(args[0])) || (!ventoy_is_decimal(args[2])))
531 {
532 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s {Int1} { eq|ne|gt|lt|ge|le } {Int2}", cmd_raw_name);
533 }
534
535 value_long1 = grub_strtol(args[0], NULL, 10);
536 value_long2 = grub_strtol(args[2], NULL, 10);
537
538 if (0 == grub_strcmp(args[1], "eq"))
539 {
540 grub_errno = (value_long1 == value_long2) ? GRUB_ERR_NONE : GRUB_ERR_TEST_FAILURE;
541 }
542 else if (0 == grub_strcmp(args[1], "ne"))
543 {
544 grub_errno = (value_long1 != value_long2) ? GRUB_ERR_NONE : GRUB_ERR_TEST_FAILURE;
545 }
546 else if (0 == grub_strcmp(args[1], "gt"))
547 {
548 grub_errno = (value_long1 > value_long2) ? GRUB_ERR_NONE : GRUB_ERR_TEST_FAILURE;
549 }
550 else if (0 == grub_strcmp(args[1], "lt"))
551 {
552 grub_errno = (value_long1 < value_long2) ? GRUB_ERR_NONE : GRUB_ERR_TEST_FAILURE;
553 }
554 else if (0 == grub_strcmp(args[1], "ge"))
555 {
556 grub_errno = (value_long1 >= value_long2) ? GRUB_ERR_NONE : GRUB_ERR_TEST_FAILURE;
557 }
558 else if (0 == grub_strcmp(args[1], "le"))
559 {
560 grub_errno = (value_long1 <= value_long2) ? GRUB_ERR_NONE : GRUB_ERR_TEST_FAILURE;
561 }
562 else
563 {
564 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s {Int1} { eq ne gt lt ge le } {Int2}", cmd_raw_name);
565 }
566
567 return grub_errno;
568 }
569
570 static grub_err_t ventoy_cmd_device(grub_extcmd_context_t ctxt, int argc, char **args)
571 {
572 char *pos = NULL;
573 char buf[128] = {0};
574
575 if (argc != 2)
576 {
577 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s path var", cmd_raw_name);
578 }
579
580 grub_strncpy(buf, (args[0][0] == '(') ? args[0] + 1 : args[0], sizeof(buf) - 1);
581 pos = grub_strstr(buf, ",");
582 if (pos)
583 {
584 *pos = 0;
585 }
586
587 grub_env_set(args[1], buf);
588
589 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
590 }
591
592 static grub_err_t ventoy_cmd_check_compatible(grub_extcmd_context_t ctxt, int argc, char **args)
593 {
594 int i;
595 char buf[256];
596 grub_disk_t disk;
597 char *pos = NULL;
598 const char *files[] = { "ventoy.dat", "VENTOY.DAT" };
599
600 (void)ctxt;
601
602 if (argc != 1)
603 {
604 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s (loop)", cmd_raw_name);
605 }
606
607 for (i = 0; i < (int)ARRAY_SIZE(files); i++)
608 {
609 grub_snprintf(buf, sizeof(buf) - 1, "[ -e %s/%s ]", args[0], files[i]);
610 if (0 == grub_script_execute_sourcecode(buf))
611 {
612 debug("file %s exist, ventoy_compatible YES\n", buf);
613 grub_env_set("ventoy_compatible", "YES");
614 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
615 }
616 else
617 {
618 debug("file %s NOT exist\n", buf);
619 }
620 }
621
622 grub_snprintf(buf, sizeof(buf) - 1, "%s", args[0][0] == '(' ? (args[0] + 1) : args[0]);
623 pos = grub_strstr(buf, ")");
624 if (pos)
625 {
626 *pos = 0;
627 }
628
629 disk = grub_disk_open(buf);
630 if (disk)
631 {
632 grub_disk_read(disk, 16 << 2, 0, 1024, g_img_swap_tmp_buf);
633 grub_disk_close(disk);
634
635 g_img_swap_tmp_buf[703] = 0;
636 for (i = 319; i < 703; i++)
637 {
638 if (g_img_swap_tmp_buf[i] == 'V' &&
639 0 == grub_strncmp(g_img_swap_tmp_buf + i, VENTOY_COMPATIBLE_STR, VENTOY_COMPATIBLE_STR_LEN))
640 {
641 debug("Ventoy compatible string exist at %d, ventoy_compatible YES\n", i);
642 grub_env_set("ventoy_compatible", "YES");
643 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
644 }
645 }
646 }
647 else
648 {
649 debug("failed to open disk <%s>\n", buf);
650 }
651
652 grub_env_set("ventoy_compatible", "NO");
653 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
654 }
655
656 int ventoy_cmp_img(img_info *img1, img_info *img2)
657 {
658 char *s1, *s2;
659 int c1 = 0;
660 int c2 = 0;
661
662 for (s1 = img1->name, s2 = img2->name; *s1 && *s2; s1++, s2++)
663 {
664 c1 = *s1;
665 c2 = *s2;
666
667 if (grub_islower(c1))
668 {
669 c1 = c1 - 'a' + 'A';
670 }
671
672 if (grub_islower(c2))
673 {
674 c2 = c2 - 'a' + 'A';
675 }
676
677 if (c1 != c2)
678 {
679 break;
680 }
681 }
682
683 return (c1 - c2);
684 }
685
686 void ventoy_swap_img(img_info *img1, img_info *img2)
687 {
688 grub_memcpy(&g_img_swap_tmp, img1, sizeof(img_info));
689
690 grub_memcpy(img1, img2, sizeof(img_info));
691 img1->next = g_img_swap_tmp.next;
692 img1->prev = g_img_swap_tmp.prev;
693
694 g_img_swap_tmp.next = img2->next;
695 g_img_swap_tmp.prev = img2->prev;
696 grub_memcpy(img2, &g_img_swap_tmp, sizeof(img_info));
697 }
698
699 static int ventoy_img_name_valid(const char *filename, grub_size_t namelen)
700 {
701 grub_size_t i;
702
703 if (g_filt_dot_underscore_file && filename[0] == '.' && filename[1] == '_')
704 {
705 return 0;
706 }
707
708 for (i = 0; i < namelen; i++)
709 {
710 if (filename[i] == ' ' || filename[i] == '\t')
711 {
712 return 0;
713 }
714
715 if ((grub_uint8_t)(filename[i]) >= 127)
716 {
717 return 0;
718 }
719 }
720
721 return 1;
722 }
723
724 static int ventoy_check_ignore_flag(const char *filename, const struct grub_dirhook_info *info, void *data)
725 {
726 if (0 == info->dir)
727 {
728 if (filename && filename[0] == '.' && 0 == grub_strncmp(filename, ".ventoyignore", 13))
729 {
730 *((int *)data) = 1;
731 return 0;
732 }
733 }
734
735 return 0;
736 }
737
738 static int ventoy_colect_img_files(const char *filename, const struct grub_dirhook_info *info, void *data)
739 {
740 int i = 0;
741 int type = 0;
742 int ignore = 0;
743 grub_size_t len;
744 img_info *img;
745 img_info *tail;
746 img_iterator_node *tmp;
747 img_iterator_node *new_node;
748 img_iterator_node *node = (img_iterator_node *)data;
749
750 len = grub_strlen(filename);
751
752 if (info->dir)
753 {
754 if ((len == 1 && filename[0] == '.') ||
755 (len == 2 && filename[0] == '.' && filename[1] == '.'))
756 {
757 return 0;
758 }
759
760 if (!ventoy_img_name_valid(filename, len))
761 {
762 return 0;
763 }
764
765 if (filename[0] == '$' && 0 == grub_strncmp(filename, "$RECYCLE.BIN", 12))
766 {
767 return 0;
768 }
769
770 new_node = grub_zalloc(sizeof(img_iterator_node));
771 if (new_node)
772 {
773 new_node->dirlen = grub_snprintf(new_node->dir, sizeof(new_node->dir), "%s%s/", node->dir, filename);
774
775 g_enum_fs->fs_dir(g_enum_dev, new_node->dir, ventoy_check_ignore_flag, &ignore);
776 if (ignore)
777 {
778 debug("Directory %s ignored...\n", new_node->dir);
779 grub_free(new_node);
780 return 0;
781 }
782
783 new_node->tail = node->tail;
784
785 new_node->parent = node;
786 if (!node->firstchild)
787 {
788 node->firstchild = new_node;
789 }
790
791 if (g_img_iterator_tail)
792 {
793 g_img_iterator_tail->next = new_node;
794 g_img_iterator_tail = new_node;
795 }
796 else
797 {
798 g_img_iterator_head.next = new_node;
799 g_img_iterator_tail = new_node;
800 }
801 }
802 }
803 else
804 {
805 debug("Find a file %s\n", filename);
806 if (len <= 4)
807 {
808 return 0;
809 }
810
811 if (0 == grub_strcasecmp(filename + len - 4, ".iso"))
812 {
813 type = img_type_iso;
814 }
815 else if (g_wimboot_enable && (0 == grub_strcasecmp(filename + len - 4, ".wim")))
816 {
817 type = img_type_wim;
818 }
819 #ifdef GRUB_MACHINE_EFI
820 else if (0 == grub_strcasecmp(filename + len - 4, ".efi"))
821 {
822 type = img_type_efi;
823 }
824 #endif
825 else
826 {
827 return 0;
828 }
829
830 if (g_filt_dot_underscore_file && filename[0] == '.' && filename[1] == '_')
831 {
832 return 0;
833 }
834
835 img = grub_zalloc(sizeof(img_info));
836 if (img)
837 {
838 img->type = type;
839 grub_snprintf(img->name, sizeof(img->name), "%s", filename);
840
841 for (i = 0; i < (int)len; i++)
842 {
843 if (filename[i] == ' ' || filename[i] == '\t' || (0 == grub_isprint(filename[i])))
844 {
845 img->name[i] = '*';
846 img->unsupport = 1;
847 }
848 }
849
850 img->pathlen = grub_snprintf(img->path, sizeof(img->path), "%s%s", node->dir, img->name);
851
852 img->size = info->size;
853 if (0 == img->size)
854 {
855 img->size = ventoy_grub_get_file_size("%s/%s%s", g_iso_path, node->dir, filename);
856 }
857
858 if (img->size < VTOY_FILT_MIN_FILE_SIZE)
859 {
860 debug("img <%s> size too small %llu\n", img->name, (ulonglong)img->size);
861 grub_free(img);
862 return 0;
863 }
864
865 if (g_ventoy_img_list)
866 {
867 tail = *(node->tail);
868 img->prev = tail;
869 tail->next = img;
870 }
871 else
872 {
873 g_ventoy_img_list = img;
874 }
875
876 img->id = g_ventoy_img_count;
877 img->parent = node;
878 if (node && NULL == node->firstiso)
879 {
880 node->firstiso = img;
881 }
882
883 node->isocnt++;
884 tmp = node->parent;
885 while (tmp)
886 {
887 tmp->isocnt++;
888 tmp = tmp->parent;
889 }
890
891 *((img_info **)(node->tail)) = img;
892 g_ventoy_img_count++;
893
894 img->alias = ventoy_plugin_get_menu_alias(vtoy_alias_image_file, img->path);
895 img->class = ventoy_plugin_get_menu_class(vtoy_class_image_file, img->name);
896 if (!img->class)
897 {
898 img->class = g_menu_class[type];
899 }
900 img->menu_prefix = g_menu_prefix[type];
901
902 debug("Add %s%s to list %d\n", node->dir, filename, g_ventoy_img_count);
903 }
904 }
905
906 return 0;
907 }
908
909 int ventoy_fill_data(grub_uint32_t buflen, char *buffer)
910 {
911 int len = GRUB_UINT_MAX;
912 const char *value = NULL;
913 char name[32] = {0};
914 char plat[32] = {0};
915 char guidstr[32] = {0};
916 ventoy_guid guid = VENTOY_GUID;
917 const char *fmt1 = NULL;
918 const char *fmt2 = NULL;
919 const char *fmt3 = NULL;
920 grub_uint32_t *puint = (grub_uint32_t *)name;
921 grub_uint32_t *puint2 = (grub_uint32_t *)plat;
922 const char fmtdata[]={ 0x39, 0x35, 0x25, 0x00, 0x35, 0x00, 0x23, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x00 };
923 const char fmtcode[]={
924 0x22, 0x0A, 0x2B, 0x20, 0x68, 0x62, 0x6F, 0x78, 0x20, 0x7B, 0x0A, 0x20, 0x20, 0x74, 0x6F, 0x70,
925 0x20, 0x3D, 0x20, 0x25, 0x73, 0x0A, 0x20, 0x20, 0x6C, 0x65, 0x66, 0x74, 0x20, 0x3D, 0x20, 0x25,
926 0x73, 0x0A, 0x20, 0x20, 0x2B, 0x20, 0x6C, 0x61, 0x62, 0x65, 0x6C, 0x20, 0x7B, 0x74, 0x65, 0x78,
927 0x74, 0x20, 0x3D, 0x20, 0x22, 0x25, 0x73, 0x20, 0x25, 0x73, 0x25, 0x73, 0x22, 0x20, 0x63, 0x6F,
928 0x6C, 0x6F, 0x72, 0x20, 0x3D, 0x20, 0x22, 0x25, 0x73, 0x22, 0x20, 0x61, 0x6C, 0x69, 0x67, 0x6E,
929 0x20, 0x3D, 0x20, 0x22, 0x6C, 0x65, 0x66, 0x74, 0x22, 0x7D, 0x0A, 0x7D, 0x0A, 0x22, 0x00
930 };
931
932 grub_memset(name, 0, sizeof(name));
933 puint[0] = grub_swap_bytes32(0x56454e54);
934 puint[3] = grub_swap_bytes32(0x4f4e0000);
935 puint[2] = grub_swap_bytes32(0x45525349);
936 puint[1] = grub_swap_bytes32(0x4f595f56);
937 value = ventoy_get_env(name);
938
939 grub_memset(name, 0, sizeof(name));
940 puint[1] = grub_swap_bytes32(0x5f544f50);
941 puint[0] = grub_swap_bytes32(0x56544c45);
942 fmt1 = ventoy_get_env(name);
943 if (!fmt1)
944 {
945 fmt1 = fmtdata;
946 }
947
948 grub_memset(name, 0, sizeof(name));
949 puint[1] = grub_swap_bytes32(0x5f4c4654);
950 puint[0] = grub_swap_bytes32(0x56544c45);
951 fmt2 = ventoy_get_env(name);
952
953 grub_memset(name, 0, sizeof(name));
954 puint[1] = grub_swap_bytes32(0x5f434c52);
955 puint[0] = grub_swap_bytes32(0x56544c45);
956 fmt3 = ventoy_get_env(name);
957
958 grub_memcpy(guidstr, &guid, sizeof(guid));
959
960 #if defined (GRUB_MACHINE_EFI)
961 puint2[0] = grub_swap_bytes32(0x55454649);
962 #else
963 puint2[0] = grub_swap_bytes32(0x42494f53);
964 #endif
965
966 /* Easter egg :) It will be appreciated if you reserve it, but NOT mandatory. */
967 #pragma GCC diagnostic push
968 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
969 len = grub_snprintf(buffer, buflen, fmtcode,
970 fmt1 ? fmt1 : fmtdata,
971 fmt2 ? fmt2 : fmtdata + 4,
972 value ? value : "", plat, guidstr,
973 fmt3 ? fmt3 : fmtdata + 6);
974 #pragma GCC diagnostic pop
975
976 grub_memset(name, 0, sizeof(name));
977 puint[0] = grub_swap_bytes32(0x76746f79);
978 puint[2] = grub_swap_bytes32(0x656e7365);
979 puint[1] = grub_swap_bytes32(0x5f6c6963);
980 ventoy_set_env(name, guidstr);
981
982 return len;
983 }
984
985 static img_info * ventoy_get_min_iso(img_iterator_node *node)
986 {
987 img_info *minimg = NULL;
988 img_info *img = (img_info *)(node->firstiso);
989
990 while (img && (img_iterator_node *)(img->parent) == node)
991 {
992 if (img->select == 0 && (NULL == minimg || grub_strcmp(img->name, minimg->name) < 0))
993 {
994 minimg = img;
995 }
996 img = img->next;
997 }
998
999 if (minimg)
1000 {
1001 minimg->select = 1;
1002 }
1003
1004 return minimg;
1005 }
1006
1007 static img_iterator_node * ventoy_get_min_child(img_iterator_node *node)
1008 {
1009 img_iterator_node *Minchild = NULL;
1010 img_iterator_node *child = node->firstchild;
1011
1012 while (child && child->parent == node)
1013 {
1014 if (child->select == 0 && (NULL == Minchild || grub_strcmp(child->dir, Minchild->dir) < 0))
1015 {
1016 Minchild = child;
1017 }
1018 child = child->next;
1019 }
1020
1021 if (Minchild)
1022 {
1023 Minchild->select = 1;
1024 }
1025
1026 return Minchild;
1027 }
1028
1029 static int ventoy_dynamic_tree_menu(img_iterator_node *node)
1030 {
1031 int offset = 1;
1032 img_info *img = NULL;
1033 const char *dir_class = NULL;
1034 const char *dir_alias = NULL;
1035 img_iterator_node *child = NULL;
1036
1037 if (node->isocnt == 0 || node->done == 1)
1038 {
1039 return 0;
1040 }
1041
1042 if (node->parent && node->parent->dirlen < node->dirlen)
1043 {
1044 offset = node->parent->dirlen;
1045 }
1046
1047 if (node == &g_img_iterator_head)
1048 {
1049 if (g_default_menu_mode == 0)
1050 {
1051 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos,
1052 "menuentry \"%-10s [Return to ListView]\" --class=\"vtoyret\" VTOY_RET {\n "
1053 " echo 'return ...' \n"
1054 "}\n", "<--");
1055 }
1056 }
1057 else
1058 {
1059 node->dir[node->dirlen - 1] = 0;
1060 dir_class = ventoy_plugin_get_menu_class(vtoy_class_directory, node->dir);
1061 if (!dir_class)
1062 {
1063 dir_class = "vtoydir";
1064 }
1065
1066 dir_alias = ventoy_plugin_get_menu_alias(vtoy_alias_directory, node->dir);
1067 if (dir_alias)
1068 {
1069 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos,
1070 "submenu \"%-10s %s\" --class=\"%s\" {\n",
1071 "DIR", dir_alias, dir_class);
1072 }
1073 else
1074 {
1075 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos,
1076 "submenu \"%-10s [%s]\" --class=\"%s\" {\n",
1077 "DIR", node->dir + offset, dir_class);
1078 }
1079
1080 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos,
1081 "menuentry \"%-10s [../]\" --class=\"vtoyret\" VTOY_RET {\n "
1082 " echo 'return ...' \n"
1083 "}\n", "<--");
1084 }
1085
1086 while ((child = ventoy_get_min_child(node)) != NULL)
1087 {
1088 ventoy_dynamic_tree_menu(child);
1089 }
1090
1091 while ((img = ventoy_get_min_iso(node)) != NULL)
1092 {
1093 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos,
1094 "menuentry \"%-10s %s%s\" --class=\"%s\" --id=\"VID_%d\" {\n"
1095 " %s_%s \n"
1096 "}\n",
1097 grub_get_human_size(img->size, GRUB_HUMAN_SIZE_SHORT),
1098 img->unsupport ? "[unsupported] " : "",
1099 img->alias ? img->alias : img->name, img->class, img->id,
1100 img->menu_prefix,
1101 img->unsupport ? "unsupport_menuentry" : "common_menuentry");
1102 }
1103
1104 if (node != &g_img_iterator_head)
1105 {
1106 vtoy_ssprintf(g_tree_script_buf, g_tree_script_pos, "%s", "}\n");
1107 }
1108
1109 node->done = 1;
1110 return 0;
1111 }
1112
1113 static grub_err_t ventoy_cmd_list_img(grub_extcmd_context_t ctxt, int argc, char **args)
1114 {
1115 int len;
1116 grub_fs_t fs;
1117 grub_device_t dev = NULL;
1118 img_info *cur = NULL;
1119 img_info *tail = NULL;
1120 img_info *default_node = NULL;
1121 const char *strdata = NULL;
1122 char *device_name = NULL;
1123 const char *default_image = NULL;
1124 int img_len = 0;
1125 char buf[32];
1126 img_iterator_node *node = NULL;
1127 img_iterator_node *tmp = NULL;
1128
1129 (void)ctxt;
1130
1131 if (argc != 2)
1132 {
1133 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s {device} {cntvar}", cmd_raw_name);
1134 }
1135
1136 if (g_ventoy_img_list || g_ventoy_img_count)
1137 {
1138 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Must clear image before list");
1139 }
1140
1141 strdata = ventoy_get_env("VTOY_FILT_DOT_UNDERSCORE_FILE");
1142 if (strdata && strdata[0] == '1' && strdata[1] == 0)
1143 {
1144 g_filt_dot_underscore_file = 1;
1145 }
1146
1147 device_name = grub_file_get_device_name(args[0]);
1148 if (!device_name)
1149 {
1150 goto fail;
1151 }
1152
1153 g_enum_dev = dev = grub_device_open(device_name);
1154 if (!dev)
1155 {
1156 goto fail;
1157 }
1158
1159 g_enum_fs = fs = grub_fs_probe(dev);
1160 if (!fs)
1161 {
1162 goto fail;
1163 }
1164
1165 if (ventoy_get_fs_type(fs->name) >= ventoy_fs_max)
1166 {
1167 debug("unsupported fs:<%s>\n", fs->name);
1168 ventoy_set_env("VTOY_NO_ISO_TIP", "unsupported file system");
1169 goto fail;
1170 }
1171
1172 strdata = ventoy_get_env("VTOY_DEFAULT_MENU_MODE");
1173 if (strdata && strdata[0] == '1')
1174 {
1175 g_default_menu_mode = 1;
1176 }
1177
1178 grub_memset(&g_img_iterator_head, 0, sizeof(g_img_iterator_head));
1179
1180 grub_snprintf(g_iso_path, sizeof(g_iso_path), "%s", args[0]);
1181
1182 strdata = ventoy_get_env("VTOY_DEFAULT_SEARCH_ROOT");
1183 if (strdata && strdata[0] == '/')
1184 {
1185 len = grub_snprintf(g_img_iterator_head.dir, sizeof(g_img_iterator_head.dir) - 1, "%s", strdata);
1186 if (g_img_iterator_head.dir[len - 1] != '/')
1187 {
1188 g_img_iterator_head.dir[len++] = '/';
1189 }
1190 g_img_iterator_head.dirlen = len;
1191 }
1192 else
1193 {
1194 g_img_iterator_head.dirlen = 1;
1195 grub_strcpy(g_img_iterator_head.dir, "/");
1196 }
1197
1198 g_img_iterator_head.tail = &tail;
1199
1200 for (node = &g_img_iterator_head; node; node = node->next)
1201 {
1202 fs->fs_dir(dev, node->dir, ventoy_colect_img_files, node);
1203 }
1204
1205 for (node = &g_img_iterator_head; node; node = node->next)
1206 {
1207 ventoy_dynamic_tree_menu(node);
1208 }
1209
1210 /* free node */
1211 node = g_img_iterator_head.next;
1212 while (node)
1213 {
1214 tmp = node->next;
1215 grub_free(node);
1216 node = tmp;
1217 }
1218
1219 /* sort image list by image name */
1220 for (cur = g_ventoy_img_list; cur; cur = cur->next)
1221 {
1222 for (tail = cur->next; tail; tail = tail->next)
1223 {
1224 if (ventoy_cmp_img(cur, tail) > 0)
1225 {
1226 ventoy_swap_img(cur, tail);
1227 }
1228 }
1229 }
1230
1231 if (g_default_menu_mode == 1)
1232 {
1233 vtoy_ssprintf(g_list_script_buf, g_list_script_pos,
1234 "menuentry \"%s [Return to TreeView]\" --class=\"vtoyret\" VTOY_RET {\n "
1235 " echo 'return ...' \n"
1236 "}\n", "<--");
1237 }
1238
1239 if (g_default_menu_mode == 0)
1240 {
1241 default_image = ventoy_get_env("VTOY_DEFAULT_IMAGE");
1242 if (default_image)
1243 {
1244 img_len = grub_strlen(default_image);
1245 }
1246 }
1247
1248 for (cur = g_ventoy_img_list; cur; cur = cur->next)
1249 {
1250 vtoy_ssprintf(g_list_script_buf, g_list_script_pos,
1251 "menuentry \"%s%s\" --class=\"%s\" --id=\"VID_%d\" {\n"
1252 " %s_%s \n"
1253 "}\n",
1254 cur->unsupport ? "[unsupported] " : "",
1255 cur->alias ? cur->alias : cur->name, cur->class, cur->id,
1256 cur->menu_prefix,
1257 cur->unsupport ? "unsupport_menuentry" : "common_menuentry");
1258
1259 if (g_default_menu_mode == 0 && default_image && default_node == NULL)
1260 {
1261 if (img_len == cur->pathlen && grub_strcmp(default_image, cur->path) == 0)
1262 {
1263 default_node = cur;
1264 }
1265 }
1266 }
1267
1268 if (default_node)
1269 {
1270 vtoy_ssprintf(g_list_script_buf, g_list_script_pos, "set default='VID_%d'\n", default_node->id);
1271 }
1272
1273 g_list_script_buf[g_list_script_pos] = 0;
1274
1275 grub_snprintf(buf, sizeof(buf), "%d", g_ventoy_img_count);
1276 grub_env_set(args[1], buf);
1277
1278 fail:
1279
1280 check_free(device_name, grub_free);
1281 check_free(dev, grub_device_close);
1282
1283 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
1284 }
1285
1286
1287 static grub_err_t ventoy_cmd_clear_img(grub_extcmd_context_t ctxt, int argc, char **args)
1288 {
1289 img_info *next = NULL;
1290 img_info *cur = g_ventoy_img_list;
1291
1292 (void)ctxt;
1293 (void)argc;
1294 (void)args;
1295
1296 while (cur)
1297 {
1298 next = cur->next;
1299 grub_free(cur);
1300 cur = next;
1301 }
1302
1303 g_ventoy_img_list = NULL;
1304 g_ventoy_img_count = 0;
1305
1306 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
1307 }
1308
1309 static grub_err_t ventoy_cmd_img_name(grub_extcmd_context_t ctxt, int argc, char **args)
1310 {
1311 long img_id = 0;
1312 img_info *cur = g_ventoy_img_list;
1313
1314 (void)ctxt;
1315
1316 if (argc != 2 || (!ventoy_is_decimal(args[0])))
1317 {
1318 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s {imageID} {var}", cmd_raw_name);
1319 }
1320
1321 img_id = grub_strtol(args[0], NULL, 10);
1322 if (img_id >= g_ventoy_img_count)
1323 {
1324 return grub_error(GRUB_ERR_BAD_ARGUMENT, "No such many images %ld %ld", img_id, g_ventoy_img_count);
1325 }
1326
1327 debug("Find image %ld name \n", img_id);
1328
1329 while (cur && img_id > 0)
1330 {
1331 img_id--;
1332 cur = cur->next;
1333 }
1334
1335 if (!cur)
1336 {
1337 return grub_error(GRUB_ERR_BAD_ARGUMENT, "No such many images");
1338 }
1339
1340 debug("image name is %s\n", cur->name);
1341
1342 grub_env_set(args[1], cur->name);
1343
1344 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
1345 }
1346
1347 static grub_err_t ventoy_cmd_chosen_img_path(grub_extcmd_context_t ctxt, int argc, char **args)
1348 {
1349 int img_id = 0;
1350 char *pos = NULL;
1351 const char *id = NULL;
1352 img_info *cur = g_ventoy_img_list;
1353
1354 (void)ctxt;
1355
1356 if (argc != 1)
1357 {
1358 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s {var}", cmd_raw_name);
1359 }
1360
1361 id = grub_env_get("chosen");
1362
1363 pos = grub_strstr(id, "VID_");
1364 if (pos)
1365 {
1366 img_id = (int)grub_strtoul(pos + 4, NULL, 10);
1367 }
1368 else
1369 {
1370 img_id = (int)grub_strtoul(id, NULL, 10);
1371 }
1372
1373 while (cur)
1374 {
1375 if (img_id == cur->id)
1376 {
1377 break;
1378 }
1379 cur = cur->next;
1380 }
1381
1382 if (!cur)
1383 {
1384 return grub_error(GRUB_ERR_BAD_ARGUMENT, "No such image");
1385 }
1386
1387 grub_env_set(args[0], cur->path);
1388
1389 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
1390 }
1391
1392 static int ventoy_get_disk_guid(const char *filename, grub_uint8_t *guid)
1393 {
1394 grub_disk_t disk;
1395 char *device_name;
1396 char *pos;
1397 char *pos2;
1398
1399 device_name = grub_file_get_device_name(filename);
1400 if (!device_name)
1401 {
1402 return 1;
1403 }
1404
1405 pos = device_name;
1406 if (pos[0] == '(')
1407 {
1408 pos++;
1409 }
1410
1411 pos2 = grub_strstr(pos, ",");
1412 if (!pos2)
1413 {
1414 pos2 = grub_strstr(pos, ")");
1415 }
1416
1417 if (pos2)
1418 {
1419 *pos2 = 0;
1420 }
1421
1422 disk = grub_disk_open(pos);
1423 if (disk)
1424 {
1425 grub_disk_read(disk, 0, 0x180, 16, guid);
1426 grub_disk_close(disk);
1427 }
1428 else
1429 {
1430 return 1;
1431 }
1432
1433 grub_free(device_name);
1434 return 0;
1435 }
1436
1437 grub_uint32_t ventoy_get_iso_boot_catlog(grub_file_t file)
1438 {
1439 eltorito_descriptor desc;
1440
1441 grub_memset(&desc, 0, sizeof(desc));
1442 grub_file_seek(file, 17 * 2048);
1443 grub_file_read(file, &desc, sizeof(desc));
1444
1445 if (desc.type != 0 || desc.version != 1)
1446 {
1447 return 0;
1448 }
1449
1450 if (grub_strncmp((char *)desc.id, "CD001", 5) != 0 ||
1451 grub_strncmp((char *)desc.system_id, "EL TORITO SPECIFICATION", 23) != 0)
1452 {
1453 return 0;
1454 }
1455
1456 return desc.sector;
1457 }
1458
1459 int ventoy_has_efi_eltorito(grub_file_t file, grub_uint32_t sector)
1460 {
1461 int i;
1462 grub_uint8_t buf[512];
1463
1464 grub_file_seek(file, sector * 2048);
1465 grub_file_read(file, buf, sizeof(buf));
1466
1467 if (buf[0] == 0x01 && buf[1] == 0xEF)
1468 {
1469 debug("%s efi eltorito in Validation Entry\n", file->name);
1470 return 1;
1471 }
1472
1473 for (i = 64; i < (int)sizeof(buf); i += 32)
1474 {
1475 if ((buf[i] == 0x90 || buf[i] == 0x91) && buf[i + 1] == 0xEF)
1476 {
1477 debug("%s efi eltorito offset %d 0x%02x\n", file->name, i, buf[i]);
1478 return 1;
1479 }
1480 }
1481
1482 debug("%s does not contain efi eltorito\n", file->name);
1483 return 0;
1484 }
1485
1486 void ventoy_fill_os_param(grub_file_t file, ventoy_os_param *param)
1487 {
1488 char *pos;
1489 const char *fs = NULL;
1490 const char *cdprompt = NULL;
1491 grub_uint32_t i;
1492 grub_uint8_t chksum = 0;
1493 grub_disk_t disk;
1494
1495 disk = file->device->disk;
1496 grub_memcpy(&param->guid, &g_ventoy_guid, sizeof(ventoy_guid));
1497
1498 param->vtoy_disk_size = disk->total_sectors * (1 << disk->log_sector_size);
1499 param->vtoy_disk_part_id = disk->partition->number + 1;
1500 param->vtoy_disk_part_type = ventoy_get_fs_type(file->fs->name);
1501
1502 pos = grub_strstr(file->name, "/");
1503 if (!pos)
1504 {
1505 pos = file->name;
1506 }
1507
1508 grub_snprintf(param->vtoy_img_path, sizeof(param->vtoy_img_path), "%s", pos);
1509
1510 ventoy_get_disk_guid(file->name, param->vtoy_disk_guid);
1511
1512 param->vtoy_img_size = file->size;
1513
1514 param->vtoy_reserved[0] = g_ventoy_break_level;
1515 param->vtoy_reserved[1] = g_ventoy_debug_level;
1516
1517 param->vtoy_reserved[2] = g_ventoy_chain_type;
1518
1519 /* Windows CD/DVD prompt 0:suppress 1:reserved */
1520 param->vtoy_reserved[4] = 0;
1521 if (g_ventoy_chain_type == 1) /* Windows */
1522 {
1523 cdprompt = ventoy_get_env("VTOY_WINDOWS_CD_PROMPT");
1524 if (cdprompt && cdprompt[0] == '1' && cdprompt[1] == 0)
1525 {
1526 param->vtoy_reserved[4] = 1;
1527 }
1528 }
1529
1530 fs = ventoy_get_env("ventoy_fs_probe");
1531 if (fs && grub_strcmp(fs, "udf") == 0)
1532 {
1533 param->vtoy_reserved[3] = 1;
1534 }
1535
1536 /* calculate checksum */
1537 for (i = 0; i < sizeof(ventoy_os_param); i++)
1538 {
1539 chksum += *((grub_uint8_t *)param + i);
1540 }
1541 param->chksum = (grub_uint8_t)(0x100 - chksum);
1542
1543 return;
1544 }
1545
1546 int ventoy_check_block_list(grub_file_t file, ventoy_img_chunk_list *chunklist, grub_disk_addr_t start)
1547 {
1548 grub_uint32_t i = 0;
1549 grub_uint64_t total = 0;
1550 ventoy_img_chunk *chunk = NULL;
1551
1552 for (i = 0; i < chunklist->cur_chunk; i++)
1553 {
1554 chunk = chunklist->chunk + i;
1555
1556 if (chunk->disk_start_sector <= start)
1557 {
1558 debug("%u disk start invalid %lu\n", i, (ulong)start);
1559 return 1;
1560 }
1561
1562 total += chunk->disk_end_sector + 1 - chunk->disk_start_sector;
1563 }
1564
1565 if (total != ((file->size + 511) / 512))
1566 {
1567 debug("Invalid total: %llu %llu\n", (ulonglong)total, (ulonglong)((file->size + 511) / 512));
1568 return 1;
1569 }
1570
1571 return 0;
1572 }
1573
1574 int ventoy_get_block_list(grub_file_t file, ventoy_img_chunk_list *chunklist, grub_disk_addr_t start)
1575 {
1576 int fs_type;
1577 grub_uint32_t i = 0;
1578 grub_uint32_t sector = 0;
1579 grub_uint32_t count = 0;
1580 grub_off_t size = 0;
1581 grub_off_t read = 0;
1582
1583 fs_type = ventoy_get_fs_type(file->fs->name);
1584 if (fs_type == ventoy_fs_exfat)
1585 {
1586 grub_fat_get_file_chunk(start, file, chunklist);
1587 }
1588 else if (fs_type == ventoy_fs_ext)
1589 {
1590 grub_ext_get_file_chunk(start, file, chunklist);
1591 }
1592 else
1593 {
1594 file->read_hook = (grub_disk_read_hook_t)grub_disk_blocklist_read;
1595 file->read_hook_data = chunklist;
1596
1597 for (size = file->size; size > 0; size -= read)
1598 {
1599 read = (size > VTOY_SIZE_1GB) ? VTOY_SIZE_1GB : size;
1600 grub_file_read(file, NULL, read);
1601 }
1602
1603 for (i = 0; start > 0 && i < chunklist->cur_chunk; i++)
1604 {
1605 chunklist->chunk[i].disk_start_sector += start;
1606 chunklist->chunk[i].disk_end_sector += start;
1607 }
1608
1609 if (ventoy_fs_udf == fs_type)
1610 {
1611 for (i = 0; i < chunklist->cur_chunk; i++)
1612 {
1613 count = (chunklist->chunk[i].disk_end_sector + 1 - chunklist->chunk[i].disk_start_sector) >> 2;
1614 chunklist->chunk[i].img_start_sector = sector;
1615 chunklist->chunk[i].img_end_sector = sector + count - 1;
1616 sector += count;
1617 }
1618 }
1619 }
1620
1621 return 0;
1622 }
1623
1624 static grub_err_t ventoy_cmd_img_sector(grub_extcmd_context_t ctxt, int argc, char **args)
1625 {
1626 int rc;
1627 grub_file_t file;
1628 grub_disk_addr_t start;
1629
1630 (void)ctxt;
1631 (void)argc;
1632
1633 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", args[0]);
1634 if (!file)
1635 {
1636 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Can't open file %s\n", args[0]);
1637 }
1638
1639 if (g_img_chunk_list.chunk)
1640 {
1641 grub_free(g_img_chunk_list.chunk);
1642 }
1643
1644 /* get image chunk data */
1645 grub_memset(&g_img_chunk_list, 0, sizeof(g_img_chunk_list));
1646 g_img_chunk_list.chunk = grub_malloc(sizeof(ventoy_img_chunk) * DEFAULT_CHUNK_NUM);
1647 if (NULL == g_img_chunk_list.chunk)
1648 {
1649 return grub_error(GRUB_ERR_OUT_OF_MEMORY, "Can't allocate image chunk memoty\n");
1650 }
1651
1652 g_img_chunk_list.max_chunk = DEFAULT_CHUNK_NUM;
1653 g_img_chunk_list.cur_chunk = 0;
1654
1655 start = file->device->disk->partition->start;
1656
1657 ventoy_get_block_list(file, &g_img_chunk_list, start);
1658
1659 rc = ventoy_check_block_list(file, &g_img_chunk_list, start);
1660 grub_file_close(file);
1661
1662 if (rc)
1663 {
1664 return grub_error(GRUB_ERR_NOT_IMPLEMENTED_YET, "Unsupported chunk list.\n");
1665 }
1666
1667 grub_memset(&g_grub_param->file_replace, 0, sizeof(g_grub_param->file_replace));
1668 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
1669 }
1670
1671 static grub_err_t ventoy_cmd_sel_auto_install(grub_extcmd_context_t ctxt, int argc, char **args)
1672 {
1673 int i = 0;
1674 int pos = 0;
1675 char *buf = NULL;
1676 char configfile[128];
1677 install_template *node = NULL;
1678
1679 (void)ctxt;
1680 (void)argc;
1681 (void)args;
1682
1683 debug("select auto installation argc:%d\n", argc);
1684
1685 if (argc < 1)
1686 {
1687 return 0;
1688 }
1689
1690 node = ventoy_plugin_find_install_template(args[0]);
1691 if (!node)
1692 {
1693 debug("Auto install template not found for %s\n", args[0]);
1694 return 0;
1695 }
1696
1697 if (node->autosel >= 0 && node->autosel <= node->templatenum)
1698 {
1699 node->cursel = node->autosel - 1;
1700 debug("Auto install template auto select %d\n", node->autosel);
1701 return 0;
1702 }
1703
1704 buf = (char *)grub_malloc(VTOY_MAX_SCRIPT_BUF);
1705 if (!buf)
1706 {
1707 return 0;
1708 }
1709
1710 vtoy_ssprintf(buf, pos, "menuentry \"Boot without auto installation template\" {\n"
1711 " echo %s\n}\n", "123");
1712
1713 for (i = 0; i < node->templatenum; i++)
1714 {
1715 vtoy_ssprintf(buf, pos, "menuentry \"Boot with %s\" {\n"
1716 " echo 123\n}\n",
1717 node->templatepath[i].path);
1718 }
1719
1720 g_ventoy_menu_esc = 1;
1721 g_ventoy_suppress_esc = 1;
1722
1723 grub_snprintf(configfile, sizeof(configfile), "configfile mem:0x%llx:size:%d", (ulonglong)(ulong)buf, pos);
1724 grub_script_execute_sourcecode(configfile);
1725
1726 g_ventoy_menu_esc = 0;
1727 g_ventoy_suppress_esc = 0;
1728
1729 grub_free(buf);
1730
1731 node->cursel = g_ventoy_last_entry - 1;
1732
1733 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
1734 }
1735
1736 static grub_err_t ventoy_cmd_sel_persistence(grub_extcmd_context_t ctxt, int argc, char **args)
1737 {
1738 int i = 0;
1739 int pos = 0;
1740 char *buf = NULL;
1741 char configfile[128];
1742 persistence_config *node;
1743
1744 (void)ctxt;
1745 (void)argc;
1746 (void)args;
1747
1748 debug("select persistence argc:%d\n", argc);
1749
1750 if (argc < 1)
1751 {
1752 return 0;
1753 }
1754
1755 node = ventoy_plugin_find_persistent(args[0]);
1756 if (!node)
1757 {
1758 debug("Persistence image not found for %s\n", args[0]);
1759 return 0;
1760 }
1761
1762 if (node->autosel >= 0 && node->autosel <= node->backendnum)
1763 {
1764 node->cursel = node->autosel - 1;
1765 debug("Persistence image auto select %d\n", node->autosel);
1766 return 0;
1767 }
1768
1769 buf = (char *)grub_malloc(VTOY_MAX_SCRIPT_BUF);
1770 if (!buf)
1771 {
1772 return 0;
1773 }
1774
1775 vtoy_ssprintf(buf, pos, "menuentry \"Boot without persistence\" {\n"
1776 " echo %s\n}\n", "123");
1777
1778 for (i = 0; i < node->backendnum; i++)
1779 {
1780 vtoy_ssprintf(buf, pos, "menuentry \"Boot with %s\" {\n"
1781 " echo 123\n}\n",
1782 node->backendpath[i].path);
1783
1784 }
1785
1786 g_ventoy_menu_esc = 1;
1787 g_ventoy_suppress_esc = 1;
1788
1789 grub_snprintf(configfile, sizeof(configfile), "configfile mem:0x%llx:size:%d", (ulonglong)(ulong)buf, pos);
1790 grub_script_execute_sourcecode(configfile);
1791
1792 g_ventoy_menu_esc = 0;
1793 g_ventoy_suppress_esc = 0;
1794
1795 grub_free(buf);
1796
1797 node->cursel = g_ventoy_last_entry - 1;
1798
1799 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
1800 }
1801
1802 static grub_err_t ventoy_cmd_dump_img_sector(grub_extcmd_context_t ctxt, int argc, char **args)
1803 {
1804 grub_uint32_t i;
1805 ventoy_img_chunk *cur;
1806
1807 (void)ctxt;
1808 (void)argc;
1809 (void)args;
1810
1811 for (i = 0; i < g_img_chunk_list.cur_chunk; i++)
1812 {
1813 cur = g_img_chunk_list.chunk + i;
1814 grub_printf("image:[%u - %u] <==> disk:[%llu - %llu]\n",
1815 cur->img_start_sector, cur->img_end_sector,
1816 (unsigned long long)cur->disk_start_sector, (unsigned long long)cur->disk_end_sector
1817 );
1818 }
1819
1820 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
1821 }
1822
1823 #ifdef GRUB_MACHINE_EFI
1824 static grub_err_t ventoy_cmd_relocator_chaindata(grub_extcmd_context_t ctxt, int argc, char **args)
1825 {
1826 (void)ctxt;
1827 (void)argc;
1828 (void)args;
1829 return 0;
1830 }
1831 #else
1832 static grub_err_t ventoy_cmd_relocator_chaindata(grub_extcmd_context_t ctxt, int argc, char **args)
1833 {
1834 int rc = 0;
1835 ulong chain_len = 0;
1836 char *chain_data = NULL;
1837 char *relocator_addr = NULL;
1838 grub_relocator_chunk_t ch;
1839 struct grub_relocator *relocator = NULL;
1840 char envbuf[64] = { 0 };
1841
1842 (void)ctxt;
1843 (void)argc;
1844 (void)args;
1845
1846 if (argc != 2)
1847 {
1848 return 1;
1849 }
1850
1851 chain_data = (char *)grub_strtoul(args[0], NULL, 16);
1852 chain_len = grub_strtoul(args[1], NULL, 10);
1853
1854 relocator = grub_relocator_new ();
1855 if (!relocator)
1856 {
1857 debug("grub_relocator_new failed %p %lu\n", chain_data, chain_len);
1858 return 1;
1859 }
1860
1861 rc = grub_relocator_alloc_chunk_addr (relocator, &ch,
1862 0x100000, // GRUB_LINUX_BZIMAGE_ADDR,
1863 chain_len);
1864 if (rc)
1865 {
1866 debug("grub_relocator_alloc_chunk_addr failed %d %p %lu\n", rc, chain_data, chain_len);
1867 grub_relocator_unload (relocator);
1868 return 1;
1869 }
1870
1871 relocator_addr = get_virtual_current_address(ch);
1872
1873 grub_memcpy(relocator_addr, chain_data, chain_len);
1874
1875 grub_relocator_unload (relocator);
1876
1877 grub_snprintf(envbuf, sizeof(envbuf), "0x%lx", (unsigned long)relocator_addr);
1878 grub_env_set("vtoy_chain_relocator_addr", envbuf);
1879
1880 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
1881 }
1882 #endif
1883
1884 static grub_err_t ventoy_cmd_test_block_list(grub_extcmd_context_t ctxt, int argc, char **args)
1885 {
1886 grub_uint32_t i;
1887 grub_file_t file;
1888 ventoy_img_chunk_list chunklist;
1889
1890 (void)ctxt;
1891 (void)argc;
1892
1893 file = ventoy_grub_file_open(VENTOY_FILE_TYPE, "%s", args[0]);
1894 if (!file)
1895 {
1896 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Can't open file %s\n", args[0]);
1897 }
1898
1899 /* get image chunk data */
1900 grub_memset(&chunklist, 0, sizeof(chunklist));
1901 chunklist.chunk = grub_malloc(sizeof(ventoy_img_chunk) * DEFAULT_CHUNK_NUM);
1902 if (NULL == chunklist.chunk)
1903 {
1904 return grub_error(GRUB_ERR_OUT_OF_MEMORY, "Can't allocate image chunk memoty\n");
1905 }
1906
1907 chunklist.max_chunk = DEFAULT_CHUNK_NUM;
1908 chunklist.cur_chunk = 0;
1909
1910 ventoy_get_block_list(file, &chunklist, 0);
1911
1912 if (0 != ventoy_check_block_list(file, &chunklist, 0))
1913 {
1914 grub_printf("########## UNSUPPORTED ###############\n");
1915 }
1916
1917 grub_printf("filesystem: <%s> entry number:<%u>\n", file->fs->name, chunklist.cur_chunk);
1918
1919 for (i = 0; i < chunklist.cur_chunk; i++)
1920 {
1921 grub_printf("%llu+%llu,", (ulonglong)chunklist.chunk[i].disk_start_sector,
1922 (ulonglong)(chunklist.chunk[i].disk_end_sector + 1 - chunklist.chunk[i].disk_start_sector));
1923 }
1924
1925 grub_printf("\n==================================\n");
1926
1927 for (i = 0; i < chunklist.cur_chunk; i++)
1928 {
1929 grub_printf("%2u: [%llu %llu] - [%llu %llu]\n", i,
1930 (ulonglong)chunklist.chunk[i].img_start_sector,
1931 (ulonglong)chunklist.chunk[i].img_end_sector,
1932 (ulonglong)chunklist.chunk[i].disk_start_sector,
1933 (ulonglong)chunklist.chunk[i].disk_end_sector
1934 );
1935 }
1936
1937 grub_free(chunklist.chunk);
1938 grub_file_close(file);
1939
1940 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
1941 }
1942
1943 static grub_err_t ventoy_cmd_add_replace_file(grub_extcmd_context_t ctxt, int argc, char **args)
1944 {
1945 int i;
1946 ventoy_grub_param_file_replace *replace = NULL;
1947
1948 (void)ctxt;
1949 (void)argc;
1950 (void)args;
1951
1952 if (argc >= 2)
1953 {
1954 replace = &(g_grub_param->file_replace);
1955 replace->magic = GRUB_FILE_REPLACE_MAGIC;
1956
1957 replace->old_name_cnt = 0;
1958 for (i = 0; i < 4 && i + 1 < argc; i++)
1959 {
1960 replace->old_name_cnt++;
1961 grub_snprintf(replace->old_file_name[i], sizeof(replace->old_file_name[i]), "%s", args[i + 1]);
1962 }
1963
1964 replace->new_file_virtual_id = (grub_uint32_t)grub_strtoul(args[0], NULL, 10);
1965 }
1966
1967 VENTOY_CMD_RETURN(GRUB_ERR_NONE);
1968 }
1969
1970 static grub_err_t ventoy_cmd_dump_menu(grub_extcmd_context_t ctxt, int argc, char **args)
1971 {
1972 (void)ctxt;
1973 (void)argc;
1974 (void)args;
1975
1976 if (argc == 0)
1977 {
1978 grub_printf("List Mode: CurLen:%d MaxLen:%u\n", g_list_script_pos, VTOY_MAX_SCRIPT_BUF);
1979 grub_printf("%s", g_list_script_buf);
1980 }
1981 else
1982 {
1983 grub_printf("Tree Mode: CurLen:%d MaxLen:%u\n", g_tree_script_pos, VTOY_MAX_SCRIPT_BUF);
1984 grub_printf("%s", g_tree_script_buf);
1985 }
1986
1987 return 0;
1988 }
1989
1990 static grub_err_t ventoy_cmd_dump_img_list(grub_extcmd_context_t ctxt, int argc, char **args)
1991 {
1992 img_info *cur = g_ventoy_img_list;
1993
1994 (void)ctxt;
1995 (void)argc;
1996 (void)args;
1997
1998 while (cur)
1999 {
2000 grub_printf("path:<%s> id=%d\n", cur->path, cur->id);
2001 grub_printf("name:<%s>\n\n", cur->name);
2002 cur = cur->next;
2003 }
2004
2005 return 0;
2006 }
2007
2008 static grub_err_t ventoy_cmd_dump_auto_install(grub_extcmd_context_t ctxt, int argc, char **args)
2009 {
2010 (void)ctxt;
2011 (void)argc;
2012 (void)args;
2013
2014 ventoy_plugin_dump_auto_install();
2015
2016 return 0;
2017 }
2018
2019 static grub_err_t ventoy_cmd_dump_persistence(grub_extcmd_context_t ctxt, int argc, char **args)
2020 {
2021 (void)ctxt;
2022 (void)argc;
2023 (void)args;
2024
2025 ventoy_plugin_dump_persistence();
2026
2027 return 0;
2028 }
2029
2030 static grub_err_t ventoy_cmd_check_mode(grub_extcmd_context_t ctxt, int argc, char **args)
2031 {
2032 (void)ctxt;
2033 (void)argc;
2034 (void)args;
2035
2036 if (argc != 1)
2037 {
2038 return 1;
2039 }
2040
2041 if (args[0][0] == '0')
2042 {
2043 return g_ventoy_memdisk_mode ? 0 : 1;
2044 }
2045 else if (args[0][0] == '1')
2046 {
2047 return g_ventoy_iso_raw ? 0 : 1;
2048 }
2049 else if (args[0][0] == '2')
2050 {
2051 return g_ventoy_iso_uefi_drv ? 0 : 1;
2052 }
2053
2054 return 1;
2055 }
2056
2057 static grub_err_t ventoy_cmd_dynamic_menu(grub_extcmd_context_t ctxt, int argc, char **args)
2058 {
2059 static int configfile_mode = 0;
2060 char memfile[128] = {0};
2061
2062 (void)ctxt;
2063 (void)argc;
2064 (void)args;
2065
2066 /*
2067 * args[0]: 0:normal 1:configfile
2068 * args[1]: 0:list_buf 1:tree_buf
2069 */
2070
2071 if (argc != 2)
2072 {
2073 debug("Invalid argc %d\n", argc);
2074 return 0;
2075 }
2076
2077 if (args[0][0] == '0')
2078 {
2079 if (args[1][0] == '0')
2080 {
2081 grub_script_execute_sourcecode(g_list_script_buf);
2082 }
2083 else
2084 {
2085 grub_script_execute_sourcecode(g_tree_script_buf);
2086 }
2087 }
2088 else
2089 {
2090 if (configfile_mode)
2091 {
2092 debug("Now already in F3 mode %d\n", configfile_mode);
2093 return 0;
2094 }
2095
2096 if (args[1][0] == '0')
2097 {
2098 grub_snprintf(memfile, sizeof(memfile), "configfile mem:0x%llx:size:%d",
2099 (ulonglong)(ulong)g_list_script_buf, g_list_script_pos);
2100 }
2101 else
2102 {
2103 g_ventoy_last_entry = -1;
2104 grub_snprintf(memfile, sizeof(memfile), "configfile mem:0x%llx:size:%d",
2105 (ulonglong)(ulong)g_tree_script_buf, g_tree_script_pos);
2106 }
2107
2108 configfile_mode = 1;
2109 grub_script_execute_sourcecode(memfile);
2110 configfile_mode = 0;
2111 }
2112
2113 return 0;
2114 }
2115
2116 static grub_err_t ventoy_cmd_file_exist_nocase(grub_extcmd_context_t ctxt, int argc, char **args)
2117 {
2118 grub_file_t file;
2119
2120 (void)ctxt;
2121
2122 if (argc != 1)
2123 {
2124 return 1;
2125 }
2126
2127 g_ventoy_case_insensitive = 1;
2128 file = grub_file_open(args[0], VENTOY_FILE_TYPE);
2129 g_ventoy_case_insensitive = 0;
2130
2131 grub_errno = 0;
2132
2133 if (file)
2134 {
2135 grub_file_close(file);
2136 return 0;
2137 }
2138 return 1;
2139 }
2140
2141 static grub_err_t ventoy_cmd_find_bootable_hdd(grub_extcmd_context_t ctxt, int argc, char **args)
2142 {
2143 int id = 0;
2144 int find = 0;
2145 grub_disk_t disk;
2146 const char *isopath = NULL;
2147 char hdname[32];
2148 ventoy_mbr_head mbr;
2149
2150 (void)ctxt;
2151 (void)argc;
2152
2153 if (argc != 1)
2154 {
2155 return grub_error(GRUB_ERR_BAD_ARGUMENT, "Usage: %s variable\n", cmd_raw_name);
2156 }
2157
2158 isopath = grub_env_get("iso_path");
2159 if (!isopath)
2160 {
2161 debug("isopath is null %p\n", isopath);
2162 return 0;
2163 }
2164
2165 debug("isopath is %s\n", isopath);
2166
2167 for (id = 0; id < 30 && (find == 0); id++)
2168 {
2169 grub_snprintf(hdname, sizeof(hdname), "hd%d,", id);
2170 if (grub_strstr(isopath, hdname))
2171 {
2172 debug("skip %s ...\n", hdname);
2173 continue;
2174 }
2175
2176 grub_snprintf(hdname, sizeof(hdname), "hd%d", id);
2177
2178 disk = grub_disk_open(hdname);
2179 if (!disk)
2180 {
2181 debug("%s not exist\n", hdname);
2182 break;
2183 }
2184
2185 grub_memset(&mbr, 0, sizeof(mbr));
2186 if (0 == grub_disk_read(disk, 0, 0, 512, &mbr))
2187 {
2188 if (mbr.Byte55 == 0x55 && mbr.ByteAA == 0xAA)
2189 {
2190 if (mbr.PartTbl[0].Active == 0x80 || mbr.PartTbl[1].Active == 0x80 ||
2191 mbr.PartTbl[2].Active == 0x80 || mbr.PartTbl[3].Active == 0x80)
2192 {
2193
2194 grub_env_set(args[0], hdname);
2195 find = 1;
2196 }
2197 }
2198 debug("%s is %s\n", hdname, find ? "bootable" : "NOT bootable");
2199 }
2200 else
2201 {
2202 debug("read %s failed\n", hdname);
2203 }
2204
2205 grub_disk_close(disk);
2206 }
2207
2208 return 0;
2209 }
2210
2211 grub_uint64_t ventoy_grub_get_file_size(const char *fmt, ...)
2212 {
2213 grub_uint64_t size = 0;
2214 grub_file_t file;
2215 va_list ap;
2216 char fullpath[256] = {0};
2217
2218 va_start (ap, fmt);
2219 grub_vsnprintf(fullpath, 255, fmt, ap);
2220 va_end (ap);
2221
2222 file = grub_file_open(fullpath, VENTOY_FILE_TYPE);
2223 if (!file)
2224 {
2225 debug("grub_file_open failed <%s>\n", fullpath);
2226 grub_errno = 0;
2227 return 0;
2228 }
2229
2230 size = file->size;
2231 grub_file_close(file);
2232 return size;
2233 }
2234
2235 grub_file_t ventoy_grub_file_open(enum grub_file_type type, const char *fmt, ...)
2236 {
2237 va_list ap;
2238 grub_file_t file;
2239 char fullpath[256] = {0};
2240
2241 va_start (ap, fmt);
2242 grub_vsnprintf(fullpath, 255, fmt, ap);
2243 va_end (ap);
2244
2245 file = grub_file_open(fullpath, type);
2246 if (!file)
2247 {
2248 debug("grub_file_open failed <%s>\n", fullpath);
2249 grub_errno = 0;
2250 }
2251
2252 return file;
2253 }
2254
2255 int ventoy_is_file_exist(const char *fmt, ...)
2256 {
2257 va_list ap;
2258 int len;
2259 char *pos = NULL;
2260 char buf[256] = {0};
2261
2262 grub_snprintf(buf, sizeof(buf), "%s", "[ -f ");
2263 pos = buf + 5;
2264
2265 va_start (ap, fmt);
2266 len = grub_vsnprintf(pos, 255, fmt, ap);
2267 va_end (ap);
2268
2269 grub_strncpy(pos + len, " ]", 2);
2270
2271 debug("script exec %s\n", buf);
2272
2273 if (0 == grub_script_execute_sourcecode(buf))
2274 {
2275 return 1;
2276 }
2277
2278 return 0;
2279 }
2280
2281 int ventoy_is_dir_exist(const char *fmt, ...)
2282 {
2283 va_list ap;
2284 int len;
2285 char *pos = NULL;
2286 char buf[256] = {0};
2287
2288 grub_snprintf(buf, sizeof(buf), "%s", "[ -d ");
2289 pos = buf + 5;
2290
2291 va_start (ap, fmt);
2292 len = grub_vsnprintf(pos, 255, fmt, ap);
2293 va_end (ap);
2294
2295 grub_strncpy(pos + len, " ]", 2);
2296
2297 debug("script exec %s\n", buf);
2298
2299 if (0 == grub_script_execute_sourcecode(buf))
2300 {
2301 return 1;
2302 }
2303
2304 return 0;
2305 }
2306
2307 static int ventoy_env_init(void)
2308 {
2309 char buf[64];
2310
2311 grub_env_set("vtdebug_flag", "");
2312 grub_env_export("vtdebug_flag");
2313
2314
2315
2316 g_tree_script_buf = grub_malloc(VTOY_MAX_SCRIPT_BUF);
2317 g_list_script_buf = grub_malloc(VTOY_MAX_SCRIPT_BUF);
2318
2319 ventoy_filt_register(0, ventoy_wrapper_open);
2320
2321 g_grub_param = (ventoy_grub_param *)grub_zalloc(sizeof(ventoy_grub_param));
2322 if (g_grub_param)
2323 {
2324 g_grub_param->grub_env_get = grub_env_get;
2325 g_grub_param->grub_env_printf = (grub_env_printf_pf)grub_printf;
2326 grub_snprintf(buf, sizeof(buf), "%p", g_grub_param);
2327 grub_env_set("env_param", buf);
2328 }
2329
2330 return 0;
2331 }
2332
2333 static cmd_para ventoy_cmds[] =
2334 {
2335 { "vt_incr", ventoy_cmd_incr, 0, NULL, "{Var} {INT}", "Increase integer variable", NULL },
2336 { "vt_debug", ventoy_cmd_debug, 0, NULL, "{on|off}", "turn debug on/off", NULL },
2337 { "vtdebug", ventoy_cmd_debug, 0, NULL, "{on|off}", "turn debug on/off", NULL },
2338 { "vtbreak", ventoy_cmd_break, 0, NULL, "{level}", "set debug break", NULL },
2339 { "vt_cmp", ventoy_cmd_cmp, 0, NULL, "{Int1} { eq|ne|gt|lt|ge|le } {Int2}", "Comare two integers", NULL },
2340 { "vt_device", ventoy_cmd_device, 0, NULL, "path var", "", NULL },
2341 { "vt_check_compatible", ventoy_cmd_check_compatible, 0, NULL, "", "", NULL },
2342 { "vt_list_img", ventoy_cmd_list_img, 0, NULL, "{device} {cntvar}", "find all iso file in device", NULL },
2343 { "vt_clear_img", ventoy_cmd_clear_img, 0, NULL, "", "clear image list", NULL },
2344 { "vt_img_name", ventoy_cmd_img_name, 0, NULL, "{imageID} {var}", "get image name", NULL },
2345 { "vt_chosen_img_path", ventoy_cmd_chosen_img_path, 0, NULL, "{var}", "get chosen img path", NULL },
2346 { "vt_img_sector", ventoy_cmd_img_sector, 0, NULL, "{imageName}", "", NULL },
2347 { "vt_dump_img_sector", ventoy_cmd_dump_img_sector, 0, NULL, "", "", NULL },
2348 { "vt_load_wimboot", ventoy_cmd_load_wimboot, 0, NULL, "", "", NULL },
2349 { "vt_load_cpio", ventoy_cmd_load_cpio, 0, NULL, "", "", NULL },
2350 { "vt_find_first_bootable_hd", ventoy_cmd_find_bootable_hdd, 0, NULL, "", "", NULL },
2351 { "vt_dump_menu", ventoy_cmd_dump_menu, 0, NULL, "", "", NULL },
2352 { "vt_dynamic_menu", ventoy_cmd_dynamic_menu, 0, NULL, "", "", NULL },
2353 { "vt_check_mode", ventoy_cmd_check_mode, 0, NULL, "", "", NULL },
2354 { "vt_dump_img_list", ventoy_cmd_dump_img_list, 0, NULL, "", "", NULL },
2355 { "vt_dump_auto_install", ventoy_cmd_dump_auto_install, 0, NULL, "", "", NULL },
2356 { "vt_dump_persistence", ventoy_cmd_dump_persistence, 0, NULL, "", "", NULL },
2357 { "vt_select_auto_install", ventoy_cmd_sel_auto_install, 0, NULL, "", "", NULL },
2358 { "vt_select_persistence", ventoy_cmd_sel_persistence, 0, NULL, "", "", NULL },
2359
2360 { "vt_iso9660_nojoliet", ventoy_cmd_iso9660_nojoliet, 0, NULL, "", "", NULL },
2361 { "vt_is_udf", ventoy_cmd_is_udf, 0, NULL, "", "", NULL },
2362 { "vt_file_size", ventoy_cmd_file_size, 0, NULL, "", "", NULL },
2363 { "vt_load_iso_to_mem", ventoy_cmd_load_iso_to_mem, 0, NULL, "", "", NULL },
2364
2365 { "vt_linux_parse_initrd_isolinux", ventoy_cmd_isolinux_initrd_collect, 0, NULL, "{cfgfile}", "", NULL },
2366 { "vt_linux_parse_initrd_grub", ventoy_cmd_grub_initrd_collect, 0, NULL, "{cfgfile}", "", NULL },
2367 { "vt_linux_specify_initrd_file", ventoy_cmd_specify_initrd_file, 0, NULL, "", "", NULL },
2368 { "vt_linux_clear_initrd", ventoy_cmd_clear_initrd_list, 0, NULL, "", "", NULL },
2369 { "vt_linux_dump_initrd", ventoy_cmd_dump_initrd_list, 0, NULL, "", "", NULL },
2370 { "vt_linux_initrd_count", ventoy_cmd_initrd_count, 0, NULL, "", "", NULL },
2371 { "vt_linux_valid_initrd_count", ventoy_cmd_valid_initrd_count, 0, NULL, "", "", NULL },
2372 { "vt_linux_locate_initrd", ventoy_cmd_linux_locate_initrd, 0, NULL, "", "", NULL },
2373 { "vt_linux_chain_data", ventoy_cmd_linux_chain_data, 0, NULL, "", "", NULL },
2374 { "vt_linux_get_main_initrd_index", ventoy_cmd_linux_get_main_initrd_index, 0, NULL, "", "", NULL },
2375
2376 { "vt_windows_reset", ventoy_cmd_wimdows_reset, 0, NULL, "", "", NULL },
2377 { "vt_windows_chain_data", ventoy_cmd_windows_chain_data, 0, NULL, "", "", NULL },
2378 { "vt_windows_collect_wim_patch", ventoy_cmd_collect_wim_patch, 0, NULL, "", "", NULL },
2379 { "vt_windows_locate_wim_patch", ventoy_cmd_locate_wim_patch, 0, NULL, "", "", NULL },
2380 { "vt_windows_count_wim_patch", ventoy_cmd_wim_patch_count, 0, NULL, "", "", NULL },
2381 { "vt_dump_wim_patch", ventoy_cmd_dump_wim_patch, 0, NULL, "", "", NULL },
2382 { "vt_wim_chain_data", ventoy_cmd_wim_chain_data, 0, NULL, "", "", NULL },
2383
2384 { "vt_add_replace_file", ventoy_cmd_add_replace_file, 0, NULL, "", "", NULL },
2385 { "vt_relocator_chaindata", ventoy_cmd_relocator_chaindata, 0, NULL, "", "", NULL },
2386 { "vt_test_block_list", ventoy_cmd_test_block_list, 0, NULL, "", "", NULL },
2387 { "vt_file_exist_nocase", ventoy_cmd_file_exist_nocase, 0, NULL, "", "", NULL },
2388
2389
2390 { "vt_load_plugin", ventoy_cmd_load_plugin, 0, NULL, "", "", NULL },
2391 { "vt_check_plugin_json", ventoy_cmd_plugin_check_json, 0, NULL, "", "", NULL },
2392
2393 };
2394
2395
2396
2397 GRUB_MOD_INIT(ventoy)
2398 {
2399 grub_uint32_t i;
2400 cmd_para *cur = NULL;
2401
2402 ventoy_env_init();
2403
2404 for (i = 0; i < ARRAY_SIZE(ventoy_cmds); i++)
2405 {
2406 cur = ventoy_cmds + i;
2407 cur->cmd = grub_register_extcmd(cur->name, cur->func, cur->flags,
2408 cur->summary, cur->description, cur->parser);
2409 }
2410 }
2411
2412 GRUB_MOD_FINI(ventoy)
2413 {
2414 grub_uint32_t i;
2415
2416 for (i = 0; i < ARRAY_SIZE(ventoy_cmds); i++)
2417 {
2418 grub_unregister_extcmd(ventoy_cmds[i].cmd);
2419 }
2420 }
2421
https://github.com/ventoy/Ventoy