завел .gitignore

.gitignore

@@ -0,0 +1,38 @@
+# Игнорировать бинарные файлы
+*.exe
+*.out
+*.app
+*.o
+*.a
+*.so
+*.dll
+*.dylib
+
+# Игнорировать папку .vscode
+.vscode/
+
+# Игнорировать сгенерированные файлы
+build/
+bin/
+obj/
+
+# Игнорировать системные файлы
+.DS_Store
+Thumbs.db
+
+# Игнорировать файлы проекта IDE
+*.sln
+*.vcxproj
+*.vcxproj.filters
+*.vcxproj.user
+
+# Игнорировать временные файлы
+*.swp
+*.swo
+*~
+*.bak
+
+# Игнорировать логи и результаты тестов
+*.log
+*.tmp
+test-results/

.vscode/settings.json

@@ -0,0 +1,67 @@
+{
+    "files.associations": {
+        "algorithm": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "cctype": "cpp",
+        "charconv": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "exception": "cpp",
+        "format": "cpp",
+        "forward_list": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "ios": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "iterator": "cpp",
+        "limits": "cpp",
+        "locale": "cpp",
+        "map": "cpp",
+        "memory": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "optional": "cpp",
+        "ostream": "cpp",
+        "ratio": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "stop_token": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "system_error": "cpp",
+        "thread": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp",
+        "utility": "cpp",
+        "vector": "cpp",
+        "xfacet": "cpp",
+        "xiosbase": "cpp",
+        "xlocale": "cpp",
+        "xlocbuf": "cpp",
+        "xlocinfo": "cpp",
+        "xlocmes": "cpp",
+        "xlocmon": "cpp",
+        "xlocnum": "cpp",
+        "xloctime": "cpp",
+        "xmemory": "cpp",
+        "xstddef": "cpp",
+        "xstring": "cpp",
+        "xtr1common": "cpp",
+        "xtree": "cpp",
+        "xutility": "cpp"
+    }
+}

src/Makefile

@@ -1,14 +1,13 @@
 CXX = g++
 CXXFLAGS = -Iinclude/
 
-all: dos
+all: my_app
 
-# Сюда дописывать файлики для компиляции
+my_app:
-dos:
+	$(CXX) $(CXXFLAGS) ./my_start.cpp ./my_fin.cpp ./main.cpp -o my_app
-	$(CXX) $(CXXFLAGS) ./main.cpp ./my_check_params.cpp -o dos
 
 rebuild:
-	rm -f ./dos && make dos
+	rm -f my_app && make my_app
 
 clean:
-	rm -f ./dos
+	rm -f my_app

src/main.cpp

@@ -1,46 +1,22 @@
-#include "my_check_params.hpp" 
+#include <iostream>
+#include <thread>
+#include <chrono>
+#include "my_start.hpp"
 
-Options opts;
+int main() {
 
-using namespace std;
+    my_start();
 
-// Компиляция из директории вызвать команду make my_app
+    for (int i = 0; i < 5; ++i) {
-// Запуск: ./my_app [флаги и аргументы к ним] (начать можно с флага --help) 
+        std::this_thread::sleep_for(std::chrono::seconds(25));
-int main(int argc, char *argv[]) {
+        if (i % 2 == 0) {
-
+            n_ok_requests++;
-    int error = my_check_params(argc, argv);
+        } else {
-    if (error > 0)
+            n_fail_requests++;
-    {
-        if (opts.attack_type == "flood") {
-            cout << "type attack: " << opts.attack_type << "\n";
-            cout << "domain: " << opts.domain << "\n";
-            cout << "ip: " << opts.ip << "\n";
-            cout << "port: " << opts.port << "\n";
-            cout << "log file path: " << opts.log_file << "\n";
         }
-        else if (opts.attack_type == "scan") {
-            cout << "type attack: " << opts.attack_type << "\n";
-            cout << "domain: " << opts.domain << "\n";
-            cout << "ip: " << opts.ip << "\n";
-            cout << "log file path: " << opts.log_file << "\n";
-        }
-
-        if (!opts.telegram_id.empty()) {
-            cout << "telegram_id: " << opts.telegram_id << "\n";
-        }
-
-        if (!opts.telegram_token.empty()) {
-            cout << "telegram_token: " << opts.telegram_token << "\n";
-        }
-        
-        
-    }
-    else {
-        cout << "err code:" << error << "\n";
     }
 
-    
+    my_fin();
-    
 
     return 0;
 }

src/my_check_params.cpp

@@ -1,117 +0,0 @@
-#include "my_check_params.hpp" 
-
-// Гарантируется наличие минимума нужных аргументов для flood и scan
-// Гарантируется, что после работы парсера мы получим только валидный тип атаки 
-
-// Добавить:
-// 1. Валидацию IP, port
-
-// Статус коды:
-// 2 - Атака флуд, все нужные опции есть
-// 1 - Атака порт скан, все нужные опции есть
-// 0 - нужна помощь
-// -1 - пользователь не ввел тип атаки или ввел неверный тип атаки
-// -10 - Пользователь выбрал тип атаки порт сканнинг, но не ввел нужные параметры
-// -20 - Пользователь выбрал тип атаки флуд, но не ввел нужные параметры
-// -100 - неизвестная ошибка
-// -101 - неизвестная опция или потерян аргумент, следует предложить вызвать флаг помощи
-// -600 -  пользователь ввел токен, но не id или наоборот
-// Какие-то еще коды?
-int my_check_params(int argc, char** argv) {
-
-    int status = -100;
-    // Короткие опции (с двоеточием для параметров)
-    const char* short_options = "a:d:i:p:l:t:b:h";
-    
-    // Длинные опции
-    const struct option long_options[] = {
-        {"attack",    required_argument, NULL, 'a'},
-        {"domain",    required_argument, NULL, 'd'},
-        {"ip",        required_argument, NULL, 'i'},
-        {"port",      required_argument, NULL, 'p'},
-        {"log",       required_argument, NULL, 'l'},
-        {"telegram",  required_argument, NULL, 't'},
-        {"token",     required_argument, NULL, 'b'},
-        {"help",      no_argument,       NULL, 'h'},
-        {NULL,     0,                 NULL,  0}
-    };
-
-    int opt;
-    while ((opt = getopt_long(argc, argv, short_options, long_options, NULL)) != -1) {
-        switch (opt) {
-            case 'a':
-                opts.attack_type = optarg;
-                break;
-            case 'd':
-                opts.domain = optarg;
-                break;
-            case 'i':
-                opts.ip = optarg;
-                break;
-            case 'p':
-                opts.port = optarg;
-                break;
-            case 'l':
-                opts.log_file = optarg;
-                break;
-            case 't':
-                opts.telegram_id = optarg;
-                break;
-            case 'b':
-                opts.telegram_token = optarg;
-                break;
-            case 'h':
-                // std::cout << "Usage: " << argv[0] << " [options]\n"
-                //           << "Required:\n"
-                //           << "  -a, --attack TYPE    Type of attack (scan|flood)\n"
-                //           << "  -d, --domain DOMAIN  Target domain\n"
-                //           << "  -i, --ip IP          Target IP\n"
-                //           << "  -p, --port PORT      Port. Required only for flood type!\n"
-                //           << "Optional:\n"
-                //           << "  -l, --log FILE       Log file\n"
-                //           << "  -t, --telegram ID    Telegram ID\n"
-                //           << "  -b, --token TOKEN    Telegram bot token\n";
-                status = 0;
-                break;
-            case '?':
-                // std::cerr << "Unknown option!\n.--help for info\n";
-                status = -101;
-                break;
-            default:
-                status = -100;
-                break;
-        }
-    }
-
-    // Проверка обязательных параметров
-    
-    if (status != 0 && status != -101)
-    {
-        if (opts.attack_type != "flood" && opts.attack_type != "scan") {
-            // std::cerr << "Error: Missing required parameters!\n--help for more info\n";
-            status = -1;
-        }
-        else if (opts.attack_type == "scan" && (opts.domain.empty() || opts.ip.empty())) {
-            // std::cerr << "Error: Missing required parameters!\n--help for more info\n";
-            status = -10;
-        }
-        else if (opts.attack_type == "flood" && (opts.domain.empty() || opts.ip.empty() || opts.port.empty())) {
-            // std::cerr << "Error: Missing required parameters!\n--help for more info\n";
-            status = -20;
-        }
-        else if ((!opts.telegram_id.empty() && opts.telegram_token.empty()) || (opts.telegram_id.empty() && !opts.telegram_token.empty())) {
-            status = -600;
-        }
-        else if (opts.attack_type == "scan" && !opts.domain.empty() && !opts.ip.empty()) {
-            // std::cerr << "Error: Missing required parameters!\n--help for more info\n";
-            status = 1;
-        }
-        else if (opts.attack_type == "flood" && !opts.domain.empty() && !opts.ip.empty() && !opts.port.empty()) {
-            // std::cerr << "Error: Missing required parameters!\n--help for more info\n";
-            status = 2;
-        }
-        // Какие-то еще коды?
-    }
-
-    return status;
-}

src/my_check_params.hpp

@@ -1,22 +0,0 @@
-#pragma once
-
-#include <iostream>
-#include <string>
-#include <unistd.h>
-#include <getopt.h> // Для struct option
-
-
-struct Options {
-    std::string attack_type;                   // Обязательный параметр
-    std::string domain;                        // Обязательный параметр
-    std::string ip;                            // Обязательный параметр
-    std::string port;                          // Обязательный параметр (не обязательный для скана)
-    std::string log_file = "/var/logs/DosAtk"; // Значение по умолчанию, не обязательный
-    std::string telegram_id;                   // Не обязательный параметр
-    std::string telegram_token;                // Не обязательный параметр
-};
-
-extern Options opts; // Теперь это глобальная переменная, где она должна определяться?
-
-// Прототип функции парсинга
-int my_check_params(int argc, char** argv);

src/my_fin.cpp

@@ -0,0 +1,34 @@
+#include "my_start.hpp"
+#include <cstdlib>
+
+void my_fin() {
+
+    auto end_timestamp = std::chrono::system_clock::now();
+    auto end_time_t = std::chrono::system_clock::to_time_t(end_timestamp);
+    auto end_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end_timestamp.time_since_epoch()) % 1000;
+
+    auto duration = end_timestamp - start_timestamp;
+    auto hours = std::chrono::duration_cast<std::chrono::hours>(duration);
+    auto minutes = std::chrono::duration_cast<std::chrono::minutes>(duration % std::chrono::hours(1));
+    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration % std::chrono::minutes(1));
+    auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(duration % std::chrono::seconds(1));
+
+    std::cout << "Worked for ";
+    if (duration < std::chrono::minutes(2)) {
+        double total_seconds = std::chrono::duration<double>(duration).count();
+        std::cout << std::fixed << std::setprecision(3) << total_seconds << " seconds";
+    } else {
+        if (hours.count() > 0) std::cout << hours.count() << "h ";
+        if (minutes.count() > 0) 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 (" 
+              << n_ok_requests << " ok, " << n_fail_requests << " failed)" << std::endl;
+
+    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) << end_ms.count() << std::endl;
+
+    std::exit(0);
+}

src/my_start.cpp

@@ -0,0 +1,18 @@
+#include "my_start.hpp"
+
+int n_ok_requests = 0;
+int n_fail_requests = 0;
+std::chrono::system_clock::time_point start_timestamp;
+
+void my_start() {
+    n_ok_requests = 0;
+    n_fail_requests = 0;
+    start_timestamp = std::chrono::system_clock::now();
+
+    auto now = std::chrono::system_clock::now();
+    auto now_time_t = std::chrono::system_clock::to_time_t(now);
+    auto now_ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()) % 1000;
+
+    std::cout << "Starting DosAtk at " << std::put_time(std::localtime(&now_time_t), "%Y-%m-%d %H:%M:%S")
+    << "." << std::setfill('0') << std::setw(3) << now_ms.count() << std::endl;
+}

src/my_start.hpp

@@ -0,0 +1,11 @@
+#include <iostream>
+#include <chrono>
+#include <iomanip>
+#include <ctime>
+
+void my_start();
+void my_fin();
+
+extern int n_ok_requests;
+extern int n_fail_requests;
+extern std::chrono::system_clock::time_point start_timestamp;