SayoriOS 0.3.3

cli.c
См. документацию.
1
10 #include <io/ports.h>
11 #include <sys/variable.h>
12 #include "elf/elf.h"
13 #include "io/tty.h"
14 #include "mem/vmm.h"
15 #include "io/status_loggers.h"
16 #include "mem/pmm.h"
17 #include "lib/split.h"
18 #include "version.h"
19 #include "drv/input/keyboard.h"
20 #include "lib/php/explode.h"
21 #include "fs/nvfs.h"
22 #include "lib/list.h"
23 #include "sys/scheduler.h"
24 #include "sys/timer.h"
25 #include "drv/disk/dpm.h"
26 #include <fmt/tga.h>
27 #include "sys/pixfmt.h"
28 #include "io/rgb_image.h"
29 #include <sys/cpuinfo.h>
30 #include "../../include/lib/fileio.h"
31 #include "sys/system.h"
32 #include "debug/hexview.h"
33 #include "lib/command_parser.h"
34
35 #include "../ports/eBat/eBat.h"
36 #include "../ports/eBat/eBatRuntime.h"
37
38 int G_CLI_CURINXA = 0;
39 int G_CLI_CURINXB = 0;
40 int G_CLI_H_KYB = 1;
41 int G_CLI_CURINXD = 17;
42 char G_CLI_PATH[1024] = "R:\\Sayori\\";
43
44 typedef struct {
45 char* name;
46 char* alias;
47 uint32_t (*funcv)(uint32_t, char**);
48 char* helpstring;
49 } CLI_CMD_ELEM;
50
51 CLI_CMD_ELEM G_CLI_CMD[];
52
53 // void F_CLI_KYB(void* data1,void* data2,void* data3,void* data4,void* data5){
54 // if (G_CLI_H_KYB == 0) return;
55 // qemu_log("[F_CLI_KYB] Key:%d | Pressed: %x",(int) data1, (int) data2);
56 // }
57
58 //uint32_t CLI_CMD_GBA(uint32_t c, char* v[]){
59 // if (c == 0 || (c == 1 && (strcmpn(v[1],"/?")))){
60 // _tty_printf("Эмулятор GameBoy.\n");
61 // _tty_printf("Пример:\"GBA R:\\game.gb\".\n");
62 // _tty_printf("\n");
63 // return 1;
64 // }
65 // // gb game.gb
66 // tty_printf("%d\n", c);
67 //
68 // for(int i = 0; i < c; i++) {
69 // tty_printf("#%d = %s\n", i, v[i]);
70 // }
71 //
72 // gb_main(c, v);
73 //
74 // return 1;
75 //}
76
77
78 uint32_t CLI_CMD_CLS(uint32_t c, char* v[]){
79 clean_tty_screen();
80 return 1;
81 }
82
83 uint32_t CLI_CMD_SYSINFO(uint32_t c, char* v[]){
84 clean_tty_screen();
85
86 setPosY(256);
87
88 tty_printf("SayoriOS by SayoriOS Team (pimnik98 and NDRAEY)\n\n");
89
90 tty_printf("Системная информация:\n");
91 tty_printf("\tOS: SayoriOS v%d.%d.%d\n", VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH);
92 tty_printf("\tДата сборки: %s\n", __TIMESTAMP__);
93 tty_printf("\tАрхитектура: %s\n", ARCH_TYPE);
94 tty_printf("\tПроцессор: %s\n", getNameBrand());
95
96 if(is_temperature_module_present()) {
97 tty_printf("\tТемпература: %d *C\n", get_cpu_temperature());
98 } else {
99 tty_printf("\tТемпература: -- *C\n");
100 }
101
102 tty_printf("\tОЗУ: %u kb\n", getInstalledRam()/1024);
103 tty_printf("\tВидеоадаптер: %s\n", "Legacy framebuffer (Unknown)");
104 tty_printf("\tДисплей: %s (%dx%d)\n", "(\?\?\?)", getScreenWidth(), getScreenHeight());
105 tty_printf("\tТики: %d\n", getTicks());
106 tty_printf("\tЧастота таймера: %d Гц\n", getFrequency());
107 tty_printf("\tВремя с момента запуска: %f секунд\n", getUptime());
108 return 1;
109 }
110
111
112 uint32_t CLI_CMD_DISKPART(uint32_t c, char* v[]){
113 _tty_printf("Список примонтированных дисков:\n");
114 // fsm_dpm_update(-1);
115 for(int i = 0; i < 26; i++){
116 DPM_Disk dpm = dpm_info(i + 65);
117 if (dpm.Ready != 1) continue;
118 _tty_printf(" [%c] %s | %s\n", i + 65, dpm.FileSystem, dpm.Name);
119 }
120
121 _tty_printf("\n");
122 //clean_tty_screen();
123 return 1;
124 }
125
126
127 uint32_t CLI_CMD_CAT(uint32_t c, char* v[]){
128 if (c == 0 || (c == 1 && (strcmpn(v[1],"/?")))){
129 _tty_printf("Данная программа выводит содержимое файла.\n");
130 _tty_printf("Пример:\"CAT R:\\Sayori\\motd\".\n");
131 _tty_printf("\n");
132 return 1;
133 }
134 FILE* cat_file = fopen(v[1], "r");
135 if (!cat_file){
136 tty_setcolor(COLOR_ERROR);
137 tty_printf("[CMD] [CAT] Не удалось найти файл `%s`. Проверьте правильность введенного вами пути.\n",v[1]);
138 return 2;
139 }
140
141 size_t filesize = fsize(cat_file);
142
143 uint8_t* buffer = kcalloc(1,filesize + 1);
144
145 fread(cat_file, 1, filesize, buffer);
146
147 tty_printf("%s", buffer);
148
149 fclose(cat_file);
150
151 kfree(buffer);
152 return 1;
153 }
154
155 uint32_t CLI_CMD_DEL(uint32_t c, char* v[]){
156 if (c == 0 || (c == 1 && (strcmpn(v[1],"/?")))){
157 _tty_printf("Удаление файла\n");
158 _tty_printf("Пример:\"DEL T:\\Sayori\\tmp.log\".\n");
159 _tty_printf("\n");
160 return 1;
161 }
162
163 bool res = unlink(v[1]);
164
165 if (!res) {
166 tty_setcolor(COLOR_ERROR);
167 tty_printf("Не удалось удалить файл, возможно файл не найден или у вас недостаточно прав для его удаления.\n");
168 return 1;
169 }
170 return 0;
171 }
172
173
174 uint32_t CLI_CMD_RMDIR(uint32_t c, char* v[]){
175 if (c == 0 || (c == 1 && (strcmpn(v[1],"/?")))){
176 _tty_printf("Удаление папки\n");
177 _tty_printf("Пример:\"RMDIR T:\\Sayori\\\".\n");
178 _tty_printf("\n");
179 return 1;
180 }
181
182 bool res = rmdir(v[1]);
183
184 if (!res) {
185 tty_setcolor(COLOR_ERROR);
186 tty_printf("Не удалось удалить папку, возможно папка не найдена или у вас недостаточно прав для её удаления.\n");
187 return 1;
188 }
189 return 0;
190 }
191
192 uint32_t CLI_CMD_TOUCH(uint32_t c, char* v[]){
193 if (c == 0 || (c == 1 && (strcmpn(v[1],"/?")))){
194 _tty_printf("Создание файла\n");
195 _tty_printf("Пример:\"TOUCH T:\\Sayori\\tmp.log\".\n");
196 _tty_printf("\n");
197 return 1;
198 }
199
200 bool res = touch(v[1]);
201
202 if (!res) {
203 tty_setcolor(COLOR_ERROR);
204 tty_printf("Не удалось создать файл, возможно файл уже существует или у вас недостаточно прав для её создания в этой папке.\n");
205 return 1;
206 }
207 return 0;
208 }
209
210 uint32_t CLI_CMD_MKDIR(uint32_t c, char* v[]){
211 if (c == 0 || (c == 1 && (strcmpn(v[1],"/?")))){
212 _tty_printf("Создание папки\n");
213 _tty_printf("Пример:\"TOUCH T:\\Sayori\\\".\n");
214 _tty_printf("\n");
215 return 1;
216 }
217
218 bool res = mkdir(v[1]);
219
220 if (!res) {
221 tty_setcolor(COLOR_ERROR);
222 tty_printf("Не удалось создать папка, возможно папка уже существует или у вас недостаточно прав для её создания в этой папке.\n");
223 return 1;
224 }
225 return 0;
226 }
227
228 uint32_t CLI_CMD_JSE(uint32_t c, char* v[]){
229 if (c == 0 || (c == 1 && (strcmpn(v[1],"/?")))){
230 _tty_printf("JavaScript Engine.\n");
231 _tty_printf("Пример:\"JSE R:\\jse\\console.js\".\n");
232 _tty_printf("\n");
233 return 1;
234 }
235
236 int res = elk_file(v[1]);
237
238 if (!res) {
239 tty_setcolor(COLOR_ERROR);
240 tty_printf(" [JSE] Произошла ошибка при выполнении скрипта. Подробности отправлены в консоль.");
241 }
242 return 1;
243 }
244
245 uint32_t CLI_CMD_SET(uint32_t c, char* v[]){
246 if (c == 1 && (strcmpn(v[1],"/?"))){
247 _tty_printf("Для получения данных переменной введите \"SET ПЕРЕМЕННАЯ\".\n");
248 _tty_printf("Для установки переменной введите \"SET ПЕРЕМЕННАЯ=ЗНАЧЕНИЕ\".\n");
249 _tty_printf("Для удаления переменной введите \"SET ПЕРЕМЕННАЯ=\".\n\n");
250
251 _tty_printf("\n");
252 return 1;
253 }
254 if (c == 0){
255 VARIABLE* s = variable_list("");
256 for(size_t i = 0; i<512; i++) {
257 if (s[i].Ready != 1) break;
258 _tty_printf("%s=%s\n", s[i].Key, s[i].Value);
259 }
260 kfree(s);
261 } else {
262 uint32_t pc = str_cdsp2(v[1], '=');
263 char** out = explode(v[1], '=');
264
265 if (pc != 1){
267 qemu_log("[Режим поиска] %s",v[1]);
268 VARIABLE* s = variable_list(v[1]);
269 for(size_t i = 0; i<512; i++) {
270 if (s[i].Ready != 1) break;
271 _tty_printf("%s=%s\n", s[i].Key, s[i].Value);
272 }
273 kfree(s);
274 } else if (out[1] == NULL || strlen(out[1]) == 0) {
275 qemu_log("[Режим удаления] %s",out[0]);
276 variable_write(out[0],"");
277 } else if (out[1] != NULL) {
278 qemu_log("[Режим изменения] %s",out[0]);
279 variable_write(out[0],out[1]);
280 }
281
282 // Почему-то не работает, а должно
283 // for (int d = 0; d <= out;d++){
284 // kfree(out[d]);
285 // }
286 kfree(out);
287 }
288 punch();
289
290 return 0;
291 }
292
293 uint32_t CLI_CMD_DIR(uint32_t c, char* v[]) {
294 const char* path = (c == 1 ? G_CLI_PATH : v[1]);
295
296 FSM_DIR* Dir = nvfs_dir(path);
297 if (Dir->Ready != 1){
298 tty_printf("Ошибка %d! При чтении папки: %s\n",Dir->Ready, path);
299 kfree(Dir);
300 return 1;
301 } else {
302 tty_printf("Содержимое папки папки: %s\n\n", path);
303 size_t Sizes = 0;
304 for (int i = 0; i < Dir->Count; i++){
305 char* btime = fsm_timePrintable(Dir->Files[i].LastTime);
306 tty_printf("%s\t%s\t\t%s\n",
307 btime,
308 (Dir->Files[i].Type == 5?"<ПАПКА>":"<ФАЙЛ> "),
309 Dir->Files[i].Name
310 );
311 Sizes += Dir->Files[i].Size;
312 kfree(btime);
313 }
314 tty_printf("\nФайлов: %d | Папок: %d | Всего: %d\n", Dir->CountFiles, Dir->CountDir, Dir->Count);
315 tty_printf("Размер папки: %d мб. | %d кб. | %d б.\n", (Sizes != 0?(Sizes/1024/1024):0), (Sizes != 0?(Sizes/1024):0), Sizes);
316 }
318 kfree(Dir->Files);
320 kfree(Dir);
321 return 1;
322 }
323
324 uint32_t CLI_CMD_RUN(uint32_t c, char* v[]) {
325 if (c == 0){
326 //tty_setcolor(COLOR_ERROR);
327 tty_printf("Файл не указан.\n");
328 return 1;
329 }
330
331 const char* path = v[0];
332
333 FILE* elf_exec = fopen(path, "r");
334
335 if(!elf_exec) {
336 fclose(elf_exec);
337 tty_error("\"%s\" не является внутренней или внешней\n командой, исполняемой программой или пакетным файлом.\n", path);
338 return 2;
339 }
340
341 if(!is_elf_file(elf_exec)) {
342 fclose(elf_exec);
343 tty_printf("\"%s\" не является программой или данный тип файла не поддерживается.\n", path);
344 return 2;
345 }
346
347 fclose(elf_exec);
348
349 run_elf_file(path, c, v);
350
351 return 0;
352 }
353
354 uint32_t CLI_CMD_ECHO(uint32_t c, char* v[]){
355 if (c == 1 && (strcmpn(v[1],"/?"))){
356 _tty_printf("Данная команда выводит сообщение на экран, а также переменные.\n");
357 _tty_printf("\n");
358 return 1;
359 }
360 for (int i = 1; i <= c;i++){
362 size_t len_v = strlen(v[i]);
363 size_t len_e = len_v-1;
364 if (v[i][0] == '%' && v[i][len_e] == '%'){
365 char* tmp_ve = kmalloc(len_v);
366 substr(tmp_ve,v[i],1,len_e-1);
367 char* tmp_dv = variable_read(tmp_ve);
368 kfree(tmp_ve);
369 if (tmp_dv != NULL) {
370 _tty_printf("%s",tmp_dv);
371 continue;
372 }
373 }
374 //if (str_contains(v[i],""))
375 if (strcmpn(v[i],"%DATE%") || strcmpn(v[i],"%date%")){
376 _tty_printf("2023-01-01");
377 } else if (strcmpn(v[i],"%CD%") || strcmpn(v[i],"%cd%") || strcmpn(v[i],"%path%") || strcmpn(v[i],"%PATH%")){
378 _tty_printf("%s",G_CLI_PATH);
379 } else if (strcmpn(v[i],"%RANDOM%") || strcmpn(v[i],"%random%")){
381 _tty_printf("%u", rand());
382 } else if (strcmpn(v[i],"%TIME%") || strcmpn(v[i],"%time%")){
383 _tty_printf("%s","12:34");
384 } else {
385 _tty_printf("%s ", v[i]);
386 }
387 }
388 _tty_printf("\n");
389 return 1;
390 }
391
392 uint32_t CLI_CMD_HELP(__attribute__((unused)) uint32_t c, __attribute__((unused)) char* v[]){
393 _tty_printf("Для получения дополнительной информации, наберите \"команда /?\", если справка по команде есть, она будет отображена.\n\n");
394 size_t hlp_padding = 11;
395 for(size_t i = 0; G_CLI_CMD[i].name != nullptr; i++) {
396 _tty_printf("%s", G_CLI_CMD[i].name);
397 for(size_t j = 0; j < hlp_padding - strlen(G_CLI_CMD[i].name); j++) {
398 _tty_printf(" ");
399 }
400 _tty_printf(" | %s\n", G_CLI_CMD[i].helpstring);
401 }
402
403 punch();
404
405 return 1;
406 }
407
408 // Pimnik98, don't being thirsty
409
410 uint32_t gfxbench(uint32_t argc, char* args[]);
411 uint32_t miniplay(uint32_t argc, char* args[]);
412 uint32_t CLI_CMD_NET(uint32_t c, char **v);
413 uint32_t parallel_desktop_start(uint32_t argc, char* args[]);
414 uint32_t mala_draw(uint32_t argc, char* argv[]);
415 uint32_t pci_print_list(uint32_t argc, char* argv[]);
416 //uint32_t pavi_view(uint32_t argc, char* argv[]);
417 uint32_t rust_command(uint32_t argc, char* argv[]);
418 uint32_t CLI_MEMINFO(uint32_t argc, char* argv[]) {
419 tty_printf("Физическая:\n");
420 tty_printf(" Используется: %u байт (%u MB)\n", used_phys_memory_size, used_phys_memory_size / MB);
421 tty_printf(" Свободно: %u байт (%u MB)\n", phys_memory_size - used_phys_memory_size, (phys_memory_size - used_phys_memory_size) / MB);
422 tty_printf("Виртуальная:\n");
423 tty_printf(" %u записей\n", system_heap.allocated_count);
424 tty_printf(" Используется: %u байт (%u MB)\n", system_heap.used_memory, system_heap.used_memory / MB);
425
426 return 0;
427 }
428
429 uint32_t proc_list(uint32_t argc, char* argv[]) {
430 extern list_t process_list;
431 extern list_t thread_list;
432
433 tty_printf("%d процессов\n", process_list.count);
434
435 list_item_t* item = process_list.first;
436 for(int i = 0; i < process_list.count; i++) {
437
438 process_t* proc = (process_t*)item;
439
440 tty_printf(" Процесс: %d [%s]\n", proc->pid, proc->name);
441
442 item = item->next;
443 }
444
445 tty_printf("%d потоков\n", thread_list.count);
446
447 list_item_t* item_thread = thread_list.first;
448 for(int j = 0; j < thread_list.count; j++) {
449 thread_t* thread = (thread_t*)item_thread;
450
451 tty_printf(" Поток: #%u процесса #%u; Стек: (%x, %x, %d); Состояние: %s\n",
452 thread->id, thread->process->pid, thread->stack_top, thread->stack, thread->stack_size,
453 thread_state_string(thread->state)
454 );
455
456 item_thread = item_thread->next;
457 }
458
459 return 0;
460 }
461
462 uint32_t CLI_CMD_REBOOT(uint32_t argc, char* argv[]) {
463 reboot();
464
465 return 0;
466 }
467
468
469 uint32_t CLI_SPAWN(uint32_t argc, char* argv[]) {
470 qemu_log("SPAWN! %u", argc);
471 if (argc <= 1) {
472 //tty_setcolor(COLOR_ERROR);
473 tty_printf("Файл не указан.\n");
474 return 1;
475 }
476
477 const char* path = argv[1];
478
479 FILE* elf_exec = fopen(path, "r");
480
481 if(!elf_exec) {
482 fclose(elf_exec);
483 tty_error("\"%s\" не является внутренней или внешней\n командой, исполняемой программой или пакетным файлом.\n", path);
484 return 2;
485 }
486
487 if(!is_elf_file(elf_exec)) {
488 fclose(elf_exec);
489 tty_printf("\"%s\" не является программой или данный тип файла не поддерживается.\n", path);
490 return 2;
491 }
492
493 fclose(elf_exec);
494
495 spawn(path, argc, argv);
496
497 return 0;
498 }
499
500 uint32_t CLI_SPAWN_TEST(uint32_t argc, char* argv[]) {
501 char* cmdline[] = {"hello"};
502
503 spawn("R:\\prog", 0, cmdline);
504 sleep_ms(1000);
505 spawn("R:\\hellors", 0, cmdline);
506
507 return 0;
508 }
509
510 uint32_t CLI_CMD_MTRR(uint32_t argc, char* argv[]) {
511 list_mtrrs();
512
513 return 0;
514 }
515
516 uint32_t CLI_RD(uint32_t argc, char* argv[]) {
517 if(argc < 2) {
518 tty_error("No arguments.\n");
519 return 1;
520 }
521
522 char* disk = argv[1];
523 DPM_Disk data = dpm_info(disk[0]);
524
525 if(!data.Ready) {
526 tty_error("No disk.\n");
527 return 1;
528 }
529
530 char* newdata = kcalloc(1024, 1);
531
532 dpm_read(disk[0], 0, 0, 1024, newdata);
533
534 hexview_advanced(newdata, 1024, 26, true, _tty_printf);
535
536 punch();
537
538 kfree(newdata);
539
540 return 0;
541 }
542
543 uint32_t CLI_CMD_HEX(uint32_t argc, char** argv) {
544 if(argc < 2) {
545 tty_printf("No arguments\n");
546 return 1;
547 }
548
549 char* file = argv[1];
550
551 FILE* fp = fopen(file, "rb");
552
553 if(!fp) {
554 tty_error("Failed to open file: %s\n", file);
555 return 1;
556 }
557
558 size_t sz = fsize(fp);
559
560 char* data = kcalloc(512, 1);
561
562 fread(fp, 512, 1, data);
563
564 tty_printf("Showing first 512 bytes:\n");
565
566 hexview_advanced(data, 512, 26, true, _tty_printf);
567
568 kfree(data);
569 fclose(fp);
570
571 return 0;
572 }
573
574 uint32_t CLI_PLAIN(uint32_t argc, char** argv) {
575 if(argc < 3) {
576 tty_error("plain <address> <file>");
577 tty_printf("Note: Address must be in HEX without 0x prefix! Example: CAFEBABE");
578 return 1;
579 }
580
581 size_t address = htoi(argv[1]);
582
583 qemu_note("Address is: %x", address);
584
585 FILE* file = fopen(argv[2], "rb");
586
587 size_t filesize = fsize(file);
588
589 qemu_note("File size is: %d", filesize);
590
591 void* a = kmalloc_common(ALIGN(filesize, PAGE_SIZE), PAGE_SIZE);
592 memset(a, 0, ALIGN(filesize, PAGE_SIZE));
593
594 size_t a_phys = virt2phys(get_kernel_page_directory(), (virtual_addr_t)a);
595
596 map_pages(get_kernel_page_directory(), (physical_addr_t)a_phys, address, ALIGN(filesize, PAGE_SIZE), PAGE_WRITEABLE);
597
598 fread(file, 1, filesize, (void*)a);
599
600 int (*entry)(int, char**) = (int(*)(int, char**))address;
601
602 qemu_log("RESULT IS: %d", entry(0, 0));
603
604 unmap_pages_overlapping(get_kernel_page_directory(), address, filesize);
605
606 kfree(a);
607 fclose(file);
608
609 return 0;
610 }
611
612 uint32_t pavi_view(uint32_t, char**);
613 uint32_t minesweeper(uint32_t, char**);
614 uint32_t shell_diskctl(uint32_t, char**);
615 uint32_t calendar(uint32_t, char**);
616 uint32_t forth_sys(uint32_t, char**);
617
618 CLI_CMD_ELEM G_CLI_CMD[] = {
619 {"CLS", "cls", CLI_CMD_CLS, "Очистка экрана"},
620 {"CALENDAR", "calendar", calendar, "Календарь"},
621 {"CAT", "cat", CLI_CMD_CAT, "Выводит содержимое файла на экран"},
622 {"ECHO", "echo", CLI_CMD_ECHO, "Выводит сообщение на экран."},
623 {"DIR", "dir", CLI_CMD_DIR, "Выводит список файлов и папок."},
624 {"DISKCTL", "diskctl", shell_diskctl, "Управление ATA-дисками"},
625 {"DISKPART", "diskpart", CLI_CMD_DISKPART, "Список дисков Disk Partition Manager"},
626 // {"GBA", "gba", CLI_CMD_GBA, "GameBoy Emulator"},
627 {"HELP", "help", CLI_CMD_HELP, "Выводит справочную информацию о командах SayoriOS (CLI)."},
628 {"SET", "set", CLI_CMD_SET, "Показывает, указывает и удаляет переменные среды SayoriOS"},
629 {"NET", "net", CLI_CMD_NET, "Информация об сетевых устройствах"},
630 {"GFXBENCH", "gfxbench", gfxbench, "Тестирование скорости фреймбуфера"},
631 {"MEMINFO", "meminfo", CLI_MEMINFO, "Информация об оперативной памяти"},
632 {"MINIPLAY", "miniplay", miniplay, "WAV-проиграватель"},
633 {"DESKTOP", "desktop", parallel_desktop_start, "Рабочий стол"},
634 {"MALA", "mala", mala_draw, "Нарисовать рисунок"},
635 {"MINESWEEPER", "minesweeper", minesweeper, "Сапёр"},
636 {"MTRR", "mtrr", CLI_CMD_MTRR, "MTRR"},
637 {"PAVI", "pavi", pavi_view, "Программа для просмотра изображений"},
638 {"PCI", "pci", pci_print_list, "Список PCI устройств"},
639 // {"RS", "rs", rust_command, "Rust command"},
640 {"PROC", "proc", proc_list, "Список процессов"},
641 {"SYSINFO", "sysinfo", CLI_CMD_SYSINFO, "Информация о системе"},
642 {"JSE", "jse", CLI_CMD_JSE, "JavaScript Engine"},
643 {"TOUCH", "touch", CLI_CMD_TOUCH, "Создать файл"},
644 {"DEL", "DEL", CLI_CMD_DEL, "Удалить файл"},
645 {"MKDIR", "mkdir", CLI_CMD_MKDIR, "Создать папку"},
646 {"RMDIR", "rmdir", CLI_CMD_RMDIR, "Удалить папку"},
647 {"REBOOT", "reboot", CLI_CMD_REBOOT, "Перезагрузка"},
648 {"RD", "rd", CLI_RD, "Чтение данных с диска"},
649 {"SPAWN", "spawn", CLI_SPAWN, "spawn a new process"},
650 {"PLAIN", "plain", CLI_PLAIN, "Run plain program"},
651 {"HEX", "hex", CLI_CMD_HEX, "Show hex data"},
652 {"ST", "st", CLI_SPAWN_TEST, "spawn test"},
653 {"FORTH", "forth",forth_sys, "Форт система"},
654 {"4TH", "4th",forth_sys, "Форт система"},
655 {nullptr, nullptr, nullptr}
656 };
657
658 int cli_handler_ebat(int argc, char** argv){
659 qemu_note("[RUNTIME] [System] [EXEC] Count: %d\n", argc);
660 int ret = 0;
661 bool found = false;
662
663 for(size_t i = 0; G_CLI_CMD[i].name != nullptr; i++) {
664 if(strcmpn(G_CLI_CMD[i].name, argv[0]) || strcmpn(G_CLI_CMD[i].alias, argv[0])) {
665 ret = G_CLI_CMD[i].funcv(argc, argv);
666 found = true;
667 break;
668 }
669 }
670
671 if(!found) {
672 ret = CLI_CMD_RUN(argc, argv);
673 }
674
675 return ret;
676 }
677
678 void cli_handler(const char* ncmd){
679 set_cursor_enabled(0);
680
681 command_parser_t parser = {};
682
683 command_parser_new(&parser, ncmd);
684
685 for(size_t i = 0; i < parser.argc; i++){
686 qemu_log("[CLI] '%s' => argc: %d => argv: %s", ncmd, i, parser.argv[i]);
687 }
688
689 bool found = false;
690
691 for(size_t i = 0; G_CLI_CMD[i].name != nullptr; i++) {
692 if(strcmpn(G_CLI_CMD[i].name, parser.argv[0]) || strcmpn(G_CLI_CMD[i].alias, parser.argv[0])) {
693 G_CLI_CMD[i].funcv(parser.argc, parser.argv);
694 found = true;
695 break;
696 }
697 }
698
699 if(!found) {
700 CLI_CMD_RUN(parser.argc, parser.argv);
701 }
702
703 command_parser_destroy(&parser);
704
705 set_cursor_enabled(1);
706 }
707
708 void cli(){
709 qemu_log("[CLI] Started...");
710 tty_set_bgcolor(0xFF000000);
711 tty_setcolor(0xFFFFFF);
712
713 // T_CLI_KYB = RegTrigger(0x0001, &F_CLI_KYB);
714
715 // clean_tty_screen();
716 _tty_printf("SayoriOS [Версия: v%d.%d.%d]\n",VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH);
717 _tty_printf("(c) SayoriOS Team, 2023.\nДля дополнительной информации наберите \"help\".\n\n");
718
719 punch();
720
721 char* input_buffer = kcalloc(1, 512);
722 while(1) {
723 size_t memory_cur = system_heap.used_memory;
724 size_t memory_cnt_cur = system_heap.allocated_count;
725
726 tty_setcolor(0xFFFFFF);
727 tty_printf("%s>", G_CLI_PATH);
728 memset(input_buffer, 0, 512);
729
730 int result = gets_max(input_buffer, 512);
731
732 if(result == 1) {
733 tty_alert("\nMaximum 512 characters!\n");
734 continue;
735 }
736
737 size_t len_cmd = strlen(input_buffer);
738 if (len_cmd == 0) {
739 continue;
740 }
741
742 size_t current_time = timestamp();
743 qemu_log("cmd: %s", input_buffer);
744
746
747 int preprocessor = 0;
748
749 if (preprocessor == 0){
750 cli_handler(input_buffer);
751 } else {
752 BAT_T* token = bat_parse_string(input_buffer);
753 token->Debug = 0;
754 token->Echo = 1;
755 int ret = bat_runtime_exec(token);
756 qemu_warn("RETURN CODE: %d\n",ret);
757 bat_destroy(token);
758 }
760
761 //
762 tty_printf("\n");
763
764 ssize_t delta = (int)system_heap.used_memory - (int)memory_cur;
765 ssize_t delta_blocks = (int)system_heap.allocated_count - (int)memory_cnt_cur;
766 qemu_warn("Used memory before: %d (%d blocks)", memory_cur, memory_cnt_cur);
767 qemu_warn("Used memory now: %d (%d blocks)", system_heap.used_memory, system_heap.allocated_count);
768 qemu_warn("Memory used: %d (%d blocks)", delta, delta_blocks);
769
770 if(delta > 0) {
771 qemu_err("Memory leak!");
772 } else if(delta == 0) {
773 qemu_ok("All right! No memory leaks! Keep it up, buddy!");
774 }
775
776 qemu_note("Time elapsed: %d milliseconds", timestamp() - current_time);
777 }
778
779 kfree(input_buffer);
780 }
G_CLI_CURINXD
int G_CLI_CURINXD
Текущий диск
Definition: cli.c:41
CLI_CMD_DIR
uint32_t CLI_CMD_DIR(uint32_t c, char *v[])
Definition: cli.c:293
CLI_CMD_ECHO
uint32_t CLI_CMD_ECHO(uint32_t c, char *v[])
Definition: cli.c:354
CLI_CMD_SET
uint32_t CLI_CMD_SET(uint32_t c, char *v[])
Definition: cli.c:245
__attribute__
struct registers __attribute__((packed))
Структура данных пакета от мыши
Definition: psf.h:19
getNameBrand
char * getNameBrand()
Получение имени процессора
Definition: cpuinfo.c:80
dpm_read
size_t dpm_read(char Letter, uint64_t high_offset, uint64_t low_offset, size_t Size, void *Buffer)
[DPM] Считывание данных с диска
Definition: dpm.c:82
str_cdsp2
uint32_t str_cdsp2(const char *a_str, char del)
Функция отладки
Definition: explode.c:21
mkdir
bool mkdir(const char *Path)
[FileIO] Создает папку
Definition: fileio.c:193
unlink
bool unlink(const char *Path)
[FileIO] Удаляет файл
Definition: fileio.c:204
filesize
size_t filesize(const char *Path)
[FileIO] Возвращает размер указанного файла
Definition: fileio.c:67
rmdir
bool rmdir(const char *Path)
[FileIO] Удаляет папку
Definition: fileio.c:215
touch
bool touch(const char *Path)
[FileIO] Создает файл
Definition: fileio.c:180
strlen
size_t strlen(const char *str)
Возращает длину строки
Definition: string.c:88
strcmpn
bool strcmpn(const char *str1, const char *str2)
Сравнение строк
Definition: string.c:270
memset
void * memset(void *ptr, char value, size_t num)
Заполнение массива указанными символами
Definition: string.c:203
substr
void substr(char *restrict dest, const char *restrict source, int from, int length)
Вырезает и возвращает подстроку из строки
Definition: string.c:492
process_list
list_t process_list
Список процессов
Definition: scheduler.c:14
thread_list
list_t thread_list
Список потоков
Definition: scheduler.c:15
fclose
void fclose(FILE *stream)
Закончить работу с файлом
Definition: stdio.c:213
fopen
FILE * fopen(const char *filename, const char *_mode)
Открывает файл
Definition: stdio.c:166
fsize
int fsize(FILE *stream)
Получение размера файла в байтах
Definition: stdio.c:227
fread
int fread(FILE *stream, size_t count, size_t size, void *buffer)
Чтение файла
Definition: stdio.c:250
_list_item_t
Definition: list.h:27
BAT
Definition: eBat.h:91
CLI_CMD_ELEM
Definition: cli.c:44
FILE
Структура файла. Требуется для работы с VFS.
Definition: stdio.h:21
VARIABLE
Definition: variable.h:3
command_parser_t
Definition: command_parser.h:5
list_t
Definition: list.h:16
reboot
void reboot()
Перезагрузка устройства
Definition: system.c:49
getFrequency
size_t getFrequency()
Получить частоту таймера
Definition: timer.c:43
getTicks
size_t getTicks()
Получить количество тиков
Definition: timer.c:26
sleep_ms
void sleep_ms(uint32_t milliseconds)
Ожидание по миллисекундам
Definition: timer.c:68
setPosY
void setPosY(uint32_t y)
Изменяем позицию курсора по Y.
Definition: tty.c:164
tty_set_bgcolor
void tty_set_bgcolor(uint32_t color)
Изменение цвета заднего фона
Definition: tty.c:121
tty_setcolor
void tty_setcolor(uint32_t color)
Изменение цвета текста
Definition: tty.c:108