Simple HTTP Proxy on C++, python, Golang, Julia

Boost_HTTP_proxy.cpp

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

// Функция для обработки HTTP запроса и отправки его на сервер
void handleRequest(boost::asio::ip::tcp::socket& clientSocket, const std::string& serverHost, const std::string& serverPort) {
    // Создание объекта io_context
    boost::asio::io_context ioContext;

    // Создание объекта resolver для разрешения имени хоста сервера
    boost::asio::ip::tcp::resolver resolver(ioContext);
    boost::asio::ip::tcp::resolver::results_type endpoints = resolver.resolve(serverHost, serverPort);

    // Создание объекта socket для соединения с сервером
    boost::asio::ip::tcp::socket serverSocket(ioContext);

    // Установка соединения с сервером
    boost::asio::connect(serverSocket, endpoints);

    // Чтение HTTP запроса от клиента
    boost::asio::streambuf requestBuf;
    boost::asio::read_until(clientSocket, requestBuf, "\r\n");

    // Отправка HTTP запроса на сервер
    boost::asio::write(serverSocket, requestBuf);

    // Чтение и перенаправление HTTP ответа от сервера клиенту
    boost::asio::streambuf responseBuf;
    boost::asio::read(serverSocket, responseBuf, boost::asio::transfer_all(), boost::asio::error::eof);
    boost::asio::write(clientSocket, responseBuf);
}

// Функция для запуска HTTP прокси
void runProxy(const std::string& listenPort, const std::string& serverHost, const std::string& serverPort) {
    // Создание объекта io_context
    boost::asio::io_context ioContext;

    // Создание объекта acceptor для прослушивания входящих соединений
    boost::asio::ip::tcp::acceptor acceptor(ioContext, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), std::stoi(listenPort)));

    while (true) {
        // Ожидание входящего соединения от клиента
        boost::asio::ip::tcp::socket clientSocket(ioContext);
        acceptor.accept(clientSocket);

        // Обработка HTTP запроса и отправка его на сервер
        handleRequest(clientSocket, serverHost, serverPort);
    }
}

int main() {
    std::string listenPort = "8080";
    std::string serverHost = "example.com";
    std::string serverPort = "80";

    runProxy(listenPort, serverHost, serverPort);

    return 0;
}

HTTP_proxy.go

package main

import (
    "io"
    "log"
    "net"
)

func handleRequest(clientConn net.Conn) {
    defer clientConn.Close()

    // Создание соединения с целевым сервером
    serverConn, err := net.Dial("tcp", "example.com:80")
    if err != nil {
        log.Println("Failed to connect to server:", err)
        return
    }
    defer serverConn.Close()

    // Перенаправление запроса от клиента к целевому серверу
    go func() {
        if _, err := io.Copy(serverConn, clientConn); err != nil {
            log.Println("Failed to copy client request to server:", err)
        }
    }()

    // Перенаправление ответа от целевого сервера клиенту
    if _, err := io.Copy(clientConn, serverConn); err != nil {
        log.Println("Failed to copy server response to client:", err)
    }
}

func main() {
    // Слушаем входящие соединения на порту 8080
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        log.Fatal("Failed to start proxy server:", err)
    }
    defer listener.Close()

    log.Println("Proxy server is running on port 8080")

    for {
        // Принимаем входящее соединение от клиента
        clientConn, err := listener.Accept()
        if err != nil {
            log.Println("Failed to accept client connection:", err)
            continue
        }

        // Обрабатываем запрос от клиента в отдельной горутине
        go handleRequest(clientConn)
    }
}

HTTP_proxy.jl

using Sockets

function handle_request(client::TCPSocket)
    # Чтение данных от клиента
    request_data = read(client, String)

    # Изменение запроса, если необходимо
    # Например, можно изменить хост или порт целевого сервера

    # Установка соединения с целевым сервером
    server = connect(TCP, "example.com", 80)

    # Отправка запроса на целевой сервер
    write(server, request_data)
    flush(server)

    # Чтение данных от целевого сервера
    response_data = read(server, String)

    # Отправка ответа клиенту
    write(client, response_data)
    flush(client)

    # Закрытие соединений
    close(server)
    close(client)
end

function run_proxy()
    # Создание сокета
    server = listen(8080)

    @info "Proxy server is running on port 8080"

    while true
        # Принятие входящего соединения от клиента
        client = accept(server)

        # Обработка запроса от клиента в отдельном потоке
        Threads.@spawn handle_request(client)
    end
end

run_proxy()

HTTP_proxy.py

import socket
import threading

def handle_request(client_socket):
    # Чтение данных от клиента
    request_data = b""
    while True:
        data = client_socket.recv(1024)
        if not data:
            break
        request_data += data

    # Изменение запроса, если необходимо
    # Например, можно изменить хост или порт целевого сервера

    # Установка соединения с целевым сервером
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.connect(("example.com", 80))

    # Отправка запроса на целевой сервер
    server_socket.sendall(request_data)

    # Чтение данных от целевого сервера
    response_data = b""
    while True:
        data = server_socket.recv(1024)
        if not data:
            break
        response_data += data

    # Отправка ответа клиенту
    client_socket.sendall(response_data)

    # Закрытие соединений
    server_socket.close()
    client_socket.close()

def run_proxy():
    # Создание сокета
    proxy_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    proxy_socket.bind(("0.0.0.0", 8080))
    proxy_socket.listen(5)

    while True:
        # Принятие входящего соединения от клиента
        client_socket, client_address = proxy_socket.accept()

        # Обработка запроса в отдельном потоке
        threading.Thread(target=handle_request, args=(client_socket,)).start()

if __name__ == "__main__":
    run_proxy()