View Categories

C/C++ Integration Demo IPNut Proxy Configuration via C/C++

After purchasing static IP services from IPNut platform, use the following C++ code samples for integration.

1. Project Structure & Build System #
				
					/* Directory Structure:
cpp-proxy-demo/
├── include/
│   ├── base64.h
│   └── proxy_common.h
├── src/
│   ├── socks5_proxy_demo.cpp
│   ├── http_proxy_demo.cpp
│   ├── proxy_test_tool.cpp
│   └── main.cpp
├── Makefile
└── README.md */

// Makefile
// Makefile for IPNut C++ Proxy Demo

CXX = g++
CXXFLAGS = -std=c++11 -Wall -Wextra -O2 -I./include
TARGETS = socks5_demo http_demo proxy_test main_demo

all: $(TARGETS)

socks5_demo: src/socks5_proxy_demo.cpp
	$(CXX) $(CXXFLAGS) -o bin/socks5_demo src/socks5_proxy_demo.cpp

http_demo: src/http_proxy_demo.cpp
	$(CXX) $(CXXFLAGS) -o bin/http_demo src/http_proxy_demo.cpp

proxy_test: src/proxy_test_tool.cpp
	$(CXX) $(CXXFLAGS) -o bin/proxy_test src/proxy_test_tool.cpp

main_demo: src/main.cpp src/socks5_proxy_demo.cpp src/http_proxy_demo.cpp src/proxy_test_tool.cpp
	$(CXX) $(CXXFLAGS) -o bin/main_demo src/main.cpp src/socks5_proxy_demo.cpp src/http_proxy_demo.cpp src/proxy_test_tool.cpp

clean:
	rm -rf bin/*

install:
	mkdir -p bin

.PHONY: all clean install
2. Common Headers & Utilities #
				
					// include/base64.h
/**
 * Base64 Encoding Utility for IPNut Proxy Authentication
 */

#ifndef BASE64_H
#define BASE64_H

#include <string>
#include <vector>

class Base64 {
public:
    static std::string encode(const std::string &input) {
        static const std::string base64_chars =
            "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
            "abcdefghijklmnopqrstuvwxyz"
            "0123456789+/";

        std::string encoded;
        int i = 0;
        int j = 0;
        unsigned char char_array_3[3];
        unsigned char char_array_4[4];

        for (size_t idx = 0; idx < input.size(); idx++) {
            char_array_3[i++] = input[idx];
            if (i == 3) {
                char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
                char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
                char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
                char_array_4[3] = char_array_3[2] & 0x3f;

                for(i = 0; i < 4; i++)
                    encoded += base64_chars[char_array_4[i]];
                i = 0;
            }
        }

        if (i) {
            for(j = i; j < 3; j++)
                char_array_3[j] = '\0';

            char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
            char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
            char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
            char_array_4[3] = char_array_3[2] & 0x3f;

            for (j = 0; j < i + 1; j++)
                encoded += base64_chars[char_array_4[j]];

            while(i++ < 3)
                encoded += '=';
        }

        return encoded;
    }
};

#endif
				
			
				
					// include/proxy_common.h
/**
 * Common definitions for IPNut Proxy Integration
 */

#ifndef PROXY_COMMON_H
#define PROXY_COMMON_H

#include <iostream>
#include <string>
#include <vector>

// Proxy Configuration
struct ProxyConfig {
    std::string host = "proxy.ipnut.com";
    int port = 28001;
    std::string username = "ipnut";
    std::string password = "123456789";
    int timeout_seconds = 30;
};

// Network utilities
class NetworkUtils {
public:
    static bool resolveHostname(const std::string& hostname, std::string& ip_address) {
        struct hostent* he = gethostbyname(hostname.c_str());
        if (he == nullptr) return false;
        
        ip_address = inet_ntoa(*(struct in_addr*)he->h_addr);
        return true;
    }
    
    static void printHex(const std::vector<unsigned char>& data, const std::string& label = "") {
        if (!label.empty()) {
            std::cout << label << ": ";
        }
        for (unsigned char byte : data) {
            std::cout << std::hex << std::setw(2) << std::setfill('0') << (int)byte << " ";
        }
        std::cout << std::dec << std::endl;
    }
};

#endif
3. SOCKS5 Proxy Implementation src/socks5_proxy_demo.cpp #
				
					/**
 * IPNut SOCKS5 Proxy Integration - C++
 */

#include <iostream>
#include <string>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netdb.h>
#include <vector>
#include <sstream>
#include <iomanip>
#include "../include/proxy_common.h"

class Socks5ProxyDemo {
private:
    ProxyConfig config;

public:
    Socks5ProxyDemo() = default;
    
    explicit Socks5ProxyDemo(const ProxyConfig& cfg) : config(cfg) {}

    /**
     * Connect to SOCKS5 proxy server
     */
    int connectToProxy() {
        int sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd < 0) {
            std::cerr << "❌ Failed to create socket" << std::endl;
            return -1;
        }

        // Set socket timeout
        struct timeval timeout;
        timeout.tv_sec = config.timeout_seconds;
        timeout.tv_usec = 0;
        setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
        setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));

        // Resolve proxy server address
        struct hostent* he = gethostbyname(config.host.c_str());
        if (he == nullptr) {
            std::cerr << "❌ Failed to resolve proxy host: " << config.host << std::endl;
            close(sockfd);
            return -1;
        }

        struct sockaddr_in proxy_addr;
        memset(&proxy_addr, 0, sizeof(proxy_addr));
        proxy_addr.sin_family = AF_INET;
        proxy_addr.sin_port = htons(config.port);
        memcpy(&proxy_addr.sin_addr, he->h_addr_list[0], he->h_length);

        std::cout << "🔗 Connecting to SOCKS5 proxy: " << config.host << ":" << config.port << std::endl;

        // Connect to proxy server
        if (connect(sockfd, (struct sockaddr*)&proxy_addr, sizeof(proxy_addr)) < 0) {
            std::cerr << "❌ Failed to connect to SOCKS5 proxy" << std::endl;
            close(sockfd);
            return -1;
        }

        std::cout << "✅ Successfully connected to SOCKS5 proxy server" << std::endl;
        return sockfd;
    }

    /**
     * SOCKS5 authentication handshake
     */
    bool authenticate(int sockfd) {
        std::cout << "🔐 Starting SOCKS5 authentication..." << std::endl;

        // SOCKS5 handshake packet
        std::vector<unsigned char> handshake = {
            0x05, // SOCKS version 5
            0x02, // Number of authentication methods
            0x00, // No authentication
            0x02  // Username/password authentication
        };

        NetworkUtils::printHex(handshake, "Sending handshake");

        if (send(sockfd, handshake.data(), handshake.size(), 0) < 0) {
            std::cerr << "❌ Failed to send handshake packet" << std::endl;
            return false;
        }

        // Receive server response
        unsigned char response[2];
        if (recv(sockfd, response, 2, 0) < 2) {
            std::cerr << "❌ Failed to receive handshake response" << std::endl;
            return false;
        }

        NetworkUtils::printHex(std::vector<unsigned char>(response, response + 2), "Handshake response");

        if (response[0] != 0x05) {
            std::cerr << "❌ Unsupported SOCKS version: " << (int)response[0] << std::endl;
            return false;
        }

        // Handle authentication method
        if (response[1] == 0x02) {
            return authenticateUsernamePassword(sockfd);
        } else if (response[1] != 0x00) {
            std::cerr << "❌ Unsupported authentication method: " << (int)response[1] << std::endl;
            return false;
        }

        std::cout << "✅ SOCKS5 authentication successful (no auth required)" << std::endl;
        return true;
    }

    /**
     * SOCKS5 username/password authentication
     */
    bool authenticateUsernamePassword(int sockfd) {
        std::vector<unsigned char> auth_packet;
        auth_packet.push_back(0x01); // Authentication version
        auth_packet.push_back(static_cast<unsigned char>(config.username.length()));
        auth_packet.insert(auth_packet.end(), config.username.begin(), config.username.end());
        auth_packet.push_back(static_cast<unsigned char>(config.password.length()));
        auth_packet.insert(auth_packet.end(), config.password.begin(), config.password.end());

        NetworkUtils::printHex(auth_packet, "Sending auth packet");

        if (send(sockfd, auth_packet.data(), auth_packet.size(), 0) < 0) {
            std::cerr << "❌ Failed to send authentication packet" << std::endl;
            return false;
        }

        unsigned char auth_response[2];
        if (recv(sockfd, auth_response, 2, 0) < 2) {
            std::cerr << "❌ Failed to receive authentication response" << std::endl;
            return false;
        }

        NetworkUtils::printHex(std::vector<unsigned char>(auth_response, auth_response + 2), "Auth response");

        if (auth_response[0] != 0x01 || auth_response[1] != 0x00) {
            std::cerr << "❌ SOCKS5 authentication failed" << std::endl;
            return false;
        }

        std::cout << "✅ SOCKS5 username/password authentication successful" << std::endl;
        return true;
    }

    /**
     * Connect to target server through SOCKS5 proxy
     */
    bool connectToTarget(int sockfd, const std::string& target_host, int target_port) {
        std::cout << "🎯 Connecting to target: " << target_host << ":" << target_port << std::endl;

        std::vector<unsigned char> connect_packet;
        connect_packet.push_back(0x05); // SOCKS version
        connect_packet.push_back(0x01); // CONNECT command
        connect_packet.push_back(0x00); // Reserved

        // Domain name type (recommended for hostnames)
        connect_packet.push_back(0x03); // Domain name
        connect_packet.push_back(static_cast<unsigned char>(target_host.length()));
        connect_packet.insert(connect_packet.end(), target_host.begin(), target_host.end());

        // Port (big-endian)
        connect_packet.push_back((target_port >> 8) & 0xFF);
        connect_packet.push_back(target_port & 0xFF);

        NetworkUtils::printHex(connect_packet, "Sending connect request");

        if (send(sockfd, connect_packet.data(), connect_packet.size(), 0) < 0) {
            std::cerr << "❌ Failed to send connect request" << std::endl;
            return false;
        }

        // Receive connection response
        unsigned char connect_response[10];
        int bytes_received = recv(sockfd, connect_response, sizeof(connect_response), 0);
        if (bytes_received < 2) {
            std::cerr << "❌ Failed to receive connect response" << std::endl;
            return false;
        }

        NetworkUtils::printHex(std::vector<unsigned char>(connect_response, connect_response + bytes_received), "Connect response");

        if (connect_response[0] != 0x05 || connect_response[1] != 0x00) {
            std::cerr << "❌ SOCKS5 connection failed with code: " << (int)connect_response[1] << std::endl;
            return false;
        }

        std::cout << "✅ Successfully connected to target through SOCKS5 proxy" << std::endl;
        return true;
    }

    /**
     * Send HTTP request through SOCKS5 proxy
     */
    bool sendHttpRequest(int sockfd, const std::string& target_host, const std::string& path = "/ip") {
        std::string http_request =
            "GET " + path + " HTTP/1.1\r\n"
            "Host: " + target_host + "\r\n"
            "User-Agent: IPNut-C++-SOCKS5/1.0\r\n"
            "Accept: application/json\r\n"
            "Connection: close\r\n"
            "\r\n";

        std::cout << "📤 Sending HTTP request to: " << target_host << path << std::endl;

        if (send(sockfd, http_request.c_str(), http_request.length(), 0) < 0) {
            std::cerr << "❌ Failed to send HTTP request" << std::endl;
            return false;
        }

        return true;
    }

    /**
     * Receive HTTP response
     */
    std::string receiveHttpResponse(int sockfd) {
        std::string response;
        char buffer[4096];
        int bytes_received;

        std::cout << "📥 Receiving HTTP response..." << std::endl;

        while ((bytes_received = recv(sockfd, buffer, sizeof(buffer) - 1, 0)) > 0) {
            buffer[bytes_received] = '\0';
            response += buffer;
        }

        return response;
    }

    /**
     * Complete HTTP request through SOCKS5 proxy
     */
    void performHttpRequest(const std::string& target_host, int target_port, const std::string& path = "/ip") {
        std::cout << "\n=== 🌐 SOCKS5 Proxy HTTP Request ===" << std::endl;
        std::cout << "Target: " << target_host << ":" << target_port << path << std::endl;

        int sockfd = connectToProxy();
        if (sockfd < 0) return;

        if (!authenticate(sockfd)) {
            close(sockfd);
            return;
        }

        if (!connectToTarget(sockfd, target_host, target_port)) {
            close(sockfd);
            return;
        }

        if (!sendHttpRequest(sockfd, target_host, path)) {
            close(sockfd);
            return;
        }

        std::string response = receiveHttpResponse(sockfd);
        std::cout << "📄 HTTP Response:" << std::endl;
        std::cout << response << std::endl;

        close(sockfd);
    }

    /**
     * Run comprehensive SOCKS5 demo
     */
    void runDemo() {
        std::cout << "🚀 Starting IPNut SOCKS5 Proxy Demo" << std::endl;
        std::cout << "===================================" << std::endl;

        // Test various endpoints
        performHttpRequest("httpbin.org", 80, "/ip");
        performHttpRequest("httpbin.org", 80, "/user-agent");
        performHttpRequest("httpbin.org", 80, "/headers");
        performHttpRequest("httpbin.org", 80, "/get?test=ipnut_socks5");

        std::cout << "===================================" << std::endl;
        std::cout << "🎉 SOCKS5 Proxy Demo Completed" << std::endl;
    }
};

// Main function for standalone SOCKS5 demo
int main() {
    Socks5ProxyDemo demo;
    demo.runDemo();
    return 0;
}
4. HTTP Proxy Implementation src/http_proxy_demo.cpp #
				
					/**
 * IPNut HTTP Proxy Integration - C++
 */

#include <iostream>
#include <string>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netdb.h>
#include <vector>
#include <sstream>
#include "../include/proxy_common.h"
#include "../include/base64.h"

class HttpProxyDemo {
private:
    ProxyConfig config;

public:
    HttpProxyDemo() = default;
    
    explicit HttpProxyDemo(const ProxyConfig& cfg) : config(cfg) {}

    /**
     * Connect to HTTP proxy server
     */
    int connectToProxy() {
        int sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd < 0) {
            std::cerr << "❌ Failed to create socket" << std::endl;
            return -1;
        }

        // Set socket timeout
        struct timeval timeout;
        timeout.tv_sec = config.timeout_seconds;
        timeout.tv_usec = 0;
        setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
        setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));

        // Resolve proxy server address
        struct hostent* he = gethostbyname(config.host.c_str());
        if (he == nullptr) {
            std::cerr << "❌ Failed to resolve proxy host: " << config.host << std::endl;
            close(sockfd);
            return -1;
        }

        struct sockaddr_in proxy_addr;
        memset(&proxy_addr, 0, sizeof(proxy_addr));
        proxy_addr.sin_family = AF_INET;
        proxy_addr.sin_port = htons(config.port);
        memcpy(&proxy_addr.sin_addr, he->h_addr_list[0], he->h_length);

        std::cout << "🔗 Connecting to HTTP proxy: " << config.host << ":" << config.port << std::endl;

        // Connect to proxy server
        if (connect(sockfd, (struct sockaddr*)&proxy_addr, sizeof(proxy_addr)) < 0) {
            std::cerr << "❌ Failed to connect to HTTP proxy" << std::endl;
            close(sockfd);
            return -1;
        }

        std::cout << "✅ Successfully connected to HTTP proxy server" << std::endl;
        return sockfd;
    }

    /**
     * HTTP Proxy CONNECT method for tunneling
     */
    bool connectThroughProxy(int sockfd, const std::string& target_host, int target_port) {
        // Build proxy authentication header
        std::string auth = config.username + ":" + config.password;
        std::string encoded_auth = Base64::encode(auth);

        // Send CONNECT request
        std::string connect_request =
            "CONNECT " + target_host + ":" + std::to_string(target_port) + " HTTP/1.1\r\n"
            "Host: " + target_host + ":" + std::to_string(target_port) + "\r\n"
            "Proxy-Authorization: Basic " + encoded_auth + "\r\n"
            "User-Agent: IPNut-C++-HTTP-Proxy/1.0\r\n"
            "Connection: keep-alive\r\n"
            "\r\n";

        std::cout << "📤 Sending CONNECT request..." << std::endl;

        if (send(sockfd, connect_request.c_str(), connect_request.length(), 0) < 0) {
            std::cerr << "❌ Failed to send CONNECT request" << std::endl;
            return false;
        }

        // Read proxy response
        char buffer[4096];
        int bytes_received = recv(sockfd, buffer, sizeof(buffer) - 1, 0);
        if (bytes_received <= 0) {
            std::cerr << "❌ Failed to receive proxy response" << std::endl;
            return false;
        }

        buffer[bytes_received] = '\0';
        std::string response(buffer);

        // Check response status
        if (response.find("HTTP/1.1 200") == std::string::npos &&
            response.find("HTTP/1.0 200") == std::string::npos) {
            std::cerr << "❌ Proxy connection failed" << std::endl;
            std::cerr << "Response: " << response << std::endl;
            return false;
        }

        std::cout << "✅ Successfully connected through HTTP proxy tunnel" << std::endl;
        return true;
    }

    /**
     * Send HTTP request through proxy tunnel
     */
    void sendTunneledHttpRequest(const std::string& target_host, int target_port, const std::string& path = "/ip") {
        std::cout << "\n=== 🌐 HTTP Proxy Tunnel Request ===" << std::endl;
        std::cout << "Target: " << target_host << ":" << target_port << path << std::endl;

        int sockfd = connectToProxy();
        if (sockfd < 0) return;

        if (!connectThroughProxy(sockfd, target_host, target_port)) {
            close(sockfd);
            return;
        }

        // Send HTTP request through tunnel
        std::string http_request =
            "GET " + path + " HTTP/1.1\r\n"
            "Host: " + target_host + "\r\n"
            "User-Agent: IPNut-C++-HTTP-Tunnel/1.0\r\n"
            "Accept: application/json\r\n"
            "Connection: close\r\n"
            "\r\n";

        std::cout << "📤 Sending HTTP request through tunnel..." << std::endl;

        if (send(sockfd, http_request.c_str(), http_request.length(), 0) < 0) {
            std::cerr << "❌ Failed to send HTTP request" << std::endl;
            close(sockfd);
            return;
        }

        // Receive response
        std::string response;
        char buffer[4096];
        int bytes_received;

        std::cout << "📥 Receiving response..." << std::endl;

        while ((bytes_received = recv(sockfd, buffer, sizeof(buffer) - 1, 0)) > 0) {
            buffer[bytes_received] = '\0';
            response += buffer;
        }

        std::cout << "📄 HTTP Response:" << std::endl;
        std::cout << response << std::endl;

        close(sockfd);
    }

    /**
     * Direct HTTP request through proxy (no tunneling)
     */
    void sendDirectHttpRequest(const std::string& target_url) {
        std::cout << "\n=== 🌐 HTTP Proxy Direct Request ===" << std::endl;
        std::cout << "URL: " << target_url << std::endl;

        int sockfd = connectToProxy();
        if (sockfd < 0) return;

        // Build proxy authentication
        std::string auth = config.username + ":" + config.password;
        std::string encoded_auth = Base64::encode(auth);

        // Extract host from URL
        std::string host = "httpbin.org";
        std::string path = target_url;
        
        size_t pos = target_url.find("//");
        if (pos != std::string::npos) {
            size_t start = pos + 2;
            size_t end = target_url.find('/', start);
            if (end != std::string::npos) {
                host = target_url.substr(start, end - start);
                path = target_url.substr(end);
            }
        }

        // Send complete HTTP request (proxy will forward)
        std::string http_request =
            "GET " + path + " HTTP/1.1\r\n"
            "Host: " + host + "\r\n"
            "User-Agent: IPNut-C++-HTTP-Direct/1.0\r\n"
            "Proxy-Authorization: Basic " + encoded_auth + "\r\n"
            "Accept: application/json\r\n"
            "Connection: close\r\n"
            "\r\n";

        std::cout << "📤 Sending direct HTTP request..." << std::endl;

        if (send(sockfd, http_request.c_str(), http_request.length(), 0) < 0) {
            std::cerr << "❌ Failed to send HTTP request" << std::endl;
            close(sockfd);
            return;
        }

        // Receive response
        std::string response;
        char buffer[4096];
        int bytes_received;

        while ((bytes_received = recv(sockfd, buffer, sizeof(buffer) - 1, 0)) > 0) {
            buffer[bytes_received] = '\0';
            response += buffer;
        }

        std::cout << "📄 HTTP Response:" << std::endl;
        std::cout << response << std::endl;

        close(sockfd);
    }

    /**
     * Run comprehensive HTTP proxy demo
     */
    void runDemo() {
        std::cout << "🚀 Starting IPNut HTTP Proxy Demo" << std::endl;
        std::cout << "=================================" << std::endl;

        // Test tunneled requests
        sendTunneledHttpRequest("httpbin.org", 80, "/ip");
        sendTunneledHttpRequest("httpbin.org", 80, "/user-agent");

        // Test direct requests
        sendDirectHttpRequest("http://httpbin.org/headers");
        sendDirectHttpRequest("http://httpbin.org/get?test=ipnut_http_proxy");

        std::cout << "=================================" << std::endl;
        std::cout << "🎉 HTTP Proxy Demo Completed" << std::endl;
    }
};

// Main function for standalone HTTP proxy demo
int main() {
    HttpProxyDemo demo;
    demo.runDemo();
    return 0;
}
5. Proxy test tool proxy_test_tool.cpp #
				
					/**
 * 代理测试工具 - C++
 */

#include <iostream>
#include <string>
#include "socks5_proxy_demo.cpp"
#include "http_proxy_demo.cpp"

class ProxyTestTool {
public:
    /**
     * 测试SOCKS5代理
     */
    void testSocks5Proxy() {
        std::cout << "测试 SOCKS5 代理:" << std::endl;
        
        Socks5ProxyDemo socks5Demo;
        
        // 简化测试 - 只测试连接和认证
        int sockfd = socks5Demo.connectToSocks5Proxy();
        if (sockfd >= 0) {
            if (socks5Demo.socks5Authenticate(sockfd)) {
                std::cout << "✅ SOCKS5 代理连接成功" << std::endl;
            } else {
                std::cout << "❌ SOCKS5 代理认证失败" << std::endl;
            }
            close(sockfd);
        } else {
            std::cout << "❌ SOCKS5 代理连接失败" << std::endl;
        }
    }

    /**
     * 测试HTTP代理
     */
    void testHttpProxy() {
        std::cout << "\n测试 HTTP 代理:" << std::endl;
        
        HttpProxyDemo httpDemo;
        
        int sockfd = httpDemo.connectToHttpProxy();
        if (sockfd >= 0) {
            std::cout << "✅ HTTP 代理连接成功" << std::endl;
            close(sockfd);
        } else {
            std::cout << "❌ HTTP 代理连接失败" << std::endl;
        }
    }

    /**
     * 运行测试
     */
    void runTests() {
        std::cout << "=== 代理测试工具 ===" << std::endl;
        
        testSocks5Proxy();
        testHttpProxy();
        
        std::cout << "\n代理测试完成!" << std::endl;
    }
};

int main() {
    ProxyTestTool tool;
    tool.runTests();
    return 0;
}
6. Makefile #
				
					# Makefile for IPNut C++ Proxy Demo

CXX = g++
CXXFLAGS = -std=c++11 -Wall -Wextra -O2 -I./include
TARGETS = socks5_demo http_demo proxy_test main_demo

all: $(TARGETS)

socks5_demo: src/socks5_proxy_demo.cpp
	$(CXX) $(CXXFLAGS) -o bin/socks5_demo src/socks5_proxy_demo.cpp

http_demo: src/http_proxy_demo.cpp
	$(CXX) $(CXXFLAGS) -o bin/http_demo src/http_proxy_demo.cpp

proxy_test: src/proxy_test_tool.cpp
	$(CXX) $(CXXFLAGS) -o bin/proxy_test src/proxy_test_tool.cpp

main_demo: src/main.cpp src/socks5_proxy_demo.cpp src/http_proxy_demo.cpp src/proxy_test_tool.cpp
	$(CXX) $(CXXFLAGS) -o bin/main_demo src/main.cpp src/socks5_proxy_demo.cpp src/http_proxy_demo.cpp src/proxy_test_tool.cpp

clean:
	rm -rf bin/*

install:
	mkdir -p bin

.PHONY: all clean install
7. Build & Execution #
				
					# Compilation:
# Create build directory
mkdir -p cpp-proxy-demo/bin
cd cpp-proxy-demo

# Build all targets
make all

# Or build individually
make socks5_demo
make http_demo
make proxy_test
make main_demo

# Execution:
# Run SOCKS5 proxy demo
./bin/socks5_demo

# Run HTTP proxy demo  
./bin/http_demo

# Run connectivity tests
./bin/proxy_test

# Run complete demonstration
./bin/main_demo

Key Integration Notes:

  • Platform: Linux/Unix systems with standard socket API

  • Dependencies: No external libraries required (uses system sockets)

  • Security: Implements proper SOCKS5 and HTTP proxy authentication

  • Error Handling: Comprehensive error checking and reporting

  • Performance: Socket timeouts and efficient buffer management

Best Practices:

  1. Resource Management: Always close sockets and handle errors

  2. Timeout Configuration: Set appropriate timeouts for production use

  3. Buffer Management: Use proper buffer sizes and bounds checking

  4. Authentication: Secure credential handling in production applications

Technical Support
For integration assistance or location-specific requirements:

  • Email: Support@ipnut.com

  • Live Chat: 24/7 real-time support via official website

*All code examples support both HTTP and SOCKS5 protocols with enterprise-grade authentication and security features.*

Scroll to Top