Beispiel #1
0
        /// <summary>
        /// Точка входа в ядро
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            Console.CancelKeyPress += Console_CancelKeyPress;
            AppDomain.CurrentDomain.ProcessExit += OnCloseProcess;

#if DEBUG
            LoggerProc = Process.Start("Loggers\\Logger.exe");
            KernelConnectors.Logger.Init();
#endif

            //Инициализация конфигурации ядра
            InitKernelConfiguration();

            //Инициализация DLL модулей (ввод их в состояние готовности подключится к ядру)
            InitModules();

            //Инициализация входящих подключений
            KernelConnectors.InitInputConnections();

            //Инициализация исходящих подключений
            KernelConnectors.InitOutputConnections();

            //Инициализация компонентов ядра
            InitKernelComponents();

            //Базовая настройка модулей
            ApplyingBasicSettings();

            if (Config.GUI_Autostart)
            {
                if (File.Exists("GUI\\GUI.exe"))
                {
                    KernelConnectors.Logger.WriteLine("[Kernel] Запуск GUI");
                    GUI_Proc = Process.Start("GUI\\GUI.exe");
                }
                else
                {
                    KernelConnectors.Logger.WriteLine("[Kernel] Файл GUI не найден");
                }
            }

            //await Task.Delay(-1);
        }
Beispiel #2
0
        private static void Handler()
        {
            var binaryReader = new BinaryReader(UserInputConnector);

            Out_writer = new BinaryWriter(UserOutputConnector);

#if DEBUG
            Console.WriteLine("[API] Init success");
#endif
            byte code = 255;

            while (true)
            {
                KernelConnectors.Api_In_Sync.WaitOne();

                {
                    try
                    {
                        code = binaryReader.ReadByte();
                    }
                    catch
                    {
#if DEBUG
                        Console.WriteLine("[API] Чтение завершилось ошибкой");
#endif
                        if (!UserInputConnector.IsConnected)
                        {
#if DEBUG
                            Console.WriteLine("[API] Ожидание переподключения пользователя");
#endif
                            try
                            {
                                UserInputConnector.WaitForConnection();
                            }
                            catch (Exception ex)
                            {
#if DEBUG
                                Console.WriteLine($"[API] {ex.Message}");
#endif
                                break;
                            }

                            if (!UserOutputConnector.IsConnected)
                            {
#if DEBUG
                                Console.WriteLine("[API] Переподключение к пользователю");
#endif
                                UserOutputConnector.Connect();
                            }


                            KernelConnectors.Api_In_Sync.ReleaseMutex();
                            continue;
                        }
                    }

#if DEBUG
                    Console.WriteLine($"[API] Запрос, код {code}");
#endif

                    switch (code)
                    {
                    //Запрос на
                    case 0:
                    {
                        break;
                    }

                    //Запрос на перемещение файла в карантин
                    case 1:
                    {
                        Task.Run(() =>
                            {
                                var id = binaryReader.ReadInt32();
                                ToQuarantine(id);
                            });

                        break;
                    }

                    //Запрос на восстановление файла из карантина
                    case 2:
                    {
                        Task.Run(() =>
                            {
                                var id = binaryReader.ReadInt32();
                                Restore(id);
                            });

                        break;
                    }

                    //Запрос на удаление файла
                    case 3:
                    {
                        Task.Run(() =>
                            {
                                var id = binaryReader.ReadInt32();
                                Delete(id);
                            });

                        break;
                    }

                    //Запрос информации о вирусе
                    case 4:
                    {
                        Task.Run(() =>
                            {
                                var id = binaryReader.ReadInt32();
                                getVirusInfo(id);
                            });

                        break;
                    }

                    //Запрос информации о всех вирусах
                    case 5:
                    {
                        Task.Run(() =>
                            {
                                getAllVirusesInfo();
                            });

                        break;
                    }

                    //Просканировать файл
                    case 6:
                    {
                        string file = binaryReader.ReadString();

#if DEBUG
                        Console.WriteLine("[API] Добавление задачи " + file);
#endif

                        Task.Run(() =>
                            {
                                if (ScanTasks.Add(file) is null)
                                {
#if DEBUG
                                    Console.WriteLine("[API] Ошибка добавления задачи, проверка завершена");
#endif
                                    API_ScanCompleted(0, false, 0, file);
                                }
                            }
                                 );

                        break;
                    }

                    //Очистить очередь сканирования
                    case 7:
                    {
                        KernelConnectors.ScannerService_Command_Sync.WaitOne();
                        {
                            ScanTasks.ClearQueue();
                        }
                        KernelConnectors.ScannerService_Command_Sync.ReleaseMutex();
                        break;
                    }

                    //Включение/выключение автоматической проверки съемных носителей
                    case 8:
                    {
                        var flag = binaryReader.ReadBoolean();

                        if (flag)
                        {
                            KernelConnectors.PartitionMon_CommandWriter.Write("2*");
                        }
                        else
                        {
                            KernelConnectors.PartitionMon_CommandWriter.Write("3*");
                        }

                        KernelConnectors.PartitionMon_CommandWriter.Flush();
                        break;
                    }

                    //Очистить информацию о подключенных устройствах
                    case 9:
                    {
                        KernelConnectors.PartitionMon_CommandWriter.Write("4*");
                        KernelConnectors.PartitionMon_CommandWriter.Flush();
                        break;
                    }

                    //Добавить простое правило фильтрации
                    case 10:
                    {
                        string rule = binaryReader.ReadString();
                        KernelConnectors.Filter_CommandWriter.Write((byte)3);
                        KernelConnectors.Filter_CommandWriter.Write(rule);

                        KernelConnectors.Filter_CommandWriter.Flush();
                        break;
                    }

                    //Удалить простое правило фильтрации
                    case 11:
                    {
                        string rule = binaryReader.ReadString();
                        KernelConnectors.Filter_CommandWriter.Write((byte)4);
                        KernelConnectors.Filter_CommandWriter.Write(rule);

                        KernelConnectors.Filter_CommandWriter.Flush();
                        break;
                    }

                    //Удалить все простые правила фильтрации
                    case 12:
                    {
                        KernelConnectors.Filter_CommandWriter.Write((byte)5);
                        KernelConnectors.Filter_CommandWriter.Flush();
                        break;
                    }

                    //Отключить всё
                    case 13:
                    {
#if DEBUG
                        Console.WriteLine("[API] Выключение ядра");
#endif

                        ScanTasks.Stop();

                        {
#if DEBUG
                            Console.WriteLine("[API] Выключение фильтра ");
#endif
                            KernelConnectors.Filter_CommandWriter.Write((byte)6);

#if DEBUG
                            Console.WriteLine("[API] Выключение монитора разделов ");
#endif
                            KernelConnectors.PartitionMon_CommandWriter.Write("7*");

#if DEBUG
                            Console.WriteLine("[API] Выключение сканнера ");
#endif
                            KernelConnectors.ScannerService_CommandWriter.Write((byte)1);

#if DEBUG
                            Console.WriteLine("[API] Выключение вирусной БД");
#endif
                            KernelConnectors.VirusesDb_CommandWriter.Write("/shutdown");
                        }

#if DEBUG
                        Console.WriteLine("[API] Закрытие подключений");
#endif
                        KernelConnectors.Stop();

                        Task.Run(() => {
                                Thread.Sleep(1000);
#if DEBUG
                                Console.WriteLine("[API] Отключение обработчика API");
#endif

                                RequestHandler.Abort();

#if DEBUG
                                Console.WriteLine("[API] Закрытие процесса ядра");
#endif
                                Process.GetCurrentProcess().Kill();
                            });


                        break;
                    }

                    case 14:
                    {
                        Defender(binaryReader.ReadBoolean());
                        break;
                    }

                    default:
                    {
#if DEBUG
                        Console.WriteLine("[API] Unknown request");
#endif
                        break;
                    }
                    }
                }

                KernelConnectors.Api_In_Sync.ReleaseMutex();
            }
        }