feat: my_tcp_syn and checksum (#8)

my_tcp_syn make tcp syn requests without waiting for confirmation.

Reviewed-on: https://gitea.serafimdev.com/serafim/dos/pulls/8

src/DosAtk.cpp

@@ -1,4 +1,12 @@
-// ====== DCL библиотеки ====== //
+#include <iostream>          // Для работы с вводом-выводом (cout, cin и др.)
+#include <stdlib.h>          // Стандартная библиотека C (функции работы с памятью, преобразования типов и др.)
+#include <string>            // Для работы со строками string
+#include <chrono>            // Для работы с временем и таймерами
+#include <ctime>             // Функции работы со временем C (time_t, localtime и др.)
+#include <iomanip>           // Для форматированного вывода (setw, setprecision и др.)
+#include <getopt.h>          // Для разбора аргументов командной строки
+#include <cctype>            // Функции для работы с символами (isdigit, isalpha и др.)
+#include <curl/curl.h>       // Библиотека libcurl для HTTP-запросов (отправка в Telegram)
 
 #include <cstring>          // Работа со строками и памятью (memset, memcpy)
 #include <unistd.h>         // POSIX API (close, read, write)
@@ -10,32 +18,25 @@
 #include <sys/ioctl.h>      // Управление сокетами и интерфейсами (ioctl)
 #include <fcntl.h>          // Флаги файловых дескрипторов (fcntl)
 
-// ====== DCL глобальные переменные ====== //
+// Глобальные переменные
-
-// Параметры
-int argc                                                // Количество аргументов при вызове программы
-char **argv                                             // Массив строк с агрументами
 std::string attack_type; // Тип атаки: scan или syn
 std::string domain; // Доменное Имя
 std::string ip; // Ip жертвы
-std::string port;                                       // Порт для syn атаки
+std::string port; // Порт
 std::string log_file; // Путь к директории для логов
 std::string telegram_id; // Telegram ID для уведомлений
-std::string telegram_token;                             // Токен бота для уведомлений
+std::string telegram_token; // Токен бота
-
-// Статистика
 int n_ok_requests; // Количество успешных запросов
 int n_fail_requests; // Количество не успешных запросов
 std::chrono::system_clock::time_point start_timestamp; // Начальное время работы
-// Переменные
 std::string log_msg; // Сообщение, которое будет записано в лог-файл
 std::string fin_msg; // Сообщение, которое будет выведено в консоль пользователю
 std::string msg; // Сообщение, которое будет отправлено в телеграм 
 int status; // Статус работы программы
 
-// ====== DCL процедуры ====== //
+// ====== end of DCL ====== //
 
-void my_check_params()
+int my_check_params(int argc, char **argv)
 {
     // Данная процедура записывает в глобальные переменные параметры 
     // (attack_type, domain, ip, port, log_file, telegram_id, telegram_token) проводимой атаки, поступившие при вызове программы
@@ -50,18 +51,11 @@ void my_check_params()
     // -101 - неизвестная опция или потерян аргумент, следует предложить вызвать флаг помощи
     // -600 -  пользователь ввел токен, но не id или наоборот
 
-    //Объявление
+    int status;
-    std::chrono::milliseconds ms;   // Количество миллисекунд от целой секунды времени начала выполнения программы
+    int opt;
-    int opt;                        // Прочитанный параметр
+    const char* short_options;
-    const char* short_options;      // Сокращения для параметров
-    struct option long_options[];   // Структура, описывающая пеобходимые программе параметры
-    int i;                          // Счётчик для цикла
-
-    // Инициализация
-    ms = std::chrono::duration_cast<std::chrono::milliseconds>(start_timestamp.time_since_epoch()) % 1000;
-    opt = -1;
     short_options = "a:d:i:p:l:t:b:h";
-    long_options = 
+    const struct option long_options[] = 
     {
         {"attack",    required_argument, NULL, 'a'},
         {"domain",    required_argument, NULL, 'd'},
@@ -73,19 +67,14 @@ void my_check_params()
         {"help",      no_argument,       NULL, 'h'},
         {NULL,     0,                 NULL,  0}
     };
-    i = 0;
 
-    printf("begin my_check_params"); // debug
+    std::string debug_msg;
-
+    debug_msg = "";
-    // Выводим информацию о времени запуска программы
+    for (int i = 0; i < argc; i++) {
-    printf("Starting DosAtk at %04d-%02d-%02d %02d:%02d:%02d.%03ld\n",  // Шаблон для вывода
+        debug_msg += argv[i];
-        std::localtime(&now_time_t)->tm_year + 1900,                    // Год (с 1900)
+        debug_msg += " ";
-        std::localtime(&now_time_t)->tm_mon + 1,                        // Месяц (0-11)
+    }
-        std::localtime(&now_time_t)->tm_mday,                           // День месяца
+    printf("begin my_check_params (argc: %i, argv: %s)\n", argc, debug_msg.c_str()); // debug
-        std::localtime(&now_time_t)->tm_hour,                           // Часы
-        std::localtime(&now_time_t)->tm_min,                            // Минуты
-        std::localtime(&now_time_t)->tm_sec,                            // Секунды
-        ms.count());                                                    // Миллисекунды
 
     // Обрабатываем аргументы командной строки с помощью getopt_long
     // Цикл продолжается, пока getopt_long возвращает валидные опции (-1 означает конец опций)
@@ -152,6 +141,7 @@ void my_check_params()
     }
 
     printf("end my_check_params status: %i\n", status); // debug
+    return status;
 }
 
 void my_diag()
@@ -159,8 +149,8 @@ void my_diag()
     // Данная функция вызывается в случае ошибки на каком-то этапе и на основании поступившего кода, 
     // формирует сообщение с описанием произошедшей ошибки
 
+    // Отладочный вывод - начало работы функции (можно отключить в релизной версии)
     printf("begin my_diag, status: %i\n", status); // debug
-
     // Выбор сообщения в зависимости от кода ошибки
     switch (status)
     {
@@ -201,18 +191,9 @@ void my_diag()
 // Принимает: const std::string& s - исходная строка для обработки
 // Возвращает: std::string - строка с экранированными спецсимволами
 std::string escape_json(const std::string& s) {
-    // Возвращаем строку с экранированными символами
-
-    // ===== Объявления =====
     std::string result; // Результирующая строка с экранированными символами
-    char c;             // Символ в строке
-
-    // ===== Инициализация =====
-    result = "";
-    c = '';
-
     // Проходим по каждому символу входной строки
-    for (c : s) {
+    for (char c : s) {
         // Обрабатываем специальные символы JSON
         switch (c) {
             case '"':  result += "\\\""; break; // Экранирование двойных кавычек
@@ -225,24 +206,17 @@ std::string escape_json(const std::string& s) {
             default:   result += c;     break; // Все остальные символы добавляем как есть
         }
     }
-
     return result; // Возвращаем обработанную строку
 }
 
 bool is_numeric(const std::string& s) {
     // Проверка, является ли строка числом (включая отрицательные)
 
-    // ===== Объявления =====
     size_t start; // Индекс, с которого начинать проверку цифр
-    size_t i;
-
-    // ===== Инициализация =====
-    start = 0;
-    i = 0;
-
     if (s.empty()) return false; // Пустая строка не может быть числом
     
     // Проверяем наличие знака минус в начале
+    start = 0;
     if (s[0] == '-') {
         // Строка из одного минуса не является числом
         if (s.size() == 1) return false;
@@ -250,47 +224,51 @@ bool is_numeric(const std::string& s) {
         start = 1;
     }
     // Проверяем все оставшиеся символы на цифры
-    for (i = start; i < s.size(); ++i) {
+    for (size_t i = start; i < s.size(); ++i) {
         // Найден нецифровой символ - строка не число
         if (!isdigit(s[i])) return false;
     }
-
     // Все проверки пройдены - строка является числом
     return true;
 }
 
-void my_msg() {
+int my_msg() {
-    printf("begin my_msg"); // debug
+    // Инициализация локальных переменных для работы с CURL
 
-    // Объявление
-    struct curl_slist* headers;     // Заголовки HTTP-запроса
     CURL* curl;                     // Указатель на CURL-объект
     std::string escaped_msg;        // Экранированное сообщение для JSON
+    std::cout << msg << std::endl;  // Вывод сообщения в консоль (для отладки)
     std::string chat_id_field;      // Поле chat_id для JSON
     std::string json_data;          // Итоговый JSON для отправки
+    struct curl_slist* headers;     // Заголовки HTTP-запроса
+    headers = nullptr;              // Инициализация заголовков
     long http_code;                 // HTTP-код ответа
     CURLcode res;                   // Код результата CURL-операции
 
-    // Инициализация
-    headers = curl_slist_append(nullptr, "Content-Type: application/json"); // Установка заголовка Content-Type
-    curl = curl_easy_init(); // Инициализация CURL
-    escaped_msg = escape_json(msg); // Экранирование спецсимволов в сообщении для JSON
-    chat_id_field = is_numeric(telegram_id) ? "\"chat_id\": " + telegram_id : "\"chat_id\": \"" + telegram_id + "\"";
-    json_data = "{" + chat_id_field + ", \"text\": \"" + escaped_msg + "\"}"; // Сборка JSON-запроса
-    http_code = 0;
-    res = nullptr;
-    
     // Проверка наличия обязательных параметров Telegram
-    if (telegram_token.empty() || telegram_id.empty())
+    if (telegram_token.empty() || telegram_id.empty()) {
-    {
+        return 0; // Интеграция с Telegram не настроена (отсутствует токен или ID)
-        status = 0; // Интеграция с Telegram не настроена (отсутствует токен или ID)
     }
 
-    if (!curl)
+    // Инициализация CURL
-    {
+    curl = curl_easy_init();
-        status = 6; // Ошибка инициализации CURL
+    if (!curl) return 6; // Ошибка инициализации CURL
+
+    // Экранирование спецсимволов в сообщении для JSON
+    escaped_msg = escape_json(msg);
+    
+    // Формирование поля chat_id в зависимости от типа ID (число или строка)
+    if (is_numeric(telegram_id)) {
+        chat_id_field = "\"chat_id\": " + telegram_id;  // Числовой ID
+    } else {
+        chat_id_field = "\"chat_id\": \"" + telegram_id + "\"";  // Строковый ID
     }
     
+    // Сборка JSON-запроса
+    json_data = "{" + chat_id_field + ", \"text\": \"" + escaped_msg + "\"}";
+    // Установка заголовка Content-Type
+    headers = curl_slist_append(headers, "Content-Type: application/json");
+
     // Настройка параметров CURL-запроса
     curl_easy_setopt(curl, CURLOPT_URL, ("https://api.telegram.org/bot" + telegram_token + "/sendMessage").c_str()); // URL API Telegram
     curl_easy_setopt(curl, CURLOPT_POST, 1L);                      // Использовать POST-метод
@@ -299,17 +277,15 @@ void my_msg() {
     curl_easy_setopt(curl, CURLOPT_USERAGENT, "libcurl/7.68.0");   // User-Agent
     
     // Игнорирование вывода ответа (пустая функция обратного вызова)
-    curl_easy_setopt(
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, [](void*, size_t size, size_t nmemb, void*) -> size_t {
-        curl, CURLOPT_WRITEFUNCTION,
-        [](void*, size_t size, size_t nmemb, void*) -> size_t {
         return size * nmemb;
-        }
+    });
-    );
 
     // Выполнение HTTP-запроса
     res = curl_easy_perform(curl);
 
     // Получение HTTP-кода ответа
+    http_code = 0;
     curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
 
     // Освобождение ресурсов
@@ -317,80 +293,57 @@ void my_msg() {
     curl_easy_cleanup(curl);       // Завершение работы CURL
 
     // Обработка ошибок CURL
-    if (res != CURLE_OK)
+    if (res != CURLE_OK) return 5; // Ошибка выполнения запроса
-    {
-        status =  5; // Ошибка выполнения запроса
-    }
     
     // Обработка HTTP-кодов ответа
-    switch (http_code)
+    switch (http_code) {
-    {
+        case 200: return 0; // Успешный запрос
-        case 200:
+        case 401: return 1; // Ошибка авторизации (неверный токен)
-            status =  0; // Успешный запрос
+        case 400: return 2; // Неверный запрос
-        case 401:
+        case 404: return 3; // Ресурс не найден
-            status =  1; // Ошибка авторизации (неверный токен)
+        default:  
-        case 400:
+            if (http_code >= 500) return 4; // Ошибка сервера
-            status =  2; // Неверный запрос
+            return 4;                       // Прочие ошибки
-        case 404:
-            status =  3; // Ресурс не найден
-        case 500:  
-            status =  4; // Ошибка сервера
     }
-
-    printf("end my_msg"); // debug
 }
 
-void my_log()
+int my_log()
 {
     // Данная функция записывает в файл лога сообщение
-    printf("start my_log"); // debug
+    return 0;
-    printf("end my_log"); // debug
 }
 
 void my_fin()
 {
-    // Данная процедура завершает программу и рассчитывает итоговое время выполнения программы
+    // Данная функция завершает программу и рассчитывает итоговое время выполнения программы 
 
-    // Объявления
+    // Фиксируем время окончания работы программы
-    time_t end_time_t;                      // Время завершения выполненя программы
+    auto end_timestamp = std::chrono::system_clock::now();
-    std::chrono::duration duration;         // Длительность выполнения программы
+    // Преобразуем время окончания в time_t и миллисекунды
-    std::chrono::hours hours;               // Компонента часов времени завершения
+    auto end_time_t = std::chrono::system_clock::to_time_t(end_timestamp);
-    std::chrono::minutes minutes;           // Компонента минут времени завершения
+    auto end_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end_timestamp.time_since_epoch()) % 1000;
-    std::chrono::seconds seconds;           // Компонента секунд времени завершения
-    std::chrono::milliseconds milliseconds; // Компонента миллисекунд времени завершения
 
-    // Иницаализация
+    // Вычисляем продолжительность работы программы
-    end_time_t = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
+    auto duration = end_timestamp - start_timestamp;
-    duration = end_timestamp - start_timestamp; // Вычисляем продолжительность работы программы
+    // Разбиваем продолжительность на компоненты
-    hours = std::chrono::duration_cast<std::chrono::hours>(duration); // Разбиваем продолжительность на компоненты
+    auto hours = std::chrono::duration_cast<std::chrono::hours>(duration);
-    minutes = std::chrono::duration_cast<std::chrono::minutes>(duration % std::chrono::hours(1)); // Разбиваем продолжительность на компоненты
+    auto minutes = std::chrono::duration_cast<std::chrono::minutes>(duration % std::chrono::hours(1));
-    seconds = std::chrono::duration_cast<std::chrono::seconds>(duration % std::chrono::minutes(1)); // Разбиваем продолжительность на компоненты
+    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration % std::chrono::minutes(1));
-    milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(duration % std::chrono::seconds(1));  // Разбиваем продолжительность на компоненты
+    auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(duration % std::chrono::seconds(1));
-    double total_seconds
 
-    printf("begin my_diag\n"); // debug
+    // Выводим информацию о времени работы
-
+    std::cout << "Worked for ";
-    std::cout << "Worked for "; // Выводим информацию о времени работы
     // Для коротких периодов (<2 минут) выводим в секундах с дробной частью
-    if (duration < std::chrono::minutes(2))
+    if (duration < std::chrono::minutes(2)) {
-    {
+        double total_seconds = std::chrono::duration<double>(duration).count();
-        total_seconds = std::chrono::duration<double>(duration).count();
         std::cout << std::fixed << std::setprecision(3) << total_seconds << " seconds";
-    }
+    } else {
-    else
-    {
         // Для длительных периодов выводим в формате ЧЧ:ММ:СС.мс
-        if (hours.count() > 0) // Если программа работала хотя бы один час
+        if (hours.count() > 0) std::cout << hours.count() << "h ";
-        {
+        if (minutes.count() > 0) std::cout << minutes.count() << "m ";
-            std::cout << hours.count() << "h "; // Выводим часы
+        std::cout << seconds.count() << "s " << milliseconds.count() << "ms";
     }
-        if (minutes.count() > 0) // Если программа работала хотя бы одину минуту
+    std::cout << std::endl;
-        {
-            std::cout << minutes.count() << "m "; // Вывовим минуты
-        }
-        std::cout << seconds.count() << "s " << milliseconds.count() << "ms"; // Выводим секунды и миллисекунды
-    }
-    std::cout << std::endl; // После осуществления вывода переходим на новую строку
 
     // Выводим статистику по запросам
     std::cout << "Sent " << (n_ok_requests + n_fail_requests) << " requests (" 
@@ -398,29 +351,21 @@ void my_fin()
 
     // Выводим точное время завершения работы
     std::cout << "DosAtk stopped at " << std::put_time(std::localtime(&end_time_t), "%Y-%m-%d %H:%M:%S")
-              << "." << std::setfill('0') << std::setw(3) << milliseconds.count() << std::endl;
+              << "." << std::setfill('0') << std::setw(3) << end_ms.count() << std::endl;
 
-    // Завершаем программу с кодом состояния
+    // Завершаем программу с кодом 0 (успешное завершение)
-    std::exit(status);
+    std::exit(0);
 }
 
-void my_dns()
+int my_dns()
 {
     // Данная процедура сопостовляет доменное имя с IP 
-    printf("start my_dns"); // debug
+    return 0;
-    printf("end my_dns"); // debug
 }
 
-void my_tcp_syn()
-{
-    // Данная процедура выполняет TCP SYN Flood атаку
-    printf("start my_tcp_syn"); // debug
-    
-    printf("end my_tcp_syn"); // debug
-}
 
 unsigned short checksum(void *data, int len) {
-    /**
+/**
  * Рассчитывает контрольную сумму для пакета (алгоритм RFC 1071)
  * 
  * Параметры:
@@ -461,8 +406,6 @@ void my_tcp_syn() {
     *    -201 - ошибка создания raw-сокета
     *    -202 - ошибка отправки SYN-пакета
     */
-    printf("start my_udp"); // debug
-    
 
     // === Объявление локальных переменных ===
     int sock;           // Основной raw-сокет для отправки пакетов
@@ -562,141 +505,149 @@ void my_tcp_syn() {
     }
 
     close(sock);
-    printf("end my_udp"); // debug
 }
 
-int main(int arg_ctr, char **arg_ptr)
+int my_udp()
 {
-    // Инициализация глобальных переменных
+    // Данная процедура выполняет UDP Flood (port scanning) атаку
-    int argc = arg_ctr;
+    return 2;
-    char **argv = arg_ptr;
+}
-    std::string attack_type = "";
-    std::string domain = "";
-    std::string ip = "";
-    std::string port = "";
-    std::string log_file = "/var/log/DosAtk";
-    std::string telegram_id = "";
-    std::string telegram_token = "";
-    int n_ok_requests = 0;
-    int n_fail_requests = 0;
-    std::chrono::system_clock::time_point start_timestamp = std::chrono::system_clock::now();
-    std::string log_msg = "";
-    std::string fin_msg = "";
-    std::string msg;
-    int status = 0;
 
-    // Тело программы
+int main(int argc, char **argv)
+{
+    // Главная функция программы - точка входа
     
-    // Проверяем параметры командной строки
+    // Объявление переменных для хранения статусов операций
-    my_check_params();
+    int log_status;          // Статус записи в лог
+    int dns_status;         // Статус DNS-разрешения
+    int udp_status;         // Статус UDP-атаки
+    int tcp_syn_status;     // Статус TCP SYN-атаки
+
+    // ====== Инициализация программы ====== //
+    n_ok_requests = 0;      // Счетчик успешных запросов
+    n_fail_requests = 0;    // Счетчик неудачных запросов
+    start_timestamp = std::chrono::system_clock::now(); // Засекаем время начала
+    status = 0; // Статус программы
+
+    // Получаем текущее время в различных форматах
+    time_t now_time_t = std::chrono::system_clock::to_time_t(start_timestamp);
+    std::chrono::milliseconds ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+                start_timestamp.time_since_epoch()) % 1000;
+
+    // Выводим информацию о времени запуска программы
+    printf("Starting DosAtk at %04d-%02d-%02d %02d:%02d:%02d.%03ld\n",
+        std::localtime(&now_time_t)->tm_year + 1900,  // Год (с 1900)
+        std::localtime(&now_time_t)->tm_mon + 1,     // Месяц (0-11)
+        std::localtime(&now_time_t)->tm_mday,        // День месяца
+        std::localtime(&now_time_t)->tm_hour,        // Часы
+        std::localtime(&now_time_t)->tm_min,         // Минуты
+        std::localtime(&now_time_t)->tm_sec,         // Секунды
+        ms.count());                                // Миллисекунды
+
+    // ====== Основная логика программы ====== //
+    // 1. Проверяем параметры командной строки
+    status = my_check_params(argc, argv);
     
     // Обрабатываем результат проверки параметров
     switch (status)
     {
     case 1: // Режим сканирования портов (UDP)
         // Пытаемся разрешить DNS (если указано доменное имя)
-        my_dns();
+        dns_status = my_dns();
         
-        if (status == 0) // Если DNS разрешен успешно
+        if (dns_status == 0) // Если DNS разрешен успешно
         {
             // Запускаем цикл UDP-атаки
-            while (true)
+            while (udp_status = my_udp())
             {
-                my_udp()
+                if (udp_status == 2) // Код завершения атаки
-                if (status == 2) // Код завершения атаки
                 {
                     break;
                 }
-                else if (status < 0) // Обработка ошибок
+                else if (udp_status < 0) // Обработка ошибок
                 {
+                    status = udp_status;
                     my_diag();      // Выводим диагностику
-                    my_log();  // Пытаемся записать в лог
+                    log_status = my_log();    // Пытаемся записать в лог
-                    if (status == 1) // Если записать лог не удалось
+                    if (log_status == 1)      // Если требуется уведомление
                     {
                         my_msg();             // Отправляем сообщение
                     }
                 }
             }
             // Завершающие действия после атаки
-            my_log(); // Логируем завершение
+            log_status = my_log(); // Логируем завершение
             my_msg();              // Отправляем финальное сообщение
             my_fin();              // Корректно завершаем программу
         }
-        else if (status == 1) // Ошибка DNS-разрешения
+        else if (dns_status == 1) // Ошибка DNS-разрешения
         {
             my_diag(); // Выводим ошибку
-            my_log(); // Логируем ошибку
+            log_status = my_log();        // Логируем ошибку
             
-            if (status == 0) // Если лог получилось записать
+            if (log_status == 0) {        // Если не требуется уведомление
-            {
                 my_fin();                 // Просто завершаем программу
             }
-            else if (log_status == 1) // Если лог не удалось записать
+            else if (log_status == 1)     // Если требуется уведомление
             {
                 my_msg();                 // Отправляем сообщение
                 my_fin();                 // Завершаем программу
             }
         }
         break;
+
     case 2: // Режим SYN-флуда (TCP)
-        // Пытаемся разрешить DNS (если указано доменное имя)
+        // Аналогичная логика как для UDP-режима
-        my_dns();
+        dns_status = my_dns();
         
-        if (status == 0) // Если DNS разрешен успешно
+        if (dns_status == 0)
         {
-            // Запускаем цикл UDP-атаки
             while (true)
             {
-                my_tcp_syn()
+                my_tcp_syn();
-                if (status == 2) // Код завершения атаки
+                if (status == 2)
                 {
                     break;
                 }
-                else if (status < 0) // Обработка ошибок
+                else if (status < 0)
                 {
-                    my_diag(); // Выводим диагностику
+                    my_diag();
-                    my_log();  // Пытаемся записать в лог
+                    log_status = my_log();
-                    if (status == 1) // Если записать лог не удалось
+                    if (log_status == 1)
                     {
-                        my_msg(); // Отправляем сообщение
+                        my_msg();
                     }
                 }
             }
-            // Завершающие действия после атаки
+            log_status = my_log();
-            my_log(); // Логируем завершение
+            my_msg();
-            my_msg(); // Отправляем финальное сообщение
+            my_fin();
-            my_fin(); // Корректно завершаем программу
         }
-        else if (status == 1) // Ошибка DNS-разрешения
+        else if (dns_status == 1)
         {
-            my_diag(); // Выводим ошибку
+            my_diag();
-            my_log(); // Логируем ошибку
+            log_status = my_log();
-            
+            if (log_status == 0)
-            if (status == 0) // Если лог получилось записать
             {
-                my_fin(); // Просто завершаем программу
+                my_fin();
             }
-            else if (log_status == 1) // Если лог не удалось записать
+            else if (log_status == 1)
             {
-                my_msg(); // Отправляем сообщение
+                my_msg();
-                my_fin(); // Завершаем программу
+                my_fin();
             }
         }
         break;
-    case 0: // Некорректные параметры или запрос справки
-    case -1:
-    case -10:
-    case -20:
-    case -101:
-    case -600:
-        my_diag(); // Выводим диагностику
-        my_log(); // Логируем событие
 
-        if (status == 0) // Без уведомления
+    default: // Некорректные параметры или запрос справки
+        my_diag(); // Выводим диагностику
+        log_status = my_log();        // Логируем событие
+        
+        if (log_status == 0)          // Без уведомления
         {
             my_fin();                 // Завершаем программу
         }
-        else if (status == 1) // С уведомлением
+        else if (log_status == 1)     // С уведомлением
         {
             my_msg();                 // Отправляем сообщение
             my_fin();                 // Завершаем программу