Ego_Http.php

gehe zur Dokumentation dieser Datei

<?php
 
class Ego_Http {
    private $_requestHeader = [];
    public $responseHeader = [];
    public $multiResponseHeader = [];
    protected $info = [];
    protected $multiInfo = [];
    public $code = 0;
    public $multiCode = [];
    public $responseTime = 0;
    public $multiResponseTime = [];
    public $content = null;
    public $multiContent = [];
    public $cookie = [];
    public $multiCookie = [];
    public $error = null;
    public $multiError = [];
    public $verifySSL = true;
    public $json = null;
    public $multiJson = [];
    public $returnHeader = true;
    public $use_http_build_query = true;
    public $flatten_array_params = false;
    private $_proxy = [];
 
    public function __construct() {
        $this->verifySSL = empty($GLOBALS['egotec_conf']['proxy']['insecure']);
 
        // Eingestellten Proxy verwenden
        if ($GLOBALS['egotec_conf']['proxy']['proxy_host']) {
            $this->proxy(
                $GLOBALS['egotec_conf']['proxy']['proxy_host'],
                $GLOBALS['egotec_conf']['proxy']['proxy_port'],
                $GLOBALS['egotec_conf']['proxy']['proxy_ssl'],
                $GLOBALS['egotec_conf']['proxy']['proxy_login'],
                $GLOBALS['egotec_conf']['proxy']['proxy_password'],
                (bool) $GLOBALS['egotec_conf']['proxy']['insecure']
            );
        }
    }
 
    public function addHeader($headers) {
        foreach ($headers as $key => $value) {
            $this->_requestHeader[$key] = $value;
        }
    }
 
    public function auth($username, $password = '') {
        $this->addHeader(array(
            'Authorization' => 'Basic '.base64_encode("$username:$password")
        ));
    }
 
    public function proxy($host, $port, $ssl = false, $username = '', $password = '', $insecure = false) {
        $this->_proxy['host'] = $host;
        $this->_proxy['port'] = (int) $port;
        $this->_proxy['ssl'] = (bool) $ssl;
        $this->_proxy['username'] = $username;
        $this->_proxy['password'] = $password;
        $this->_proxy['insecure'] = $insecure;
    }
 
    public function get($url, $additional_header = array(), int $timeout = 0) {
        $this->request(array_merge([
            'url' => $url,
            'method' => 'GET',
            'header' => $additional_header
        ], $timeout > 0 ? ['timeout' => $timeout] : []));
    }
 
    public function post($url, $param = array(), $additional_header = array(), $callback = null) {
        $this->request(array(
            'url' => $url,
            'method' => 'POST',
            'param' => $param,
            'header' => $additional_header,
            'callback' => $callback
        ));
    }
 
    public function delete($url, $additional_header = array()) {
        $this->request(array(
            'url' => $url,
            'method' => 'DELETE',
            'header' => $additional_header
        ));
    }
 
    public function put($url, $param = array(), $additional_header = array()) {
        $this->request(array(
            'url' => $url,
            'method' => 'PUT',
            'param' => $param,
            'header' => $additional_header
        ));
    }
 
    public function download($url, $target, $param = array(), $additional_header = array()) {
        $this->request(array(
            'url' => $url,
            'method' => 'POST',
            'download' => $target,
            'param' => $param,
            'header' => $additional_header
        ));
    }
 
    public function upload($url, $file, $param = array(), $additional_header = array()) {
        $this->request(array(
            'url' => $url,
            'method' => 'POST',
            'upload' => $file,
            'param' => $param,
            'header' => $additional_header
        ));
    }
 
    public function multiRequest(array $requests): void {
        $curlHandles = [];
        $running = false;
        $multiCurl = curl_multi_init();
 
        // Alle Curl-Aufrufe initialisieren
        foreach ($requests as $request) {
            $ch = $this->createCurlHandle($request);
            curl_multi_add_handle($multiCurl, $ch);
 
            $curlHandles[] = $ch;
        }
 
        // Alle cUrl-Aufrufe durchführen
        do {
            curl_multi_exec($multiCurl, $running);
            curl_multi_select($multiCurl);
        } while ($running > 0);
 
        foreach ($curlHandles as $ch) {
            $response = curl_multi_getcontent($ch);
 
            if (!$response) {
                $this->multiError[] = curl_error($ch);
            } else {
                $response_headers = [];
                $response_cookies = [];
                $header_size = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
                $content_orig = substr($response, $header_size);
                $headers = substr($response, 0, $header_size);
 
                // Headers sammeln
                foreach (explode("\n", $headers) as $value) {
                    $pos = strpos($value, ':');
                    $response_headers[substr($value, 0, $pos)] = trim(substr($value, $pos + 1));
                }
 
                $content = $response_headers['Content-Encoding'] == 'gzip' ? zlib_decode($content_orig) : $content_orig;
 
                // Cookies sammeln
                if ($response_headers['Set-Cookie']) {
                    foreach (explode("\n", $response_headers['Set-Cookie']) as $line) {
                        $rows = explode(';', $line);
                        $row0_keyval = explode('=', array_shift($rows));
                        $cookie = ['value' => $row0_keyval[1]];
 
                        foreach ($rows as $s) {
                            $keyval = explode('=', $s);
                            $cookie[trim($keyval[0])] = $keyval[1];
                        }
 
                        $response_cookies[$row0_keyval[0]] = $cookie;
                    }
                }
 
                $info = curl_getinfo($ch);
 
                $this->multiResponseHeader[] = $response_headers;
                $this->multiCookie[] = $response_cookies;
                $this->multiInfo[] = $info;
                $this->multiResponseTime[] = $info['total_time'];
                $this->multiCode[] = $info['http_code'];
                $this->multiContent[] = $content;
 
                if (strpos($response_headers['Content-Type'], 'application/json') !== false) {
                    $this->multiJson[] = json_decode($content);
                }
            }
 
            curl_multi_remove_handle($multiCurl, $ch);
        }
 
        curl_multi_close($multiCurl);
    }
 
    public function request($request) {
        $ch = $this->createCurlHandle($request);
 
        $response = curl_exec($ch);
        if (!$response) {
            $this->error = curl_error($ch);
            return;
        }
        $this->error = null;
 
        if (!$request['download']) {
            // Generate Response Headers
            $header_size = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
            $headers = substr($response, 0, $header_size);
            $content_orig = substr($response, $header_size);
            $this->responseHeader = array();
            foreach (explode("\n", $headers) as $value) {
                $pos = strpos($value, ":");
                $key = substr($value, 0, $pos);
                $val = trim(substr($value, $pos + 1));
                $this->responseHeader[$key] = $val;
            }
 
            // Collect Cookies
            $this->cookie = array();
            if ($this->responseHeader['Set-Cookie']) {
                $cookies = explode("\n", $this->responseHeader['Set-Cookie']);
                foreach ($cookies as $line) {
                    $row = explode(";", $line);
                    $row0 = array_shift($row);
                    $row0_keyval = explode("=", $row0);
                    $cookie = array('value' => $row0_keyval[1]);
                    foreach ($row as $s) {
                        $keyval = explode("=", $s);
                        $cookie[trim($keyval[0])] = $keyval[1];
                    }
                    $this->cookie[$row0_keyval[0]] = $cookie;
                }
            }
        }
 
        $this->info = curl_getinfo($ch);
        $this->responseTime = $this->info['total_time'];
        $this->content = $this->responseHeader['Content-Encoding']=='gzip' ? zlib_decode($content_orig) : $content_orig;
 
        // decode JSON
        if (
            strpos($this->responseHeader['Content-Type'], "application/json") !== false
            || strpos($this->responseHeader['content-type'], "application/json") !== false
        ) {
            $this->json = json_decode($this->content);
        } else {
            $this->json = null;
        }
 
        $this->code = $this->info['http_code'];
 
        curl_close($ch);
        if (isset($fp)) {
            fclose($fp);
        }
    }
 
    private function createCurlHandle(array $request) {
        $header = [];
        foreach (array_merge($this->_requestHeader, $request['header'] ?? []) as $key => $value) {
            $header[] = $key . ': ' . $value;
        }
 
        $ch = curl_init();
 
        curl_setopt($ch, CURLOPT_HTTPHEADER, $header);
        curl_setopt($ch, CURLOPT_URL, $request['url']);
        curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $request['method']);
 
        if ($request['timeout']) {
            curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $request['timeout']);
            curl_setopt($ch, CURLOPT_TIMEOUT, $request['timeout']);
        }
 
        // Cookie
        if ($request['cookie']) {
            curl_setopt($ch, CURLOPT_COOKIE, $request['cookie']);
        }
 
        // Download
        if ($request['download']) {
            $fp = fopen($request['download'], 'w+');
            curl_setopt($ch, CURLOPT_FILE, $fp);
            curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
            curl_setopt($ch, CURLOPT_TIMEOUT, 900);
        } else {
            curl_setopt($ch, CURLOPT_HEADER, $this->returnHeader);
            curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        }
 
        // Don't verify SSL certificates.
        if (!$this->verifySSL) {
            curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
            curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
        }
 
        // Upload
        if ($request['upload']) {
            curl_setopt($ch, CURLOPT_INFILE, $request['upload']);
            curl_setopt($ch, CURLOPT_INFILESIZE, filesize($request['upload']));
        }
 
        // URL Parameter
        if (!empty($request['param'])) {
            assert($request['method'] === 'POST', 'Makes only sense with POST.');
            if ($this->use_http_build_query) {
                if ($this->flatten_array_params) {
                    // Array Parameter mit numerischen Indizes flach darstellen (z.B. "x=1&x=2" anstatt "x[0]=1&x[1]=2")
                    $params = [];
                    $flatten = [];
                    foreach ($request['param'] as $key => $value) {
                        if (is_array($value) && count(array_filter(array_keys($value), 'is_string')) == 0) {
                            foreach ($value as $v) {
                                $flatten[] = "$key=" . rawurlencode($v);
                            }
                        } else {
                            $params[$key] = $value;
                        }
                    }
 
                    curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($params)
                        . (sizeof($flatten) > 0 ? '&' . implode('&', $flatten) : ''));
                } else {
                    curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($request['param']));
                }
            } else {
                curl_setopt($ch, CURLOPT_POSTFIELDS, $request['param']);
            }
        }
 
        // Proxy
        if (!empty($this->_proxy)) {
            curl_setopt($ch, CURLOPT_PROXY, $this->_proxy['host']);
            curl_setopt($ch, CURLOPT_PROXYPORT, $this->_proxy['port']);
            if ($this->_proxy['ssl']) {
                curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, true);
            }
            if (!empty($this->_proxy['username'])) {
                curl_setopt($ch, CURLOPT_PROXYUSERPWD, implode(':', [
                    $this->_proxy['username'],
                    $this->_proxy['password']
                ])
                );
            }
            if ($this->_proxy['insecure']) {
                curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
                curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
            }
        }
 
        // Callback Funktion
        if (!empty($request['callback']) && is_callable($request['callback'])) {
            curl_setopt($ch, CURLOPT_WRITEFUNCTION, function($ch, $str) use ($request) {
                $request['callback']($str);
                return strlen($str);
            });
        }
 
        return $ch;
    }
}