#include <arpa/inet.h>

int inet_pton(int af, const char *src, void *dst);

#include <stdio.h>
#include <stdlib.h>
#include <arpa/inet.h>

int main() {
  struct in_addr ip_bin;
  int result = inet_pton(AF_INET, "192.168.1.1", &ip_bin.s_addr);
    
  if(result > 0) {
    printf("Преобразование прошло успешно.\n");
  } else if(result == 0) {
    fprintf(stderr, "Адрес неверен.\n");
  } else {
    perror("Ошибка:");
  }

  return EXIT_SUCCESS;
}

#include <arpa/inet.h>

unsigned long inet_addr(const char *cp);

#include <stdio.h>
#include <arpa/inet.h>

int main() {
  unsigned long addr = inet_addr("192.168.1.1"); // Конвертируем строку в числовой IP-адрес

  if(addr != INADDR_NONE) { // Проверяем успешность конвертации
    printf("IP-адрес: %lu\n", addr); // Выведем полученный IP-адрес
  } else {
    printf("Некорректный IP-адрес!\n");
  }

  return 0;
}

#include <stdio.h>
#include <arpa/inet.h> // здесь объявлена htons()

int main() {
  unsigned short host_number = 12345;
    
  // Преобразование числа в сетевой порядок байтов
  unsigned short network_number = htons(host_number);
    
  printf("Хостовое представление: %hu\n", host_number);      // Выведет исходное число
  printf("Сетевое представление: %hu\n", network_number);   // Выведет число в сетевом порядке байтов
    
  return 0;
}

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>

// Создание сокета
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
  perror("Ошибка при создании сокета");

struct sockaddr_in {
  sa_family_t sin_family; /* AF_INET */
  in_port_t sin_port;     /* номер порта */
  struct in_addr sin_addr;/* IP-адрес */
};

#include <arpa/inet.h>

char ip_str[] = "192.168.1.1";
struct in_addr addr;

if (inet_pton(AF_INET, ip_str, &addr)) {
  printf("IP успешно преобразован!\n");
}

int sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sockfd < 0) {
  perror("Ошибка при открытии сокета");
  exit(EXIT_FAILURE);
}

int server_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (server_fd < 0) {
  perror("Ошибка при создании сокета");
  exit(EXIT_FAILURE);
}

struct sockaddr_in serv_addr;
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(PORT_NUMBER);

if (bind(server_fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr))) {
  perror("Ошибка при привязке адреса");
  close(server_fd);
  exit(EXIT_FAILURE);
}

if (listen(server_fd, MAX_QUEUE_SIZE)) {
  perror("Ошибка при установке слушающего состояния");
  close(server_fd);
  exit(EXIT_FAILURE);
}

ssize_t bytes_sent = send(sockfd, buffer, len, flags);
if (bytes_sent != len) {
  perror("Ошибка отправки данных");
}

ssize_t bytes_received = recv(sockfd, buffer, BUFLEN, 0);
if (bytes_received <= 0) {
  if (bytes_received == 0) {
    fprintf(stderr, "Клиент отключился.\n");
  } else {
    perror("Ошибка приёма данных");
  }
}

#include <boost/asio.hpp>
#include <iostream>

using boost::asio::ip::tcp;

void handle_connection(boost::asio::io_context& io_ctx, tcp::socket&& sock) {
  try {
    char data[1024];
    size_t len = sock.read_some(boost::asio::buffer(data));
    std::cout.write(data, len);
    sock.write_some(boost::asio::buffer(data, len));
  } catch(std::exception& e) {
    std::cerr << "Исключение: " << e.what() << "\n";
  }
}

int main() {
  try {
    boost::asio::io_context io_ctx;
    tcp::acceptor acceptor(io_ctx, tcp::endpoint(tcp::v4(), PORT_NUMBER));
        
    for (;;) {
      tcp::socket sock(io_ctx);
      acceptor.accept(sock);
      std::thread(handle_connection, std::ref(io_ctx), std::move(sock)).detach();
    }
  } catch(const std::exception& ex) {
    std::cerr << "Ошибка: " << ex.what() << '\n';
  }

  return 0;
}

#include <sys/socket.h>

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

struct sockaddr_in {
  sa_family_t sin_family;       // Семейство адресов (AF_INET)
  uint16_t sin_port;           // Номер порта
  struct in_addr sin_addr;     // Адрес IP
};

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <errno.h>

#define SERVER_IP "74.125.239.113"
#define SERVER_PORT 80

int main(void) {
  int sockfd;
  struct sockaddr_in serv_addr;

  // Создаем сокет
  sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if (sockfd < 0) {
    perror("Ошибка при создании сокета");
    exit(EXIT_FAILURE);
  }

  memset(&serv_addr, 0, sizeof(serv_addr));          // Обнуляем структуру
  serv_addr.sin_family = AF_INET;                     // Используем семейство IPv4
  serv_addr.sin_port = htons(SERVER_PORT);           // Устанавливаем порт (преобразуя в сетевой порядок)
  inet_pton(AF_INET, SERVER_IP, &(serv_addr.sin_addr)); // Конвертируем IP-адрес в двоичный формат

  // Подключаемся к серверу
  if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
    perror("Ошибка подключения к серверу");
    close(sockfd);
    exit(EXIT_FAILURE);
  }

  printf("Подключение установлено!\n");

  // Теперь можно отправлять запросы и получать ответы...

  close(sockfd);
  return 0;
}

#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>

int getaddrinfo(
  const char* node,               // Имя узла (IP или DNS)
  const char* service,            // Порт или сервис
  const struct addrinfo* hints,   // Дополнительные опции
  struct addrinfo** res           // Результат (список адресов)
);

#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int tcp_connect(const char* hostname, const char* port) {
  struct addrinfo hints, *result, *rp;
  int sfd, errcode;

  memset(&hints, 0, sizeof(hints));
  hints.ai_family = AF_UNSPEC;    // Разрешить оба семейства (IPv4 и IPv6)
  hints.ai_socktype = SOCK_STREAM;// Тип сокета TCP
  hints.ai_protocol = IPPROTO_TCP;// Протокол TCP

  // Получаем список возможных адресов
  errcode = getaddrinfo(hostname, port, &hints, &result);
  if (errcode != 0) {
    fprintf(stderr, "Ошибка getaddrinfo(): %s\n", gai_strerror(errcode));
    return -1;
  }

  // Пробуем каждый полученный адрес
  for (rp = result; rp != NULL; rp = rp->ai_next) {
    // Создаем сокет
    sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
    if (sfd == -1) continue; // Перейти к следующему адресу

    // Подключаемся к выбранному адресу
    if (connect(sfd, rp->ai_addr, rp->ai_addrlen) != -1) break; // Успешное подключение!

    close(sfd); // Неудача с данным адресом, закрываем сокет
  }

  freeaddrinfo(result); // Освобождаем память

  if (rp == NULL) { // Ни один адрес не подошел
    fprintf(stderr, "Не удалось подключиться ни к одному адресу\n");
    return -1;
  }

  return sfd; // Вернуть дескриптор сокета
}

#include <boost/asio.hpp>

int main() {
  try {
    boost::asio::ip::tcp::socket socket(io_service);
    boost::asio::connect(socket, endpoint_iterator);
    boost::asio::write(socket, boost::asio::buffer("GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n"));
    boost::asio::read_until(socket, response_buffer, "\r\n");
  } catch (std::exception& e) {
    std::cerr << "Exception: " << e.what() << "\n";
  }
}

#include <Poco/Net/HTTPServer.h>

void requestHandler(const HTTPRequest&, HTTPResponse&) {...}

int main() {
  HTTPServer srv(new RequestHandlerFactory(), 8080);
  srv.start();
}

QTcpSocket socket;
connect(&socket, SIGNAL(connected()), SLOT(onConnected()));
socket.connectToHost("example.com", 80);

#include <iostream>

int main() {
  while(std::cin.peek() == ' ') { // пока впереди пробельный символ
    std::cin.ignore(); // пропускаем его
  }

  // теперь считываем первый непробельный символ
  char firstNonSpace;
  std::cin.get(firstNonSpace);

  std::cout << "Первый непробельный символ: " << firstNonSpace << std::endl;

  return 0;
}

#include <fstream>
#include <iostream>

int main() {
  std::ifstream file("example.txt");

  if (!file.is_open()) {
    std::cerr << "Ошибка открытия файла." << std::endl;
    return 1;
  }

  while(file.peek() != EOF) { // пока не конец файла
    char current_char;
    file.get(current_char); // берем очередной символ
    std::cout << current_char;
  }

  file.close();
  return 0;
}

#include <cstddef> // std::ptrdiff_t

int arr[] = {1, 2, 3};
auto diff = &arr[2] - &arr[0]; // Результат имеет тип ptrdiff_t

#include <cstddef> // std::size_t

char str[] = "Привет";
size_t len = strlen(str); // Результат имеет тип size_t

#include <cinttypes> // std::intptr_t

void* ptr = malloc(10);
intptr_t ip = reinterpret_cast<intptr_t>(ptr); // Преобразование указателя в целое число
free(reinterpret_cast<void*>(ip)); // Обратное преобразование назад в указатель

#include <cinttypes> // std::uintptr_t

void* data = new char[10];
uintptr_t addr = reinterpret_cast<uintptr_t>(data); // Сохранение адреса в беззнаковом целом числе
delete [] reinterpret_cast<char*>(addr); // Обратное преобразование

#include <iostream>
#include <string>
#include <regex>

bool isValidIPv4(const std::string& ip) {
  // Регулярное выражение для валидной строки IPv4 адреса:
  std::regex ipv4_regex(R"(^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$)");
    
  return std::regex_match(ip, ipv4_regex);
}

int main() {
  std::string test_ip = "192.168.1.1";
  if(isValidIPv4(test_ip))
    std::cout << "IP-адрес корректен." << std::endl;
  else
    std::cout << "IP-адрес некорректен." << std::endl;

  return 0;
}

int main(int argc, char** argv):
// и далеее
int main(int argc, char** argv) {
  //Тело функции main
  return 0;
}

#include <stdio.h>

int main(int argc, char** argv) {
  int returnValue;
  if (argc == 2) {
    sscanf(argv[1], "%d", &returnValue);
  }
  if (returnValue == 0) {
    return returnValue;
  }
  --returnValue;
  argv[1][0] = '0' + returnValue;
  printf("argv[1] = %s, returnValue = %d\n", argv[1], returnValue);
  return main(argc, argv);
}

compukter@barracol:~/Programs/C/edu_task$ ./a.out 9
argv[1] = 8, returnValue = 8
argv[1] = 7, returnValue = 7
argv[1] = 6, returnValue = 6
argv[1] = 5, returnValue = 5
argv[1] = 4, returnValue = 4
argv[1] = 3, returnValue = 3
argv[1] = 2, returnValue = 2
argv[1] = 1, returnValue = 1
argv[1] = 0, returnValue = 0

sudo apt-get install libcurl4-openssl-dev

// Подключение библиотеки:
#include <curl/curl.h>
   
/* Инициализация и выполнение простого GET-запроса*/
CURL* curl = curl_easy_init();
if (curl) {
  curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
  res = curl_easy_perform(curl); // Выполняем запрос
  curl_easy_cleanup(curl);       // Освобождаем ресурсы
}

#include <openssl/ssl.h>

void init_openssl() {
  SSL_library_init();
}

#include <openssl/opensslv.h> /* OPENSSL_VERSION_NUMBER */
#include <openssl/ssl.h>

#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
#define USE_OPENSSL_INIT_API
#endif

#ifdef USE_OPENSSL_INIT_API
void init_openssl() {
  OPENSSL_init_ssl(0, NULL);
}
#else
void init_openssl() {
  SSL_library_init();
}
#endif

#include <openssl/err.h>

void load_errors() {
  SSL_load_error_strings();
}

#include <openssl/err.h>

void load_errors() {
  ERR_load_crypto_strings();
}

#include <openssl/opensslv.h> /* OPENSSL_VERSION_NUMBER */
#include <openssl/ssl.h>

#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
#define USE_OPENSSL_INIT_API
#endif

#ifdef USE_OPENSSL_INIT_API
void load_errors() {
  OPENSSL_init_ssl(0, NULL);
}
#else
void load_errors() {
  SSL_load_error_strings();
}
#endif

#include <curl/curl.h>

int main(void) {
  CURL *curl_handle = curl_easy_init();
  if (!curl_handle) {
    fprintf(stderr, "Ошибка инициализации cURL.\n");
    return 1;
  }

  // Далее можно настроить опции, такие как URL, HTTP-метод и др.
  curl_easy_setopt(curl_handle, CURLOPT_URL, "http://example.com");

  // Отправляем запрос
  CURLcode result = curl_easy_perform(curl_handle);

  // Очищаем ресурсы
  curl_easy_cleanup(curl_handle);

  return 0;
}