vless://9b6d037b-14e5-4469-b48f-eeb10cfcc6c0@wl-ru-1.midiopenners.ru:441?type=xhttp&host=eh.vk.com&path=/&mode=auto&security=reality&fp=chrome&sni=eh.vk.com&pbk=YnG1LDJQElY4N4O2n0VIJfj2qPZkgOBjYPQd0TZIRC4&sid=a1b2c1d3#%F0%9F%87%AB%F0%9F%87%AE%5B1%5D%F0%9F%8F%B3%EF%B8%8F%20%D0%A4%D0%B8%D0%BD%D0%BB%D1%8F%D0%BD%D0%B4%D0%B8%D1%8F%20%7C%20%D0%9C%D0%BE%D0%B1%D0%B8%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9%20(xhttp)

#pragma once
#include <iostream>
#include <vector>
#include <cstring>
#define _WINSOCK_DEPRECATED_NO_WARNINGS
#include <WinSock2.h>
#include <thread>
#include <format>
#include <atomic>
#include "io.hpp" // если используете C++23 то отключите просто у меня свой print
#include <mutex>
#include <chrono>
#include "hostname.hpp"
#pragma comment(lib,"ws2_32.lib")
std::mutex net_mt;
struct net {
    const char* target_ip = "142.251.1.102";
    int target_port = 443;                   
    size_t PACKET_SIZE = 64;
    SOCKET sock = INVALID_SOCKET;          
    sockaddr_in addr;
    int64_t max_iteration = 10;
    int success = 0, fall = 0, max_packets = 0;
    bool bMultiThread = false;
    std::string out_ping_str = "";
    int64_t i64MaxThreads = std::jthread::hardware_concurrency();
    net() {
        WSADATA wsaData;
        if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
            print(" WSAStartup failed\n");
        }
    }

    void sendDeep() {
        setlocale(LC_ALL, "rus");
        success = 0; fall = 0;
        sock = socket(AF_INET, SOCK_STREAM, 0);
        if (sock == INVALID_SOCKET) {
            print(" Socket creation failed\n");
            return;
        }
        else {
            print(" socket created\n");
        }

        addr.sin_family = AF_INET;
        addr.sin_port = htons(target_port);
        addr.sin_addr.s_addr = inet_addr(target_ip);

        print(" Connecting to [{}]...\n", target_ip);

        
        if (connect(sock, (struct sockaddr*)&addr, sizeof(addr)) == 0) {
            std::vector<char> buf(PACKET_SIZE, 'X');
            for (int64_t count = 0; count < max_iteration; count++) {
                SOCKET s = socket(AF_INET, SOCK_STREAM, 0);
                auto in_ping = std::chrono::high_resolution_clock::now();
                if (connect(s, (struct sockaddr*)&addr, sizeof(addr)) == 0) {
                    int sentBytes = send(s, buf.data(), (int)buf.size(), 0);

                    auto out_ping = std::chrono::high_resolution_clock::now();
                    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(out_ping - in_ping).count();
                    print(" {} [{}] Отправлен пакет: {} ms\n", count, target_ip, duration);
                    success++;
                    closesocket(s);
                }
                else {
                    print(" {} [{}] Ошибка подключения\n", count, target_ip);
                    fall++;
                    closesocket(s);
                }
            }
            print(" [{}] Сводка: Отправлено {}/{} ping : {}\n", target_ip, success, max_iteration, out_ping_str);
            closesocket(sock);
        }
        else {
            int err = WSAGetLastError();
            print(" [{}:{}] Connection Error! Code: {}\n", target_ip, target_port, err);
            std::cout << " Пока не поддерживаем пинг по URL но вот айпи вот айпи ниже";
            print("({}) ->( {} )", target_ip, getIPFromUrl(target_ip));
        }

    }
    ~net() {
        WSACleanup();
        print(" WSACleanup()\n");
    }
};

#include "ping.hpp"
struct PING_DATA {
  std::string usage_string = R"(
    Ошибка команды!
    Использование:
    ping.exe <флаг> <ip или url> <порт> <размер пакета> <количество пакетов>
    -----------------------------------------------------------------
    
    Пример:
    ping.exe -host "http://google.com" 80 64 4
            | 0   ||        1        || 2| 3|4|
    0 - Флаг (-ip - для теста по IP , -host - для теста по url
    1 - Адрес
    2 - Порт
    3 - размер пакета
    4 - количество пакетов
    -------------------------------------------------------------------
    created by HCPP20334 | Writtein C++20 Win10SDK
    )";
};
std::unique_ptr<PING_DATA> ping = std::make_unique<PING_DATA>();
std::unique_ptr<net>net_ptr = std::make_unique<net>();
std::string hostname_and_ip_str,flag_ping_to;
int main(int argc, char** argv) {
    setlocale(LC_ALL, "rus");
  if (argc < 2) {
    std::cout << ping->usage_string;
    }
    else {
        
       // flag_ping_to = std::string(reinterpret_cast<const char*>((argv[2])));
        print("ping by HCPP20334 | Writtein to C++20\n----------------------\n IP:{} | PORT:{} | MAX_ITERATION:{} | PACKET_SIZE:{}\n", (const char*)argv[1], std::stoi(argv[2]), std::stoi(argv[4]), std::stoll(argv[3]));
        hostname_and_ip_str = std::string(reinterpret_cast<const char*>((argv[1])));
        net_ptr->target_ip = hostname_and_ip_str.c_str();
        net_ptr->target_port = (std::stoi(argv[2]));
        net_ptr->PACKET_SIZE = (std::stoll(argv[3]));
        net_ptr->max_iteration = (std::stoi(argv[4]));
        net_ptr->sendDeep();
    }
}

#pragma once
#include <iostream>
#include <string>
#include <stdint.h>
#include <memory>
#include "net.hpp"

ВОТ свой принт

std::mutex deepPayloadMt;
std::string print_data;
template <class... Tm>
void print(const std::format_string<Tm...> _Fmt, Tm&&... _Args) {
    std::lock_guard<std::mutex> lock(deepPayloadMt);
    std::string_view out_buffer = _STD vformat(_Fmt.get(), _STD make_format_args(_Args...));
    std::cout << out_buffer.data();
}

// default string
std::string raw_string = R"( 
Hello World
Hello World
string
 )";
// wide string
std::wstring raw_wstring = LR"( 
Hello World
Hello World
wstring
 )";

std::wstring wdata = std::wstring(sdata.begin(),sdata.end());

const std::string_view tx = "0. Text\n"
                                                    "1. Text\n"
                                                    "2. Text\n"
                                                    "3. Text\n"
                                                    "4. Text\n";
int count = 0;
for(auto c : tx){
if(c == '\n'){count++;}
}
std::print("tx-size:{}, new_line:{}",tx.size(),count);