#include iostream
          

  #include   
  #include 
  #include 
  #include 
  
  #include "curl/curl.h"
  
  #pragma comment(lib, "libcurl.lib")
  
  using namespace std;
  
  static size_t write_buff_data(char* buffer, size_t size, size_t nitems, void* outstream)
  {//Copy the received data to the cache
    memcpy(outstream, buffer, nitems * size);
    return nitems * size;
  }
  /*
  Use HTTP proxy
  */
  int GetHTTPFunc(char* url, char* buff)
  {
    CURL* curl;
    CURLcode res;
    curl = curl_easy_init();
    if (curl)
    {
      curl_easy_setopt(curl, CURLOPT_PROXY, "http://ip:port");//Set HTTP proxy address
      curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, "User name: password");//Proxy username password
      curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)buff);//Set Read-Write Cache
      curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_buff_data);//Set Callback Function
      curl_easy_setopt(curl, CURLOPT_URL, url);//Set URL address
      curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, 10L);//Sets a long integer to control how many seconds CURLOPT_LOW_SPEED_LIMIT bytes are passed
      curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 50L);//Set a long integer to control how many bytes are transferred
      curl_easy_setopt(curl, CURLOPT_MAX_RECV_SPEED_LARGE, 2000000L);//Maximum download speed
  
      res = curl_easy_perform(curl);
      curl_easy_cleanup(curl);
      if (res == CURLE_OK) {
        return res;
      }
      else {
        printf("error code:%d\n", res);
        MessageBox(NULL, TEXT("Get IP Error"), TEXT("assistant"), MB_ICONINFORMATION | MB_YESNO);
      }
    }
    return res;
  }
  /*
  Use Socks5 proxy
  */
  int GetSocks5Func(char* url, char* buff)
  {
    CURL* curl;
    CURLcode res;
    curl = curl_easy_init();
    if (curl)
    {
      curl_easy_setopt(curl, CURLOPT_PROXY, "socks5://ip:port");//Set Socks5 proxy address
      curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, "User name: password");//Proxy username password
      curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)buff);//Set Read-Write Cache
      curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_buff_data);//Set Callback Function
      curl_easy_setopt(curl, CURLOPT_URL, url);//Set URL address
      curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, 10L);//Sets a long integer to control how many seconds CURLOPT_LOW_SPEED_LIMIT bytes are passed
      curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 50L);//Set a long integer to control how many bytes are transferred;
      curl_easy_setopt(curl, CURLOPT_MAX_RECV_SPEED_LARGE, 2000000L);/*Maximum download speed*/
      res = curl_easy_perform(curl);
      curl_easy_cleanup(curl);
  
      if (res == CURLE_OK) {
        return res;
      }
      else {
        printf("error code:%d\n", res);
        MessageBox(NULL, TEXT("Get IP Error"), TEXT("assistant"), MB_ICONINFORMATION | MB_YESNO);
      }
    }
    return res;
  }
  /*
  Do not use proxy
  */
  int GetUrl(char* url, char* buff)
  {
    CURL* curl;
    CURLcode res;
    //Initialize curl library using curl Library
    curl = curl_easy_init();
    if (curl)
    {
      curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)buff);//Set Read-Write Cache
      curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_buff_data);//Set Callback Function
      curl_easy_setopt(curl, CURLOPT_URL, url);//Set URL address
      curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, 10L);//Sets a long integer to control how many seconds CURLOPT_LOW_SPEED_LIMIT bytes are passed
      curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 50L);//Set a long integer to control how many bytes are transferred
      curl_easy_setopt(curl, CURLOPT_MAX_RECV_SPEED_LARGE, 2000000L);/*Maximum download speed*/
  
      string testurl = url;
      std::string strHead = testurl.substr(0, 5);
      if (strHead != "https")
      {
      }
      else
      {
        curl_easy_setopt(curl, CURLOPT_USE_SSL, CURLUSESSL_TRY);
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 1);
      }
  
  
      res = curl_easy_perform(curl);
      curl_easy_cleanup(curl);
      if (res == CURLE_OK)
      {
        return res;
      }
      else {
        printf("error code:%d\n", res);
        MessageBox(NULL, TEXT("Get IP Error"), TEXT("assistant"), MB_ICONINFORMATION | MB_YESNO);
      }
    }
    return res;
  }
  
  int func()
  {
    string strUrl = "ipinfo.io";
    char* buff = (char*)malloc(1024 * 1024);
    memset(buff, 0, 1024 * 1024);
    //Do not use HTTP proxy
    GetUrl((char*)strUrl.c_str(), buff);
    printf("Now IP:%s\n", buff);
    //Use HTTP proxy
    memset(buff, 0, 1024 * 1024);
    GetHTTPFunc((char*)strUrl.c_str(), buff);
    printf("Http results:%s\n", buff);
    //Use Socks5 proxy
    memset(buff, 0, 1024 * 1024);
    GetSocks5Func((char*)strUrl.c_str(), buff);
    printf("Socks5 result:%s\n", buff);
    free(buff);
    return 0;
  }
  
  int main()
  {
    return func();
  }
                            
                          

package main
                            package main
              
                            import (
                                "context"
                                "fmt"
                                "golang.org/x/net/proxy"
                                "io/ioutil"
                                "net"
                                "net/http"
                                "net/url"
                                "strings"
                                "time"
                            )
                            
                            var testApi = "https://api.ipify.org/?format=json"
                            
                            func main() {
                                var proxyIP = ""
                                var username = "xxx-zone-isp"
                                var password = ""
                                httpProxy(proxyIP, username, password)
                                time.Sleep(time.Second * 1)
                                Socks5Proxy(proxyIP, username, password)
                            
                            }
                            func httpProxy(proxyUrl, user, pass string) {
                                defer func() {
                                    if err := recover(); err != nil {
                                        fmt.Println(err)
                                    }
                                }()
                                urli := url.URL{}
                            
                                if !strings.Contains(proxyUrl, "http") {
                                    proxyUrl = fmt.Sprintf("http://%s", proxyUrl)
                                }
                            
                                urlProxy, _ := urli.Parse(proxyUrl)
                                if user != "" && pass != "" {
                                    urlProxy.User = url.UserPassword(user, pass)
                                }
                            
                                client := &http.Client{
                                    Transport: &http.Transport{
                                        Proxy: http.ProxyURL(urlProxy),
                                    },
                                }
                                rqt, err := http.NewRequest("GET", testApi, nil)
                                if err != nil {
                                    panic(err)
                                    return
                                }
                                response, err := client.Do(rqt)
                                if err != nil {
                                    panic(err)
                                    return
                                }
                            
                                defer response.Body.Close()
                                body, _ := ioutil.ReadAll(response.Body)
                                fmt.Println("http result = ", response.Status, string(body))
                            
                                return
                            }
                            
                            func Socks5Proxy(proxyUrl, user, pass string) {
                            
                                defer func() {
                                    if err := recover(); err != nil {
                                        fmt.Println(err)
                                    }
                                }()
                            
                                var userAuth proxy.Auth
                                if user != "" && pass != "" {
                                    userAuth.User = user
                                    userAuth.Password = pass
                                }
                                dialer, err := proxy.SOCKS5("tcp", proxyUrl, &userAuth, proxy.Direct)
                                if err != nil {
                                    panic(err)
                                }
                                httpClient := &http.Client{
                                    Transport: &http.Transport{
                                        DialContext: func(ctx context.Context, network, addr string) (conn net.Conn, err error) {
                                            return dialer.Dial(network, addr)
                                        },
                                    },
                                    Timeout: time.Second * 10,
                                }
                            
                                if resp, err := httpClient.Get(testApi); err != nil {
                                    panic(err)
                                } else {
                                    defer resp.Body.Close()
                                    body, _ := ioutil.ReadAll(resp.Body)
                                    fmt.Println("socks5 result = ",string(body))
                                }
                            }
          

const SocksProxyAgent = require("socks-proxy-agent");
          const net = require("net");
          const proxyHost = "proxy-server-hostname";
          const proxyPort = 1080;
          const proxyUsername = "your-username";
          const proxyPassword = "your-password";
          const agent = new SocksProxyAgent({
          host: proxyHost,
          port: proxyPort,
          auth: `${proxyUsername}:${proxyPassword}`
          });
          const socket = net.connect({
          host: "destination-hostname",
          port: 80,
          agent
          });
          socket.on("connect", () => {
          console.log("Connected to destination server through SOCKS5 proxy.");
          });
          socket.on("error", err => {
          console.error("Error:", err);
          });

<?php
          $targetUrl = "https://www.google.com/";
          $proxyServer = "http://";
          $proxyUserPwd = "user:psswd";
          $ch = curl_init();
          curl_setopt($ch, CURLOPT_URL, $targetUrl);
          curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, false);
          curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
          curl_setopt($ch, CURLOPT_PROXYTYPE, 0); //http
          // curl_setopt($ch, CURLOPT_PROXYTYPE, 5); //sock5
          curl_setopt($ch, CURLOPT_PROXY, $proxyServer);
          curl_setopt($ch, CURLOPT_PROXYAUTH, CURLAUTH_BASIC);
          curl_setopt($ch, CURLOPT_USERAGENT, "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727;)");
          curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 3);
          curl_setopt($ch, CURLOPT_TIMEOUT, 5);
          curl_setopt($ch, CURLOPT_HEADER, true);
          curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
          curl_setopt($ch, CURLOPT_PROXYUSERPWD, $proxyUserPwd);
          $result = curl_exec($ch);
          $err = curl_error($ch);
          curl_close($ch);
          var_dump($err);
          var_dump($result);
          ?>

package demo;
          import okhttp3.Credentials;
          import okhttp3.OkHttpClient;
          import okhttp3.Request;
          
          import java.io.IOException;
          import java.net.InetSocketAddress;
          import java.net.PasswordAuthentication;
          import java.net.Proxy;
          
          /**
          * compile 'com.squareup.okhttp3:okhttp:3.10.0'
          */
          class AutProxyJava {
          public static void main(String[] args) throws IOException {
              testWithOkHttp();
          
              testSocks5WithOkHttp();
          }
          
          public static void testWithOkHttp() throws IOException {
              String url = "https://api.ipify.org?format=json";
              Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("asg.360s5.com", 3600));
              OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).proxyAuthenticator((route, response) -> {
                  String credential = Credentials.basic("username-zone-custom", password);
                      return response.request().newBuilder()
                  .header("Proxy-Authorization", credential).build();
              }).build();
          
          
              Request request = new Request.Builder().url(url).build();
              okhttp3.Response response = client.newCall(request).execute();
              String responseString = response.body().string();
              System.out.println(responseString);
          }
          
          public static void testSocks5WithOkHttp() throws IOException {
              String url = "https://api.ipify.org?format=json";
              Proxy proxy = new Proxy(Proxy.Type.SOCKS, new InetSocketAddress("asg.360s5.com", 3600));
              java.net.Authenticator.setDefault(new java.net.Authenticator() {
                  private PasswordAuthentication authentication =
                  new PasswordAuthentication("laylay-zone-isp", "123456".toCharArray());
          
                  @Override
                  protected PasswordAuthentication getPasswordAuthentication() {
                      return authentication;
                  }
              });
              OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).build();
          
              Request request = new Request.Builder().url(url).build();
              okhttp3.Response response = client.newCall(request).execute();
              String responseString = response.body().string();
              System.out.println(responseString);
          }
          }

import urllib
          import socks
          import http.client
          from urllib.error import URLError
          import ssl
          from urllib.request import build_opener, HTTPHandler, HTTPSHandler
          
          
          def merge_dict(a, b):
          d = a.copy()
          d.update(b)
          return d
          
          
          class SocksiPyConnection(http.client.HTTPConnection):
          def __init__(self, proxytype, proxyaddr, proxyport=None, rdns=True, username=None, password=None, *args, **kwargs):
              self.proxyargs = (proxytype, proxyaddr, proxyport, rdns, username, password)
              http.client.HTTPConnection.__init__(self, *args, **kwargs)
          
          def connect(self):
              self.sock = socks.socksocket()
              self.sock.setproxy(*self.proxyargs)
              if type(self.timeout) in (int, float):
                  self.sock.settimeout(self.timeout)
              self.sock.connect((self.host, self.port))
          
          
          class SocksiPyConnectionS(http.client.HTTPSConnection):
          def __init__(self, proxytype, proxyaddr, proxyport=None, rdns=True, username=None, password=None, *args, **kwargs):
              self.proxyargs = (proxytype, proxyaddr, proxyport, rdns, username, password)
              http.client.HTTPSConnection.__init__(self, *args, **kwargs)
          
          def connect(self):
              sock = socks.socksocket()
              sock.setproxy(*self.proxyargs)
              if type(self.timeout) in (int, float):
                  sock.settimeout(self.timeout)
              sock.connect((self.host, self.port))
              self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file)
          
          
          class SocksiPyHandler(HTTPHandler, HTTPSHandler):
          def __init__(self, *args, **kwargs):
              self.args = args
              self.kw = kwargs
              HTTPHandler.__init__(self)
          
          def http_open(self, req):
              def build(host, port=None, timeout=0, **kwargs):
                  kw = merge_dict(self.kw, kwargs)
                  conn = SocksiPyConnection(*self.args, host=host, port=port, timeout=timeout, **kw)
                  return conn
          
              return self.do_open(build, req)
          
          def https_open(self, req):
              def build(host, port=None, timeout=0, **kwargs):
                  kw = merge_dict(self.kw, kwargs)
                  conn = SocksiPyConnectionS(*self.args, host=host, port=port, timeout=timeout, **kw)
                  return conn
          
              return self.do_open(build, req)
          
          
          username = ""
          password = ""
          ip = "asg.360s5.com"
          port = 3600
          proxy = "socks5://{username}:{password}@{ip}:{port}".format(username=username, password=password, ip=ip, port=port)
          # socks.set_default_proxy(socks.SOCKS5, ip, port,username=username,password=password)
          # socket.socket = socks.socksocket
          
          url = 'https://www.google.com/'
          
          try:
          req = urllib.request.Request(url=url, headers={'User-Agent':'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36'})
          opener = build_opener(SocksiPyHandler(socks.SOCKS5, ip, port, username=username, password=password))
          response = opener.open(req)
          # response = urllib.request.urlopen(req)
          # response = request.urlopen(url)
          print(response.read().decode('utf-8'))
          except URLError as e:
          print(e)