<?php
namespace Curl;
use Curl\ArrayUtil;
use Curl\Decoder;
class Curl
{
const VERSION = '8.1.0';
const DEFAULT_TIMEOUT = 30;
public $curl;
public $id = null;
public $error = false;
public $errorCode = 0;
public $errorMessage = null;
public $curlError = false;
public $curlErrorCode = 0;
public $curlErrorMessage = null;
public $httpError = false;
public $httpStatusCode = 0;
public $httpErrorMessage = null;
public $url = null;
public $requestHeaders = null;
public $responseHeaders = null;
public $rawResponseHeaders = '';
public $responseCookies = array();
public $response = null;
public $rawResponse = null;
public $beforeSendCallback = null;
public $downloadCompleteCallback = null;
public $successCallback = null;
public $errorCallback = null;
public $completeCallback = null;
public $fileHandle = null;
public $attempts = 0;
public $retries = 0;
public $isChildOfMultiCurl = false;
public $remainingRetries = 0;
public $retryDecider = null;
public $jsonDecoder = null;
public $xmlDecoder = null;
private $cookies = array();
private $headers = array();
private $options = array();
private $jsonDecoderArgs = array();
private $jsonPattern = '/^(?:application|text)\/(?:[a-z]+(?:[\.-][0-9a-z]+){0,}[\+\.]|x-)?json(?:-[a-z]+)?/i';
private $xmlPattern = '~^(?:text/|application/(?:atom\+|rss\+|soap\+)?)xml~i';
private $defaultDecoder = null;
public static $RFC2616 = array(
// RFC 2616: "any CHAR except CTLs or separators".
// CHAR = <any US-ASCII character (octets 0 - 127)>
// CTL = <any US-ASCII control character
// (octets 0 - 31) and DEL (127)>
// separators = "(" | ")" | "<" | ">" | "@"
// | "," | ";" | ":" | "\" | <">
// | "/" | "[" | "]" | "?" | "="
// | "{" | "}" | SP | HT
// SP = <US-ASCII SP, space (32)>
// HT = <US-ASCII HT, horizontal-tab (9)>
// <"> = <US-ASCII double-quote mark (34)>
'!', '#', '$', '%', '&', "'", '*', '+', '-', '.', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q',
'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '|', '~',
);
public static $RFC6265 = array(
// RFC 6265: "US-ASCII characters excluding CTLs, whitespace DQUOTE, comma, semicolon, and backslash".
// %x21
'!',
// %x23-2B
'#', '$', '%', '&', "'", '(', ')', '*', '+',
// %x2D-3A
'-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':',
// %x3C-5B
'<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q',
'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[',
// %x5D-7E
']', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~',
);
private static $deferredProperties = array(
'effectiveUrl',
'rfc2616',
'rfc6265',
'totalTime',
);
/**
* Construct
*
* @access public
* @param $base_url
* @throws \ErrorException
*/
public function __construct($base_url = null)
{
if (!extension_loaded('curl')) {
throw new \ErrorException('cURL library is not loaded');
}
$this->curl = curl_init();
$this->initialize($base_url);
}
/**
* Before Send
*
* @access public
* @param $callback
*/
public function beforeSend($callback)
{
$this->beforeSendCallback = $callback;
}
/**
* Build Post Data
*
* @access public
* @param $data
*
* @return array|string
*/
public function buildPostData($data)
{
$binary_data = false;
if (is_array($data)) {
// Return JSON-encoded string when the request's content-type is JSON.
if (isset($this->headers['Content-Type']) &&
preg_match($this->jsonPattern, $this->headers['Content-Type'])) {
$json_str = json_encode($data);
if (!($json_str === false)) {
$data = $json_str;
}
} else {
// Manually build a single-dimensional array from a multi-dimensional array as using curl_setopt($ch,
// CURLOPT_POSTFIELDS, $data) doesn't correctly handle multi-dimensional arrays when files are
// referenced.
if (ArrayUtil::is_array_multidim($data)) {
$data = ArrayUtil::array_flatten_multidim($data);
}
// Modify array values to ensure any referenced files are properly handled depending on the support of
// the @filename API or CURLFile usage. This also fixes the warning "curl_setopt(): The usage of the
// @filename API for file uploading is deprecated. Please use the CURLFile class instead". Ignore
// non-file values prefixed with the @ character.
foreach ($data as $key => $value) {
if (is_string($value) && strpos($value, '@') === 0 && is_file(substr($value, 1))) {
$binary_data = true;
if (class_exists('CURLFile')) {
$data[$key] = new \CURLFile(substr($value, 1));
}
} elseif ($value instanceof \CURLFile) {
$binary_data = true;
}
}
}
}
if (!$binary_data && (is_array($data) || is_object($data))) {
$data = http_build_query($data, '', '&');
}
return $data;
}
/**
* Call
*
* @access public
*/
public function call()
{
$args = func_get_args();
$function = array_shift($args);
if (is_callable($function)) {
array_unshift($args, $this);
call_user_func_array($function, $args);
}
}
/**
* Close
*
* @access public
*/
public function close()
{
if (is_resource($this->curl)) {
curl_close($this->curl);
}
$this->options = null;
$this->jsonDecoder = null;
$this->jsonDecoderArgs = null;
$this->xmlDecoder = null;
$this->defaultDecoder = null;
}
/**
* Complete
*
* @access public
* @param $callback
*/
public function complete($callback)
{
$this->completeCallback = $callback;
}
/**
* Progress
*
* @access public
* @param $callback
*/
public function progress($callback)
{
$this->setOpt(CURLOPT_PROGRESSFUNCTION, $callback);
$this->setOpt(CURLOPT_NOPROGRESS, false);
}
/**
* Delete
*
* @access public
* @param $url
* @param $query_parameters
* @param $data
*
* @return mixed Returns the value provided by exec.
*/
public function delete($url, $query_parameters = array(), $data = array())
{
if (is_array($url)) {
$data = $query_parameters;
$query_parameters = $url;
$url = (string)$this->url;
}
$this->setUrl($url, $query_parameters);
$this->setOpt(CURLOPT_CUSTOMREQUEST, 'DELETE');
$this->setOpt(CURLOPT_POSTFIELDS, $this->buildPostData($data));
return $this->exec();
}
/**
* Download
*
* @access public
* @param $url
* @param $mixed_filename
*
* @return boolean
*/
public function download($url, $mixed_filename)
{
if (is_callable($mixed_filename)) {
$this->downloadCompleteCallback = $mixed_filename;
$this->fileHandle = tmpfile();
} else {
$filename = $mixed_filename;
// Use a temporary file when downloading. Not using a temporary file can cause an error when an existing
// file has already fully completed downloading and a new download is started with the same destination save
// path. The download request will include header "Range: bytes=$filesize-" which is syntactically valid,
// but unsatisfiable.
$download_filename = $filename . '.pccdownload';
$mode = 'wb';
// Attempt to resume download only when a temporary download file exists and is not empty.
if (file_exists($download_filename) && $filesize = filesize($download_filename)) {
$mode = 'ab';
$first_byte_position = $filesize;
$range = $first_byte_position . '-';
$this->setOpt(CURLOPT_RANGE, $range);
}
$this->fileHandle = fopen($download_filename, $mode);
// Move the downloaded temporary file to the destination save path.
$this->downloadCompleteCallback = function ($instance, $fh) use ($download_filename, $filename) {
// Close the open file handle before renaming the file.
if (is_resource($fh)) {
fclose($fh);
}
rename($download_filename, $filename);
};
}
$this->setOpt(CURLOPT_FILE, $this->fileHandle);
$this->get($url);
return ! $this->error;
}
/**
* Error
*
* @access public
* @param $callback
*/
public function error($callback)
{
$this->errorCallback = $callback;
}
/**
* Exec
*
* @access public
* @param $ch
*
* @return mixed Returns the value provided by parseResponse.
*/
public function exec($ch = null)
{
$this->attempts += 1;
if ($this->jsonDecoder === null) {
$this->setDefaultJsonDecoder();
}
if ($this->xmlDecoder === null) {
$this->setDefaultXmlDecoder();
}
if ($ch === null) {
$this->responseCookies = array();
$this->call($this->beforeSendCallback);
$this->rawResponse = curl_exec($this->curl);
$this->curlErrorCode = curl_errno($this->curl);
$this->curlErrorMessage = curl_error($this->curl);
} else {
$this->rawResponse = curl_multi_getcontent($ch);
$this->curlErrorMessage = curl_error($ch);
}
$this->curlError = !($this->curlErrorCode === 0);
// Transfer the header callback data and release the temporary store to avoid memory leak.
$this->rawResponseHeaders = $this->headerCallbackData->rawResponseHeaders;
$this->responseCookies = $this->headerCallbackData->responseCookies;
$this->headerCallbackData->rawResponseHeaders = null;
$this->headerCallbackData->responseCookies = null;
// Include additional error code information in error message when possible.
if ($this->curlError && function_exists('curl_strerror')) {
$this->curlErrorMessage =
curl_strerror($this->curlErrorCode) . (
empty($this->curlErrorMessage) ? '' : ': ' . $this->curlErrorMessage
);
}
$this->httpStatusCode = $this->getInfo(CURLINFO_HTTP_CODE);
$this->httpError = in_array(floor($this->httpStatusCode / 100), array(4, 5));
$this->error = $this->curlError || $this->httpError;
$this->errorCode = $this->error ? ($this->curlError ? $this->curlErrorCode : $this->httpStatusCode) : 0;
// NOTE: CURLINFO_HEADER_OUT set to true is required for requestHeaders
// to not be empty (e.g. $curl->setOpt(CURLINFO_HEADER_OUT, true);).
if ($this->getOpt(CURLINFO_HEADER_OUT) === true) {
$this->requestHeaders = $this->parseRequestHeaders($this->getInfo(CURLINFO_HEADER_OUT));
}
$this->responseHeaders = $this->parseResponseHeaders($this->rawResponseHeaders);
$this->response = $this->parseResponse($this->responseHeaders, $this->rawResponse);
$this->httpErrorMessage = '';
if ($this->error) {
if (isset($this->responseHeaders['Status-Line'])) {
$this->httpErrorMessage = $this->responseHeaders['Status-Line'];
}
}
$this->errorMessage = $this->curlError ? $this->curlErrorMessage : $this->httpErrorMessage;
// Reset select deferred properties so that they may be recalculated.
unset($this->effectiveUrl);
unset($this->totalTime);
// Reset content-length header possibly set from a PUT or SEARCH request.
$this->unsetHeader('Content-Length');
// Reset nobody setting possibly set from a HEAD request.
$this->setOpt(CURLOPT_NOBODY, false);
// Allow multicurl to attempt retry as needed.
if ($this->isChildOfMultiCurl) {
return;
}
if ($this->attemptRetry()) {
return $this->exec($ch);
}
$this->execDone();
return $this->response;
}
public function execDone()
{
if ($this->error) {
$this->call($this->errorCallback);
} else {
$this->call($this->successCallback);
}
$this->call($this->completeCallback);
// Close open file handles and reset the curl instance.
if (!($this->fileHandle === null)) {
$this->downloadComplete($this->fileHandle);
}
}
/**
* Get
*
* @access public
* @param $url
* @param $data
*
* @return mixed Returns the value provided by exec.
*/
public function get($url, $data = array())
{
if (is_array($url)) {
$data = $url;
$url = (string)$this->url;
}
$this->setUrl($url, $data);
$this->setOpt(CURLOPT_CUSTOMREQUEST, 'GET');
$this->setOpt(CURLOPT_HTTPGET, true);
return $this->exec();
}
/**
* Get Info
*
* @access public
* @param $opt
*
* @return mixed
*/
public function getInfo($opt = null)
{
$args = array();
$args[] = $this->curl;
if (func_num_args()) {
$args[] = $opt;
}
return call_user_func_array('curl_getinfo', $args);
}
/**
* Get Opt
*
* @access public
* @param $option
*
* @return mixed
*/
public function getOpt($option)
{
return isset($this->options[$option]) ? $this->options[$option] : null;
}
/**
* Head
*
* @access public
* @param $url
* @param $data
*
* @return mixed Returns the value provided by exec.
*/
public function head($url, $data = array())
{
if (is_array($url)) {
$data = $url;
$url = (string)$this->url;
}
$this->setUrl($url, $data);
$this->setOpt(CURLOPT_CUSTOMREQUEST, 'HEAD');
$this->setOpt(CURLOPT_NOBODY, true);
return $this->exec();
}
/**
* Options
*
* @access public
* @param $url
* @param $data
*
* @return mixed Returns the value provided by exec.
*/
public function options($url, $data = array())
{
if (is_array($url)) {
$data = $url;
$url = (string)$this->url;
}
$this->setUrl($url, $data);
$this->setOpt(CURLOPT_CUSTOMREQUEST, 'OPTIONS');
return $this->exec();
}
/**
* Patch
*
* @access public
* @param $url
* @param $data
*
* @return mixed Returns the value provided by exec.
*/
public function patch($url, $data = array())
{
if (is_array($url)) {
$data = $url;
$url = (string)$this->url;
}
if (is_array($data) && empty($data)) {
$this->removeHeader('Content-Length');
}
$this->setUrl($url);
$this->setOpt(CURLOPT_CUSTOMREQUEST, 'PATCH');
$this->setOpt(CURLOPT_POSTFIELDS, $this->buildPostData($data));
return $this->exec();
}
/**
* Post
*
* @access public
* @param $url
* @param $data
* @param $follow_303_with_post
* If true, will cause 303 redirections to be followed using a POST request (default: false).
* Notes:
* - Redirections are only followed if the CURLOPT_FOLLOWLOCATION option is set to true.
* - According to the HTTP specs (see [1]), a 303 redirection should be followed using
* the GET method. 301 and 302 must not.
* - In order to force a 303 redirection to be performed using the same method, the
* underlying cURL object must be set in a special state (the CURLOPT_CURSTOMREQUEST
* option must be set to the method to use after the redirection). Due to a limitation
* of the cURL extension of PHP < 5.5.11 ([2], [3]) and of HHVM, it is not possible
* to reset this option. Using these PHP engines, it is therefore impossible to
* restore this behavior on an existing php-curl-class Curl object.
*
* @return mixed Returns the value provided by exec.
*
* [1] https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.2
* [2] https://github.com/php/php-src/pull/531
* [3] http://php.net/ChangeLog-5.php#5.5.11
*/
public function post($url, $data = '', $follow_303_with_post = false)
{
if (is_array($url)) {
$follow_303_with_post = (bool)$data;
$data = $url;
$url = (string)$this->url;
}
$this->setUrl($url);
if ($follow_303_with_post) {
$this->setOpt(CURLOPT_CUSTOMREQUEST, 'POST');
} else {
if (isset($this->options[CURLOPT_CUSTOMREQUEST])) {
if ((version_compare(PHP_VERSION, '5.5.11') < 0) || defined('HHVM_VERSION')) {
trigger_error(
'Due to technical limitations of PHP <= 5.5.11 and HHVM, it is not possible to '
. 'perform a post-redirect-get request using a php-curl-class Curl object that '
. 'has already been used to perform other types of requests. Either use a new '
. 'php-curl-class Curl object or upgrade your PHP engine.',
E_USER_ERROR
);
} else {
$this->setOpt(CURLOPT_CUSTOMREQUEST, null);
}
}
}
$this->setOpt(CURLOPT_POST, true);
$this->setOpt(CURLOPT_POSTFIELDS, $this->buildPostData($data));
return $this->exec();
}
/**
* Put
*
* @access public
* @param $url
* @param $data
*
* @return mixed Returns the value provided by exec.
*/
public function put($url, $data = array())
{
if (is_array($url)) {
$data = $url;
$url = (string)$this->url;
}
$this->setUrl($url);
$this->setOpt(CURLOPT_CUSTOMREQUEST, 'PUT');
$put_data = $this->buildPostData($data);
if (empty($this->options[CURLOPT_INFILE]) && empty($this->options[CURLOPT_INFILESIZE])) {
if (is_string($put_data)) {
$this->setHeader('Content-Length', strlen($put_data));
}
}
if (!empty($put_data)) {
$this->setOpt(CURLOPT_POSTFIELDS, $put_data);
}
return $this->exec();
}
/**
* Search
*
* @access public
* @param $url
* @param $data
*
* @return mixed Returns the value provided by exec.
*/
public function search($url, $data = array())
{
if (is_array($url)) {
$data = $url;
$url = (string)$this->url;
}
$this->setUrl($url);
$this->setOpt(CURLOPT_CUSTOMREQUEST, 'SEARCH');
$put_data = $this->buildPostData($data);
if (empty($this->options[CURLOPT_INFILE]) && empty($this->options[CURLOPT_INFILESIZE])) {
if (is_string($put_data)) {
$this->setHeader('Content-Length', strlen($put_data));
}
}
if (!empty($put_data)) {
$this->setOpt(CURLOPT_POSTFIELDS, $put_data);
}
return $this->exec();
}
/**
* Set Basic Authentication
*
* @access public
* @param $username
* @param $password
*/
public function setBasicAuthentication($username, $password = '')
{
$this->setOpt(CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
$this->setOpt(CURLOPT_USERPWD, $username . ':' . $password);
}
/**
* Set Digest Authentication
*
* @access public
* @param $username
* @param $password
*/
public function setDigestAuthentication($username, $password = '')
{
$this->setOpt(CURLOPT_HTTPAUTH, CURLAUTH_DIGEST);
$this->setOpt(CURLOPT_USERPWD, $username . ':' . $password);
}
/**
* Set Cookie
*
* @access public
* @param $key
* @param $value
*/
public function setCookie($key, $value)
{
$this->setEncodedCookie($key, $value);
$this->buildCookies();
}
/**
* Set Cookies
*
* @access public
* @param $cookies
*/
public function setCookies($cookies)
{
foreach ($cookies as $key => $value) {
$this->setEncodedCookie($key, $value);
}
$this->buildCookies();
}
/**
* Get Cookie
*
* @access public
* @param $key
*
* @return mixed
*/
public function getCookie($key)
{
return $this->getResponseCookie($key);
}
/**
* Get Response Cookie
*
* @access public
* @param $key
*
* @return mixed
*/
public function getResponseCookie($key)
{
return isset($this->responseCookies[$key]) ? $this->responseCookies[$key] : null;
}
/**
* Get Response Cookies
*
* @access public
*
* @return array
*/
public function getResponseCookies()
{
return $this->responseCookies;
}
/**
* Set Max Filesize
*
* @access public
* @param $bytes
*/
public function setMaxFilesize($bytes)
{
// Make compatible with PHP version both before and after 5.5.0. PHP 5.5.0 added the cURL resource as the first
// argument to the CURLOPT_PROGRESSFUNCTION callback.
$gte_v550 = version_compare(PHP_VERSION, '5.5.0') >= 0;
if ($gte_v550) {
$callback = function ($resource, $download_size, $downloaded, $upload_size, $uploaded) use ($bytes) {
// Abort the transfer when $downloaded bytes exceeds maximum $bytes by returning a non-zero value.
return $downloaded > $bytes ? 1 : 0;
};
} else {
$callback = function ($download_size, $downloaded, $upload_size, $uploaded) use ($bytes) {
return $downloaded > $bytes ? 1 : 0;
};
}
$this->progress($callback);
}
/**
* Set Port
*
* @access public
* @param $port
*/
public function setPort($port)
{
$this->setOpt(CURLOPT_PORT, intval($port));
}
/**
* Set Connect Timeout
*
* @access public
* @param $seconds
*/
public function setConnectTimeout($seconds)
{
$this->setOpt(CURLOPT_CONNECTTIMEOUT, $seconds);
}
/**
* Set Cookie String
*
* @access public
* @param $string
*
* @return bool
*/
public function setCookieString($string)
{
return $this->setOpt(CURLOPT_COOKIE, $string);
}
/**
* Set Cookie File
*
* @access public
* @param $cookie_file
*
* @return boolean
*/
public function setCookieFile($cookie_file)
{
return $this->setOpt(CURLOPT_COOKIEFILE, $cookie_file);
}
/**
* Set Cookie Jar
*
* @access public
* @param $cookie_jar
*
* @return boolean
*/
public function setCookieJar($cookie_jar)
{
return $this->setOpt(CURLOPT_COOKIEJAR, $cookie_jar);
}
/**
* Set Default JSON Decoder
*
* @access public
* @param $assoc
* @param $depth
* @param $options
*/
public function setDefaultJsonDecoder()
{
$this->jsonDecoder = '\Curl\Decoder::decodeJson';
$this->jsonDecoderArgs = func_get_args();
}
/**
* Set Default XML Decoder
*
* @access public
*/
public function setDefaultXmlDecoder()
{
$this->xmlDecoder = '\Curl\Decoder::decodeXml';
}
/**
* Set Default Decoder
*
* @access public
* @param $mixed boolean|callable|string
*/
public function setDefaultDecoder($mixed = 'json')
{
if ($mixed === false) {
$this->defaultDecoder = false;
} elseif (is_callable($mixed)) {
$this->defaultDecoder = $mixed;
} else {
if ($mixed === 'json') {
$this->defaultDecoder = '\Curl\Decoder::decodeJson';
} elseif ($mixed === 'xml') {
$this->defaultDecoder = '\Curl\Decoder::decodeXml';
}
}
}
/**
* Set Default Timeout
*
* @access public
*/
public function setDefaultTimeout()
{
$this->setTimeout(self::DEFAULT_TIMEOUT);
}
/**
* Set Default User Agent
*
* @access public
*/
public function setDefaultUserAgent()
{
$user_agent = 'PHP-Curl-Class/' . self::VERSION . ' (+https://github.com/php-curl-class/php-curl-class)';
$user_agent .= ' PHP/' . PHP_VERSION;
$curl_version = curl_version();
$user_agent .= ' curl/' . $curl_version['version'];
$this->setUserAgent($user_agent);
}
/**
* Set Header
*
* Add extra header to include in the request.
*
* @access public
* @param $key
* @param $value
*/
public function setHeader($key, $value)
{
$this->headers[$key] = $value;
$headers = array();
foreach ($this->headers as $key => $value) {
$headers[] = $key . ': ' . $value;
}
$this->setOpt(CURLOPT_HTTPHEADER, $headers);
}
/**
* Set Headers
*
* Add extra headers to include in the request.
*
* @access public
* @param $headers
*/
public function setHeaders($headers)
{
foreach ($headers as $key => $value) {
$this->headers[$key] = $value;
}
$headers = array();
foreach ($this->headers as $key => $value) {
$headers[] = $key . ': ' . $value;
}
$this->setOpt(CURLOPT_HTTPHEADER, $headers);
}
/**
* Set JSON Decoder
*
* @access public
* @param $mixed boolean|callable
*/
public function setJsonDecoder($mixed)
{
if ($mixed === false) {
$this->jsonDecoder = false;
$this->jsonDecoderArgs = array();
} elseif (is_callable($mixed)) {
$this->jsonDecoder = $mixed;
$this->jsonDecoderArgs = array();
}
}
/**
* Set XML Decoder
*
* @access public
* @param $mixed boolean|callable
*/
public function setXmlDecoder($mixed)
{
if ($mixed === false) {
$this->xmlDecoder = false;
} elseif (is_callable($mixed)) {
$this->xmlDecoder = $mixed;
}
}
/**
* Set Opt
*
* @access public
* @param $option
* @param $value
*
* @return boolean
*/
public function setOpt($option, $value)
{
$required_options = array(
CURLOPT_RETURNTRANSFER => 'CURLOPT_RETURNTRANSFER',
);
if (in_array($option, array_keys($required_options), true) && !($value === true)) {
trigger_error($required_options[$option] . ' is a required option', E_USER_WARNING);
}
$success = curl_setopt($this->curl, $option, $value);
if ($success) {
$this->options[$option] = $value;
}
return $success;
}
/**
* Set Opts
*
* @access public
* @param $options
*
* @return boolean
* Returns true if all options were successfully set. If an option could not be successfully set, false is
* immediately returned, ignoring any future options in the options array. Similar to curl_setopt_array().
*/
public function setOpts($options)
{
foreach ($options as $option => $value) {
if (!$this->setOpt($option, $value)) {
return false;
}
}
return true;
}
/**
* Set Referer
*
* @access public
* @param $referer
*/
public function setReferer($referer)
{
$this->setReferrer($referer);
}
/**
* Set Referrer
*
* @access public
* @param $referrer
*/
public function setReferrer($referrer)
{
$this->setOpt(CURLOPT_REFERER, $referrer);
}
/**
* Set Retry
*
* Number of retries to attempt or decider callable. Maximum number of
* attempts is $maximum_number_of_retries + 1.
*
* @access public
* @param $mixed
*/
public function setRetry($mixed)
{
if (is_callable($mixed)) {
$this->retryDecider = $mixed;
} elseif (is_int($mixed)) {
$maximum_number_of_retries = $mixed;
$this->remainingRetries = $maximum_number_of_retries;
}
}
/**
* Set Timeout
*
* @access public
* @param $seconds
*/
public function setTimeout($seconds)
{
$this->setOpt(CURLOPT_TIMEOUT, $seconds);
}
/**
* Set Url
*
* @access public
* @param $url
* @param $mixed_data
*/
public function setUrl($url, $mixed_data = '')
{
$built_url = $this->buildUrl($url, $mixed_data);
if ($this->url === null) {
$this->url = (string)new Url($built_url);
} else {
$this->url = (string)new Url($this->url, $built_url);
}
$this->setOpt(CURLOPT_URL, $this->url);
}
/**
* Set User Agent
*
* @access public
* @param $user_agent
*/
public function setUserAgent($user_agent)
{
$this->setOpt(CURLOPT_USERAGENT, $user_agent);
}
/**
* Attempt Retry
*
* @access public
*/
public function attemptRetry()
{
$attempt_retry = false;
if ($this->error) {
if ($this->retryDecider === null) {
$attempt_retry = $this->remainingRetries >= 1;
} else {
$attempt_retry = call_user_func($this->retryDecider, $this);
}
if ($attempt_retry) {
$this->retries += 1;
if ($this->remainingRetries) {
$this->remainingRetries -= 1;
}
}
}
return $attempt_retry;
}
/**
* Success
*
* @access public
* @param $callback
*/
public function success($callback)
{
$this->successCallback = $callback;
}
/**
* Unset Header
*
* Remove extra header previously set using Curl::setHeader().
*
* @access public
* @param $key
*/
public function unsetHeader($key)
{
unset($this->headers[$key]);
$headers = array();
foreach ($this->headers as $key => $value) {
$headers[] = $key . ': ' . $value;
}
$this->setOpt(CURLOPT_HTTPHEADER, $headers);
}
/**
* Remove Header
*
* Remove an internal header from the request.
* Using `curl -H "Host:" ...' is equivalent to $curl->removeHeader('Host');.
*
* @access public
* @param $key
*/
public function removeHeader($key)
{
$this->setHeader($key, '');
}
/**
* Verbose
*
* @access public
* @param bool $on
* @param resource $output
*/
public function verbose($on = true, $output = STDERR)
{
// Turn off CURLINFO_HEADER_OUT for verbose to work. This has the side
// effect of causing Curl::requestHeaders to be empty.
if ($on) {
$this->setOpt(CURLINFO_HEADER_OUT, false);
}
$this->setOpt(CURLOPT_VERBOSE, $on);
$this->setOpt(CURLOPT_STDERR, $output);
}
/**
* Reset
*
* @access public
*/
public function reset()
{
if (function_exists('curl_reset') && is_resource($this->curl)) {
curl_reset($this->curl);
} else {
$this->curl = curl_init();
}
$this->initialize();
}
/**
* Destruct
*
* @access public
*/
public function __destruct()
{
$this->close();
}
public function __get($name)
{
$return = null;
if (in_array($name, self::$deferredProperties) && is_callable(array($this, $getter = '__get_' . $name))) {
$return = $this->$name = $this->$getter();
}
return $return;
}
/**
* Get Effective Url
*
* @access private
*/
private function __get_effectiveUrl()
{
return $this->getInfo(CURLINFO_EFFECTIVE_URL);
}
/**
* Get RFC 2616
*
* @access private
*/
private function __get_rfc2616()
{
return array_fill_keys(self::$RFC2616, true);
}
/**
* Get RFC 6265
*
* @access private
*/
private function __get_rfc6265()
{
return array_fill_keys(self::$RFC6265, true);
}
/**
* Get Total Time
*
* @access private
*/
private function __get_totalTime()
{
return $this->getInfo(CURLINFO_TOTAL_TIME);
}
/**
* Build Cookies
*
* @access private
*/
private function buildCookies()
{
// Avoid using http_build_query() as unnecessary encoding is performed.
// http_build_query($this->cookies, '', '; ');
$this->setOpt(CURLOPT_COOKIE, implode('; ', array_map(function ($k, $v) {
return $k . '=' . $v;
}, array_keys($this->cookies), array_values($this->cookies))));
}
/**
* Build Url
*
* @access private
* @param $url
* @param $mixed_data
*
* @return string
*/
private function buildUrl($url, $mixed_data = '')
{
$query_string = '';
if (!empty($mixed_data)) {
$query_mark = strpos($url, '?') > 0 ? '&' : '?';
if (is_string($mixed_data)) {
$query_string .= $query_mark . $mixed_data;
} elseif (is_array($mixed_data)) {
$query_string .= $query_mark . http_build_query($mixed_data, '', '&');
}
}
return $url . $query_string;
}
/**
* Download Complete
*
* @access private
* @param $fh
*/
private function downloadComplete($fh)
{
if (!$this->error && $this->downloadCompleteCallback) {
rewind($fh);
$this->call($this->downloadCompleteCallback, $fh);
$this->downloadCompleteCallback = null;
}
if (is_resource($fh)) {
fclose($fh);
}
// Fix "PHP Notice: Use of undefined constant STDOUT" when reading the
// PHP script from stdin. Using null causes "Warning: curl_setopt():
// supplied argument is not a valid File-Handle resource".
if (!defined('STDOUT')) {
define('STDOUT', fopen('php://stdout', 'w'));
}
// Reset CURLOPT_FILE with STDOUT to avoid: "curl_exec(): CURLOPT_FILE
// resource has gone away, resetting to default".
$this->setOpt(CURLOPT_FILE, STDOUT);
// Reset CURLOPT_RETURNTRANSFER to tell cURL to return subsequent
// responses as the return value of curl_exec(). Without this,
// curl_exec() will revert to returning boolean values.
$this->setOpt(CURLOPT_RETURNTRANSFER, true);
}
/**
* Parse Headers
*
* @access private
* @param $raw_headers
*
* @return array
*/
private function parseHeaders($raw_headers)
{
$raw_headers = preg_split('/\r\n/', $raw_headers, null, PREG_SPLIT_NO_EMPTY);
$http_headers = new CaseInsensitiveArray();
$raw_headers_count = count($raw_headers);
for ($i = 1; $i < $raw_headers_count; $i++) {
if (strpos($raw_headers[$i], ':') !== false) {
list($key, $value) = explode(':', $raw_headers[$i], 2);
$key = trim($key);
$value = trim($value);
// Use isset() as array_key_exists() and ArrayAccess are not compatible.
if (isset($http_headers[$key])) {
$http_headers[$key] .= ',' . $value;
} else {
$http_headers[$key] = $value;
}
}
}
return array(isset($raw_headers['0']) ? $raw_headers['0'] : '', $http_headers);
}
/**
* Parse Request Headers
*
* @access private
* @param $raw_headers
*
* @return \Curl\CaseInsensitiveArray
*/
private function parseRequestHeaders($raw_headers)
{
$request_headers = new CaseInsensitiveArray();
list($first_line, $headers) = $this->parseHeaders($raw_headers);
$request_headers['Request-Line'] = $first_line;
foreach ($headers as $key => $value) {
$request_headers[$key] = $value;
}
return $request_headers;
}
/**
* Parse Response
*
* @access private
* @param $response_headers
* @param $raw_response
*
* @return mixed
* If the response content-type is json:
* Returns the json decoder's return value: A stdClass object when the default json decoder is used.
* If the response content-type is xml:
* Returns the xml decoder's return value: A SimpleXMLElement object when the default xml decoder is used.
* If the response content-type is something else:
* Returns the original raw response unless a default decoder has been set.
* If the response content-type cannot be determined:
* Returns the original raw response.
*/
private function parseResponse($response_headers, $raw_response)
{
$response = $raw_response;
if (isset($response_headers['Content-Type'])) {
if (preg_match($this->jsonPattern, $response_headers['Content-Type'])) {
if ($this->jsonDecoder) {
$args = $this->jsonDecoderArgs;
array_unshift($args, $response);
$response = call_user_func_array($this->jsonDecoder, $args);
}
} elseif (preg_match($this->xmlPattern, $response_headers['Content-Type'])) {
if ($this->xmlDecoder) {
$response = call_user_func($this->xmlDecoder, $response);
}
} else {
if ($this->defaultDecoder) {
$response = call_user_func($this->defaultDecoder, $response);
}
}
}
return $response;
}
/**
* Parse Response Headers
*
* @access private
* @param $raw_response_headers
*
* @return \Curl\CaseInsensitiveArray
*/
private function parseResponseHeaders($raw_response_headers)
{
$response_header_array = explode("\r\n\r\n", $raw_response_headers);
$response_header = '';
for ($i = count($response_header_array) - 1; $i >= 0; $i--) {
if (stripos($response_header_array[$i], 'HTTP/') === 0) {
$response_header = $response_header_array[$i];
break;
}
}
$response_headers = new CaseInsensitiveArray();
list($first_line, $headers) = $this->parseHeaders($response_header);
$response_headers['Status-Line'] = $first_line;
foreach ($headers as $key => $value) {
$response_headers[$key] = $value;
}
return $response_headers;
}
/**
* Set Encoded Cookie
*
* @access private
* @param $key
* @param $value
*/
private function setEncodedCookie($key, $value)
{
$name_chars = array();
foreach (str_split($key) as $name_char) {
if (isset($this->rfc2616[$name_char])) {
$name_chars[] = $name_char;
} else {
$name_chars[] = rawurlencode($name_char);
}
}
$value_chars = array();
foreach (str_split($value) as $value_char) {
if (isset($this->rfc6265[$value_char])) {
$value_chars[] = $value_char;
} else {
$value_chars[] = rawurlencode($value_char);
}
}
$this->cookies[implode('', $name_chars)] = implode('', $value_chars);
}
/**
* Initialize
*
* @access private
* @param $base_url
*/
private function initialize($base_url = null)
{
$this->id = uniqid('', true);
$this->setDefaultUserAgent();
$this->setDefaultTimeout();
$this->setOpt(CURLINFO_HEADER_OUT, true);
// Create a placeholder to temporarily store the header callback data.
$header_callback_data = new \stdClass();
$header_callback_data->rawResponseHeaders = '';
$header_callback_data->responseCookies = array();
$this->headerCallbackData = $header_callback_data;
$this->setOpt(CURLOPT_HEADERFUNCTION, createHeaderCallback($header_callback_data));
$this->setOpt(CURLOPT_RETURNTRANSFER, true);
$this->headers = new CaseInsensitiveArray();
$this->setUrl($base_url);
}
}
/**
* Create Header Callback
*
* Gather headers and parse cookies as response headers are received. Keep this function separate from the class so that
* unset($curl) automatically calls __destruct() as expected. Otherwise, manually calling $curl->close() will be
* necessary to prevent a memory leak.
*
* @param $header_callback_data
*
* @return callable
*/
function createHeaderCallback($header_callback_data) {
return function ($ch, $header) use ($header_callback_data) {
if (preg_match('/^Set-Cookie:\s*([^=]+)=([^;]+)/mi', $header, $cookie) === 1) {
$header_callback_data->responseCookies[$cookie[1]] = trim($cookie[2], " \n\r\t\0\x0B");
}
$header_callback_data->rawResponseHeaders .= $header;
return strlen($header);
};
}