API tools faq
paste
Guest User

Untitled

a guest
Apr 11th, 2020
461
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
PHP 25.20 KB | None | 0 0
raw download clone embed print report
  1. <?php
  2. /**
  3.  * Usage:
  4.  *  require_once 'kclick_client.php';
  5.  *  $client = new KClickClient('http://tds.com/api.php', 'CAMPAIGN_TOKEN');
  6.  *  $client->sendUtmLabels(); # send only utm labels
  7.  *  $client->sendAllParams(); # send all params
  8.  *  $client
  9.  *      ->keyword('[KEYWORD]')
  10.  *      ->execute();          # use executeAndBreak() to break the page execution if there is redirect or some output
  11.  *
  12.  */
  13. class KClickClient
  14. {
  15.     const SESSION_SUB_ID = 'sub_id';
  16.     const SESSION_LANDING_TOKEN = 'landing_token';
  17.     /** @version 3.9 **/
  18.     const VERSION = 3;
  19.     const STATE_SESSION_KEY = 'keitaro_state';
  20.     const STATE_SESSION_EXPIRES_KEY = 'keitaro_state_expires';
  21.     const DEFAULT_TTL = 1;
  22.     const NOT_FOUND_STATUS = 404;
  23.     /**
  24.      * @var KHttpClient
  25.      */
  26.     private $_httpClient;
  27.     private $_debug = false;
  28.     private $_trackerUrl;
  29.     private $_params = array();
  30.     private $_log = array();
  31.     private $_excludeParams = array('api_key', 'token', 'language', 'ua', 'ip', 'referrer', 'force_redirect_offer');
  32.     private $_result;
  33.     private $_stateRestored;
  34.  
  35.     const ERROR = '[KTrafficClient] Something is wrong. Enable debug mode to see the reason.';
  36.  
  37.     public function __construct($trackerUrl, $token)
  38.     {
  39.         $this->trackerUrl($trackerUrl);
  40.         $this->campaignToken($token);
  41.         $this->version(self::VERSION);
  42.         $this->param('info', 1);
  43.         $this->fillParams();
  44.     }
  45.  
  46.     public function fillParams()
  47.     {
  48.         $referrer = isset($_SERVER['HTTP_REFERER']) ? $_SERVER['HTTP_REFERER'] : null;
  49.         $this->setHttpClient(new KHttpClient());
  50.  
  51.         $this->ip($this->_findIp())
  52.             ->ua(isset($_SERVER['HTTP_USER_AGENT']) ? $_SERVER['HTTP_USER_AGENT'] : null)
  53.             ->language((isset($_SERVER['HTTP_ACCEPT_LANGUAGE']) ? substr($_SERVER['HTTP_ACCEPT_LANGUAGE'], 0, 2) : ''))
  54.             ->seReferrer($referrer)
  55.             ->referrer($referrer)
  56.             ->param('original_headers', getallheaders())
  57.             ->param('original_host', isset($_SERVER['HTTP_HOST']) ? $_SERVER['HTTP_HOST'] : 'localhost')
  58.             ->param('kversion', '3.4');
  59.  
  60.         if ($this->isPrefetchDetected()) {
  61.             $this->param('prefetch', 1);
  62.         }
  63.     }
  64.  
  65.     public function currentPageAsReferrer()
  66.     {
  67.         $this->referrer($this->_getCurrentPage());
  68.         return $this;
  69.     }
  70.  
  71.     public function debug($state = true)
  72.     {
  73.         $this->_debug = $state;
  74.         return $this;
  75.     }
  76.  
  77.     public function seReferrer($seReferrer)
  78.     {
  79.         $this->_params['se_referrer'] = $seReferrer;
  80.         return $this;
  81.     }
  82.  
  83.     public function referrer($referrer)
  84.     {
  85.         $this->_params['referrer'] = $referrer;
  86.         return $this;
  87.     }
  88.  
  89.     public function setHttpClient($httpClient)
  90.     {
  91.         $this->_httpClient = $httpClient;
  92.         return $this;
  93.     }
  94.  
  95.     public function trackerUrl($name)
  96.     {
  97.         $this->_trackerUrl = $name;
  98.     }
  99.  
  100.     // @deprecated
  101.     public function token($token)
  102.     {
  103.         return $this->campaignToken($token);
  104.     }
  105.  
  106.     public function campaignToken($campaignToken)
  107.     {
  108.         $this->_params['token'] = $campaignToken;
  109.         return $this;
  110.     }
  111.     public function version($version)
  112.     {
  113.         $this->_params['version'] = $version;
  114.         return $this;
  115.     }
  116.  
  117.     public function ua($ua)
  118.     {
  119.         $this->_params['ua'] = $ua;
  120.         return $this;
  121.     }
  122.  
  123.     public function language($language)
  124.     {
  125.         $this->_params['language'] = $language;
  126.         return $this;
  127.     }
  128.  
  129.     public function keyword($keyword)
  130.     {
  131.         $this->_params['keyword'] = $keyword;
  132.         return $this;
  133.     }
  134.  
  135.     public function forceRedirectOffer()
  136.     {
  137.         $this->_params['force_redirect_offer'] = 1;
  138.     }
  139.  
  140.     public function ip($ip)
  141.     {
  142.         $this->_params['ip'] = $ip;
  143.         return $this;
  144.     }
  145.  
  146.     public function sendUtmLabels()
  147.     {
  148.         foreach ($_GET as $name => $value) {
  149.             if (strstr($name, 'utm_')) {
  150.                 $this->_params[$name] = $value;
  151.             }
  152.         }
  153.     }
  154.  
  155.     public function setLandingToken($token)
  156.     {
  157.         $this->_startSession();
  158.         $_SESSION['token'] = $token;
  159.     }
  160.  
  161.     public function getSubId()
  162.     {
  163.         $result = $this->performRequest();
  164.         if (empty($result->info->sub_id)) {
  165.             $this->log('No sub_id is defined');
  166.             return 'no_subid';
  167.         }
  168.         $subId = $result->info->sub_id;
  169.         return $subId;
  170.     }
  171.  
  172.     public function getToken()
  173.     {
  174.         $result = $this->performRequest();
  175.         if (empty($result->info->sub_id)) {
  176.             $this->log('No landing token is defined');
  177.             return 'no_token';
  178.         }
  179.         $subId = $result->info->token;
  180.         return $subId;
  181.     }
  182.  
  183.     public function sendAllParams()
  184.     {
  185.         foreach ($_GET as $name => $value) {
  186.             if (empty($this->_params[$name]) && !in_array($name, $this->_excludeParams)) {
  187.                 $this->_params[$name] = $value;
  188.             }
  189.         }
  190.     }
  191.  
  192.     public function restoreFromSession()
  193.     {
  194.         if ($this->isStateRestored()) {
  195.             return;
  196.         }
  197.         $this->_startSession();
  198.         if (!empty($_SESSION[self::STATE_SESSION_KEY])) {
  199.             if ($_SESSION[self::STATE_SESSION_EXPIRES_KEY] < time()) {
  200.                 unset($_SESSION[self::STATE_SESSION_KEY]);
  201.                 unset($_SESSION[self::STATE_SESSION_EXPIRES_KEY]);
  202.                 $this->log('State expired');
  203.             } else {
  204.                 $this->_result = json_decode($_SESSION[self::STATE_SESSION_KEY], false);
  205.                 if (isset($this->_result) && isset($this->_result->headers)) {
  206.                     $this->_result->headers = array();
  207.                 }
  208.                 $this->_stateRestored = true;
  209.                 $this->log('State restored');
  210.             }
  211.         }
  212.     }
  213.  
  214.     public function restoreFromQuery()
  215.     {
  216.         if (isset($_GET['_subid'])) {
  217.             $this->_stateRestored = true;
  218.             if (empty($this->_result)) {
  219.                 $this->_result = new StdClass();
  220.                 $this->_result->info = new StdClass();
  221.             }
  222.             $this->_result->info->sub_id = $_GET['_subid'];
  223.             $this->log('SubId loaded from query');
  224.             if (isset($_GET['_token'])) {
  225.                 $this->_result->info->token = $_GET['_token'];
  226.                 $this->log('Landing token loaded from query');
  227.             }
  228.             $this->_storeState($this->_result, self::DEFAULT_TTL);
  229.             $this->_stateRestored = true;
  230.         }
  231.     }
  232.  
  233.     public function isStateRestored()
  234.     {
  235.         return $this->_stateRestored;
  236.     }
  237.  
  238.     public function isPrefetchDetected()
  239.     {
  240.         $checkServerParams = array('HTTP_X_PURPOSE' => 'preview', 'HTTP_X_MOZ' => 'prefetch', 'HTTP_X_FB_HTTP_ENGINE' => 'Liger');
  241.         foreach ($checkServerParams as $name => $value) {
  242.             if (isset($_SERVER[$name]) && $_SERVER[$name] == $value) {
  243.                 return true;
  244.             }
  245.         }
  246.         return false;
  247.     }
  248.  
  249.     public function saveCookie($key, $value, $ttl)
  250.     {
  251.         if (isset($_COOKIE[$key]) && $_COOKIE[$key] == $value) {
  252.             return;
  253.         }
  254.         if (!headers_sent()) {
  255.             setcookie($key, $value, $this->_getCookiesExpireTimestamp($ttl), '/', $this->_getCookieHost());
  256.         }
  257.         $_COOKIE[$key] = $value;
  258.     }
  259.  
  260.     public function param($name, $value)
  261.     {
  262.         if (!in_array($name, $this->_excludeParams)) {
  263.             $this->_params[$name] = $value;
  264.         }
  265.         return $this;
  266.     }
  267.  
  268.     public function params($value)
  269.     {
  270.         if (!empty($value)) {
  271.             if (is_string($value)) {
  272.                 parse_str($value, $result);
  273.                 foreach ($result as $name => $value) {
  274.                     $this->param($name, $value);
  275.                 }
  276.             }
  277.         }
  278.  
  279.         return $this;
  280.     }
  281.  
  282.     public function reset()
  283.     {
  284.         $this->_result = null;
  285.     }
  286.  
  287.     public function performRequest()
  288.     {
  289.         if ($this->_result) {
  290.             return $this->_result;
  291.         }
  292.         $request = $this->_buildRequestUrl();
  293.         $params = $this->getParams();
  294.         $options = $this->_getRequestOptions();
  295.         $this->log('Request: ' . $request);
  296.         try {
  297.             $result = $this->_httpClient->request($request, $params, $options);
  298.             $this->log('Response: ' . $result);
  299.         } catch (KTrafficClientError $e) {
  300.             if ($this->_debug) {
  301.                 throw $e;
  302.             } else {
  303.                 $errorCode = $e->getHumanCode();
  304.                 $errorCode = $errorCode ? $errorCode . ' ' : '';
  305.  
  306.                 echo $errorCode . self::ERROR;
  307.                 return;
  308.             }
  309.         }
  310.         $this->_result = json_decode($result);
  311.         $this->_storeState(
  312.             $this->_result,
  313.             isset($this->_result->cookies_ttl) ? $this->_result->cookies_ttl : null
  314.         );
  315.  
  316.         if (isset($this->_result->cookies)) {
  317.             $this->_saveKeitaroCookies($this->_result->cookies, $this->_result->cookies_ttl);
  318.         }
  319.         return $this->_result;
  320.     }
  321.  
  322.     /**
  323.      * @param bool $break
  324.      * @param bool $print
  325.      * @return bool|string
  326.      * @throws KTrafficClientError
  327.      */
  328.     public function execute($break = false, $print = true)
  329.     {
  330.         $result = $this->performRequest();
  331.         $body = $this->_buildBody($result);
  332.  
  333.         if (!$print) {
  334.             return $body;
  335.         }
  336.  
  337.         $this->_sendHeaders($result);
  338.         echo $body;
  339.     }
  340.  
  341.     public function executeAndBreak()
  342.     {
  343.         $result = $this->performRequest();
  344.         $body = $this->_buildBody($result);
  345.         $this->_sendHeaders($result);
  346.  
  347.         if (!empty($body)) {
  348.             die($body);
  349.         }
  350.  
  351.         if (!empty($result->headers) && ResponseExecutor::containsActionHeader($result->headers)) {
  352.             die($body);
  353.         }
  354.  
  355.         if (!empty($result->status) && $result->status == self::NOT_FOUND_STATUS) {
  356.             die($body);
  357.         }
  358.     }
  359.  
  360.     public function getContent()
  361.     {
  362.         $result = $this->performRequest();
  363.         return $this->_buildBody($result);
  364.     }
  365.  
  366.     public function showLog($separator = '<br />')
  367.     {
  368.         echo '<hr>' . implode($separator, $this->getLog()). '<hr>';
  369.     }
  370.  
  371.     public function log($msg)
  372.     {
  373.         if ($this->_debug) {
  374.             error_log($msg);
  375.         }
  376.         $this->_log[] = $msg;
  377.     }
  378.  
  379.     public function getLog()
  380.     {
  381.         return $this->_log;
  382.     }
  383.  
  384.     public function getParams()
  385.     {
  386.         return $this->_params;
  387.     }
  388.  
  389.     private function _sendHeaders($result)
  390.     {
  391.         $file = '';
  392.         $line = '';
  393.         if (headers_sent($file, $line)) {
  394.             $msg = "Body output already started";
  395.             if (!empty($file)) {
  396.                 $msg .= "({$file}:{$line})";
  397.             }
  398.             $this->log($msg);
  399.             return;
  400.         }
  401.         ResponseExecutor::sendHeaders($result);
  402.     }
  403.  
  404.     private function _storeState($result, $ttl)
  405.     {
  406.         $this->_startSession();
  407.         $_SESSION[self::STATE_SESSION_KEY] = json_encode($result);
  408.         $_SESSION[self::STATE_SESSION_EXPIRES_KEY] = time() + ($ttl * 60 * 60);
  409.  
  410.         // for back-compatibility purpose
  411.         if (!empty($result->info)) {
  412.             if (!empty($result->info->sub_id)) {
  413.                 $_SESSION[self::SESSION_SUB_ID] = $result->info->sub_id;
  414.             }
  415.             if (!empty($result->info->token)) {
  416.                 $_SESSION[self::SESSION_LANDING_TOKEN] = $result->info->token;
  417.             }
  418.         }
  419.     }
  420.  
  421.     private function _buildBody($result)
  422.     {
  423.         $content = '';
  424.         if (!empty($result)) {
  425.             if (!empty($result->error)) {
  426.                 $content .=  $result->error;
  427.             }
  428.             if (!empty($result->body)) {
  429.                 if (isset($result->contentType) && (strstr($result->contentType, 'image') || strstr($result->contentType, 'application/pdf'))) {
  430.                     $content = base64_decode($result->body);
  431.                 } else {
  432.                     $content .= $result->body;
  433.                 }
  434.             }
  435.         }
  436.  
  437.         return $content;
  438.     }
  439.  
  440.     private function _saveKeitaroCookies($cookies, $ttl)
  441.     {
  442.         foreach ($cookies as $key => $value) {
  443.             $this->saveCookie($key, $value, $ttl);
  444.         }
  445.     }
  446.  
  447.     public function getOffer($params = array(), $fallback = 'no_offer')
  448.     {
  449.         $result = $this->performRequest();
  450.         $token = $this->getToken();
  451.         if (empty($token)) {
  452.             $this->log('Campaign hasn\'t returned offer');
  453.             return $fallback;
  454.         }
  455.         $params['_lp'] = 1;
  456.         $params['_token'] = $result->info->token;
  457.         return $this->_buildOfferUrl($params);
  458.     }
  459.  
  460.     public function isBot()
  461.     {
  462.         $result = $this->performRequest();
  463.         if (isset($result->info)) {
  464.             return isset($result->info->is_bot) ? $result->info->is_bot : false;
  465.         }
  466.     }
  467.  
  468.     public function isUnique($level = 'campaign')
  469.     {
  470.         $result = $this->performRequest();
  471.         if (isset($result->info) && $result->info->uniqueness) {
  472.             return isset($result->info->uniqueness->$level) ? $result->info->uniqueness->$level : false;
  473.         }
  474.     }
  475.  
  476.     // @deprecated
  477.     public function forceChooseOffer()
  478.     {
  479.         throw new \Error('forceChooseOffer was removed in KClickClient v3.');
  480.     }
  481.  
  482.     public function getBody()
  483.     {
  484.         $result = $this->performRequest();
  485.         return $result->body;
  486.     }
  487.  
  488.     public function getHeaders()
  489.     {
  490.         $result = $this->performRequest();
  491.         return $result->headers;
  492.     }
  493.  
  494.     private function _startSession()
  495.     {
  496.         if (!headers_sent()) {
  497.             @session_start();
  498.         }
  499.     }
  500.  
  501.     private function _buildOfferUrl($params = array())
  502.     {
  503.         $request = parse_url($this->_trackerUrl);
  504.         $lastChar = substr($request['path'], -1);
  505.         if ($lastChar != '/' && $lastChar != '\\') {
  506.             $path = str_replace(basename($request['path']), '', $request['path']);
  507.         } else {
  508.             $path = $request['path'];
  509.         }
  510.         $path = ltrim($path, "\\\/");
  511.         $params = http_build_query($params);
  512.         return "{$request['scheme']}://{$request['host']}/{$path}?{$params}";
  513.     }
  514.  
  515.  
  516.     private function _getCurrentPage()
  517.     {
  518.         if ((isset($_SERVER['SERVER_PORT']) && $_SERVER['SERVER_PORT']  == 443) || !empty($_SERVER['HTTPS'])) {
  519.             $scheme = 'https';
  520.         } else {
  521.             $scheme = 'http';
  522.         }
  523.         return $scheme . '://' . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
  524.     }
  525.  
  526.     private function _buildRequestUrl()
  527.     {
  528.         $request = parse_url($this->_trackerUrl);
  529.         $url = "{$request['scheme']}://{$request['host']}";
  530.         if (isset($request['port'])) {
  531.             $url .= ':' . $request['port'];
  532.         }
  533.         $url .= "/{$request['path']}";
  534.         return $url;
  535.     }
  536.  
  537.  
  538.     private function _findIp()
  539.     {
  540.         $ip = null;
  541.         $headers = array(
  542.             'HTTP_X_FORWARDED_FOR',
  543.             'HTTP_FORWARDED_FOR',
  544.             'HTTP_X_FORWARDED',
  545.             'HTTP_FORWARDED',
  546.             'HTTP_CLIENT_IP',
  547.             'HTTP_FORWARDED_FOR_IP',
  548.             'X_FORWARDED_FOR',
  549.             'FORWARDED_FOR',
  550.             'X_FORWARDED',
  551.             'FORWARDED',
  552.             'CLIENT_IP',
  553.             'FORWARDED_FOR_IP',
  554.             'HTTP_PROXY_CONNECTION');
  555.         foreach ($headers as $header) {
  556.             if (!empty($_SERVER[$header])) {
  557.                 $tmp = explode(',', $_SERVER[$header]);
  558.                 $ip = trim($tmp[0]);
  559.                 break;
  560.             }
  561.         }
  562.         if (strstr($ip, ',')) {
  563.             $tmp = explode(',', $ip);
  564.             if (stristr($_SERVER['HTTP_USER_AGENT'], 'mini')) {
  565.                 $ip = trim($tmp[count($tmp) - 2]);
  566.             } else {
  567.                 $ip = trim($tmp[0]);
  568.             }
  569.         }
  570.  
  571.         if (empty($ip)) {
  572.             $ip = isset($_SERVER['REMOTE_ADDR']) ? $_SERVER['REMOTE_ADDR'] : '127.0.0.1';
  573.         }
  574.  
  575.         return $ip;
  576.     }
  577.  
  578.     private function _getCookiesExpireTimestamp($ttl)
  579.     {
  580.         return time() + 60 * 60 * $ttl;
  581.     }
  582.  
  583.     private function _getCookieHost()
  584.     {
  585.         if (isset($_SERVER['HTTP_HOST']) && substr_count($_SERVER['HTTP_HOST'], '.') < 3) {
  586.             $host = '.' . str_replace('www.', '', $_SERVER['HTTP_HOST']);
  587.         } else {
  588.             $host = null;
  589.         }
  590.         return $host;
  591.     }
  592.  
  593.     private function _getRequestOptions()
  594.     {
  595.         $opts = array();
  596.         if (isset($_SERVER["HTTP_COOKIE"])) {
  597.             $opts['cookies'] = preg_replace('/PHPSESSID=.*?;/si', '', $_SERVER["HTTP_COOKIE"]);
  598.         }
  599.  
  600.         return $opts;
  601.     }
  602. }
  603.  
  604. class ResponseExecutor
  605. {
  606.     public static function sendHeaders($result)
  607.     {
  608.         if (!empty($result->headers)) {
  609.             foreach ($result->headers as $header) {
  610.                 if (!headers_sent()) {
  611.                     header($header);
  612.                 }
  613.             }
  614.         }
  615.  
  616.         if (!empty($result->status)) {
  617.             http_response_code($result->status);
  618.         }
  619.  
  620.         if (!empty($result->contentType)) {
  621.             $header = 'Content-type: ' . $result->contentType;
  622.             $headers[] = $header;
  623.             if (!headers_sent()) {
  624.                 header($header);
  625.             }
  626.         }
  627.     }
  628.  
  629.     public static function containsActionHeader($headers)
  630.     {
  631.         if (empty($headers)) {
  632.             return false;
  633.         }
  634.         foreach ($headers as $header) {
  635.             if (strpos($header, 'Location:') === 0) {
  636.                 return true;
  637.             }
  638.             if (strstr($header, '404 Not Found')) {
  639.                 return true;
  640.             }
  641.         }
  642.         return false;
  643.     }
  644.  
  645. }
  646.  
  647. class KHttpClient
  648. {
  649.     const UA = 'KHttpClient';
  650.  
  651.     public function request($url, $params, $opts = array())
  652.     {
  653.         if (!function_exists('curl_init')) {
  654.             die('[KCLickClient Error] Extension \'php_curl\' must be installed');
  655.         }
  656.         $ch = curl_init();
  657.         curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
  658.         curl_setopt($ch, CURLOPT_URL, $url);
  659.         curl_setopt($ch, CURLOPT_HEADER, 0);
  660.         curl_setopt($ch, CURLOPT_COOKIE, isset($opts['cookies']) ? $opts['cookies'] : null);
  661.         curl_setopt($ch, CURLOPT_NOBODY, 0);
  662.         curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 5);
  663.         curl_setopt($ch, CURLOPT_TIMEOUT, 10);
  664.         curl_setopt($ch, CURLOPT_USERAGENT, self::UA);
  665.         curl_setopt($ch, CURLOPT_POST, 1);
  666.         curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($params));
  667.         curl_setopt($ch, CURLOPT_FAILONERROR, true);
  668.         $result = curl_exec($ch);
  669.         if (curl_error($ch)) {
  670.             throw new KTrafficClientError(curl_error($ch), curl_errno($ch));
  671.         }
  672.  
  673.         if (empty($result)) {
  674.             throw new KTrafficClientError('Empty response');
  675.         }
  676.         return $result;
  677.     }
  678. }
  679.  
  680. class KTrafficClientError extends Exception
  681. {
  682.     const ERROR_UNKNOWN = 'UNKNOWN';
  683.  
  684.     public function getHumanCode()
  685.     {
  686.         switch ($this->getCode()) {
  687.             case CURLE_HTTP_RETURNED_ERROR:
  688.                 preg_match(
  689.                     "/The requested URL returned error: (?'errorCode'\d+).*$/",
  690.                     $this->getMessage(),
  691.                     $matches
  692.                 );
  693.  
  694.                 $errorCode = isset($matches['errorCode']) ? $matches['errorCode'] : 'HTTP_ERROR_'.self::ERROR_UNKNOWN;
  695.                 return "[REQ_ERR: {$errorCode}]";
  696.             case CURLE_UNSUPPORTED_PROTOCOL:
  697.                 return "[REQ_ERR: UNSUPPORTED_PROTOCOL]";
  698.             case CURLE_FAILED_INIT:
  699.                 return "[REQ_ERR: FAILED_INIT]";
  700.             case CURLE_URL_MALFORMAT:
  701.                 return "[REQ_ERR: BAD_URL]";
  702.             case CURLE_COULDNT_RESOLVE_PROXY:
  703.                 return "[REQ_ERR: COULDNT_RESOLVE_PROXY]";
  704.             case CURLE_COULDNT_RESOLVE_HOST:
  705.                 return "[REQ_ERR: COULDNT_RESOLVE_HOST]";
  706.             case CURLE_COULDNT_CONNECT:
  707.                 return "[REQ_ERR: COULDNT_CONNECT]";
  708.             case CURLE_PARTIAL_FILE:
  709.                 return "[REQ_ERR: PARTIAL_FILE]";
  710.             case CURLE_READ_ERROR:
  711.                 return "[REQ_ERR: READ_ERROR]";
  712.             case CURLE_OUT_OF_MEMORY:
  713.                 return "[REQ_ERR: OUT_OF_MEMORY]";
  714.             case CURLE_OPERATION_TIMEDOUT:
  715.                 return "[REQ_ERR: OPERATION_TIMEDOUT]";
  716.             case CURLE_HTTP_POST_ERROR:
  717.                 return "[REQ_ERR: HTTP_POST_ERROR]";
  718.             case CURLE_BAD_FUNCTION_ARGUMENT:
  719.                 return "[REQ_ERR: BAD_FUNCTION_ARGUMENT]";
  720.             case CURLE_TOO_MANY_REDIRECTS:
  721.                 return "[REQ_ERR: TOO_MANY_REDIRECTS]";
  722.             case CURLE_GOT_NOTHING:
  723.                 return "[REQ_ERR: GOT_NOTHING]";
  724.             case CURLE_SEND_ERROR:
  725.                 return "[REQ_ERR: SEND_ERROR]";
  726.             case CURLE_RECV_ERROR:
  727.                 return "[REQ_ERR: RECV_ERROR]";
  728.             case CURLE_BAD_CONTENT_ENCODING:
  729.                 return "[REQ_ERR: BAD_CONTENT_ENCODING]";
  730.             case CURLE_SSL_CACERT:
  731.             case CURLE_SSL_CACERT_BADFILE:
  732.             case CURLE_SSL_CERTPROBLEM:
  733.             case CURLE_SSL_CIPHER:
  734.             case CURLE_SSL_CONNECT_ERROR:
  735.             case CURLE_SSL_ENGINE_NOTFOUND:
  736.             case CURLE_SSL_ENGINE_SETFAILED:
  737.             case CURLE_SSL_PEER_CERTIFICATE:
  738.             case CURLE_SSL_PINNEDPUBKEYNOTMATCH:
  739.                 return "[REQ_ERR: SSL]";
  740.             case CURLE_OK:
  741.                 return '';
  742.             default:
  743.                 return "[REQ_ERR: " . self::ERROR_UNKNOWN . "]";
  744.         }
  745.     }
  746. }
  747.  
  748. if (!function_exists('http_response_code')) {
  749.     function http_response_code($code = null)
  750.     {
  751.         if ($code !== null) {
  752.  
  753.             switch ($code) {
  754.                 case 100: $text = 'Continue'; break;
  755.                 case 101: $text = 'Switching Protocols'; break;
  756.                 case 200: $text = 'OK'; break;
  757.                 case 201: $text = 'Created'; break;
  758.                 case 202: $text = 'Accepted'; break;
  759.                 case 203: $text = 'Non-Authoritative Information'; break;
  760.                 case 204: $text = 'No Content'; break;
  761.                 case 205: $text = 'Reset Content'; break;
  762.                 case 206: $text = 'Partial Content'; break;
  763.                 case 300: $text = 'Multiple Choices'; break;
  764.                 case 301: $text = 'Moved Permanently'; break;
  765.                 case 302: $text = 'Moved Temporarily'; break;
  766.                 case 303: $text = 'See Other'; break;
  767.                 case 304: $text = 'Not Modified'; break;
  768.                 case 305: $text = 'Use Proxy'; break;
  769.                 case 400: $text = 'Bad Request'; break;
  770.                 case 401: $text = 'Unauthorized'; break;
  771.                 case 402: $text = 'The license must be in Pro edition or higher'; break;
  772.                 case 403: $text = 'Forbidden'; break;
  773.                 case 404: $text = 'Not Found'; break;
  774.                 case 405: $text = 'Method Not Allowed'; break;
  775.                 case 406: $text = 'Not Acceptable'; break;
  776.                 case 407: $text = 'Proxy Authentication Required'; break;
  777.                 case 408: $text = 'Request Time-out'; break;
  778.                 case 409: $text = 'Conflict'; break;
  779.                 case 410: $text = 'Gone'; break;
  780.                 case 411: $text = 'Length Required'; break;
  781.                 case 412: $text = 'Precondition Failed'; break;
  782.                 case 413: $text = 'Request Entity Too Large'; break;
  783.                 case 414: $text = 'Request-URI Too Large'; break;
  784.                 case 415: $text = 'Unsupported Media Type'; break;
  785.                 case 500: $text = 'Internal Server Error'; break;
  786.                 case 501: $text = 'Not Implemented'; break;
  787.                 case 502: $text = 'Bad Gateway'; break;
  788.                 case 503: $text = 'Service Unavailable'; break;
  789.                 case 504: $text = 'Gateway Time-out'; break;
  790.                 case 505: $text = 'HTTP Version not supported'; break;
  791.                 default:
  792.                     exit('Unknown http status code "' . htmlentities($code) . '"');
  793.                     break;
  794.             }
  795.  
  796.             $protocol = (isset($_SERVER['SERVER_PROTOCOL']) ? $_SERVER['SERVER_PROTOCOL'] : 'HTTP/1.0');
  797.  
  798.             header($protocol . ' ' . $code . ' ' . $text);
  799.  
  800.             $GLOBALS['http_response_code'] = $code;
  801.  
  802.         } else {
  803.  
  804.             $code = (isset($GLOBALS['http_response_code']) ? $GLOBALS['http_response_code'] : 200);
  805.  
  806.         }
  807.  
  808.         return $code;
  809.  
  810.     }
  811. }
  812.  
  813. if (!function_exists('getallheaders'))
  814. {
  815.     function getallheaders()
  816.     {
  817.         $headers = array();
  818.         foreach ($_SERVER as $name => $value)
  819.         {
  820.             if (substr($name, 0, 5) == 'HTTP_')
  821.             {
  822.                 $headers[str_replace(' ', '-', ucwords(strtolower(str_replace('_', ' ', substr($name, 5)))))] = $value;
  823.             }
  824.         }
  825.         return $headers;
  826.     }
  827. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!