Curl error message php

you can generate curl error after its execution

$url = 'http://example.com';

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$result = curl_exec($ch);
if(curl_errno($ch)){
    echo 'Request Error:' . curl_error($ch);
}

and here are curl error code

if someone need more information about curl errors

<?php

    $error_codes=array(
    [1] => 'CURLE_UNSUPPORTED_PROTOCOL',
    [2] => 'CURLE_FAILED_INIT',
    [3] => 'CURLE_URL_MALFORMAT',
    [4] => 'CURLE_URL_MALFORMAT_USER',
    [5] => 'CURLE_COULDNT_RESOLVE_PROXY',
    [6] => 'CURLE_COULDNT_RESOLVE_HOST',
    [7] => 'CURLE_COULDNT_CONNECT',
    [8] => 'CURLE_FTP_WEIRD_SERVER_REPLY',
    [9] => 'CURLE_REMOTE_ACCESS_DENIED',
    [11] => 'CURLE_FTP_WEIRD_PASS_REPLY',
    [13] => 'CURLE_FTP_WEIRD_PASV_REPLY',
    [14]=>'CURLE_FTP_WEIRD_227_FORMAT',
    [15] => 'CURLE_FTP_CANT_GET_HOST',
    [17] => 'CURLE_FTP_COULDNT_SET_TYPE',
    [18] => 'CURLE_PARTIAL_FILE',
    [19] => 'CURLE_FTP_COULDNT_RETR_FILE',
    [21] => 'CURLE_QUOTE_ERROR',
    [22] => 'CURLE_HTTP_RETURNED_ERROR',
    [23] => 'CURLE_WRITE_ERROR',
    [25] => 'CURLE_UPLOAD_FAILED',
    [26] => 'CURLE_READ_ERROR',
    [27] => 'CURLE_OUT_OF_MEMORY',
    [28] => 'CURLE_OPERATION_TIMEDOUT',
    [30] => 'CURLE_FTP_PORT_FAILED',
    [31] => 'CURLE_FTP_COULDNT_USE_REST',
    [33] => 'CURLE_RANGE_ERROR',
    [34] => 'CURLE_HTTP_POST_ERROR',
    [35] => 'CURLE_SSL_CONNECT_ERROR',
    [36] => 'CURLE_BAD_DOWNLOAD_RESUME',
    [37] => 'CURLE_FILE_COULDNT_READ_FILE',
    [38] => 'CURLE_LDAP_CANNOT_BIND',
    [39] => 'CURLE_LDAP_SEARCH_FAILED',
    [41] => 'CURLE_FUNCTION_NOT_FOUND',
    [42] => 'CURLE_ABORTED_BY_CALLBACK',
    [43] => 'CURLE_BAD_FUNCTION_ARGUMENT',
    [45] => 'CURLE_INTERFACE_FAILED',
    [47] => 'CURLE_TOO_MANY_REDIRECTS',
    [48] => 'CURLE_UNKNOWN_TELNET_OPTION',
    [49] => 'CURLE_TELNET_OPTION_SYNTAX',
    [51] => 'CURLE_PEER_FAILED_VERIFICATION',
    [52] => 'CURLE_GOT_NOTHING',
    [53] => 'CURLE_SSL_ENGINE_NOTFOUND',
    [54] => 'CURLE_SSL_ENGINE_SETFAILED',
    [55] => 'CURLE_SEND_ERROR',
    [56] => 'CURLE_RECV_ERROR',
    [58] => 'CURLE_SSL_CERTPROBLEM',
    [59] => 'CURLE_SSL_CIPHER',
    [60] => 'CURLE_SSL_CACERT',
    [61] => 'CURLE_BAD_CONTENT_ENCODING',
    [62] => 'CURLE_LDAP_INVALID_URL',
    [63] => 'CURLE_FILESIZE_EXCEEDED',
    [64] => 'CURLE_USE_SSL_FAILED',
    [65] => 'CURLE_SEND_FAIL_REWIND',
    [66] => 'CURLE_SSL_ENGINE_INITFAILED',
    [67] => 'CURLE_LOGIN_DENIED',
    [68] => 'CURLE_TFTP_NOTFOUND',
    [69] => 'CURLE_TFTP_PERM',
    [70] => 'CURLE_REMOTE_DISK_FULL',
    [71] => 'CURLE_TFTP_ILLEGAL',
    [72] => 'CURLE_TFTP_UNKNOWNID',
    [73] => 'CURLE_REMOTE_FILE_EXISTS',
    [74] => 'CURLE_TFTP_NOSUCHUSER',
    [75] => 'CURLE_CONV_FAILED',
    [76] => 'CURLE_CONV_REQD',
    [77] => 'CURLE_SSL_CACERT_BADFILE',
    [78] => 'CURLE_REMOTE_FILE_NOT_FOUND',
    [79] => 'CURLE_SSH',
    [80] => 'CURLE_SSL_SHUTDOWN_FAILED',
    [81] => 'CURLE_AGAIN',
    [82] => 'CURLE_SSL_CRL_BADFILE',
    [83] => 'CURLE_SSL_ISSUER_ERROR',
    [84] => 'CURLE_FTP_PRET_FAILED',
    [84] => 'CURLE_FTP_PRET_FAILED',
    [85] => 'CURLE_RTSP_CSEQ_ERROR',
    [86] => 'CURLE_RTSP_SESSION_ERROR',
    [87] => 'CURLE_FTP_BAD_FILE_LIST',
    [88] => 'CURLE_CHUNK_FAILED');

    ?>

curl_getinfo

(PHP 4 >= 4.0.4, PHP 5, PHP 7, PHP

curl_getinfo — Get information regarding a specific transfer

Description

Gets information about the last transfer.

Parameters

A cURL handle returned by curl_init() .

This may be one of the following constants:

• CURLINFO_EFFECTIVE_URL — Last effective URL
• CURLINFO_HTTP_CODE — The last response code. As of cURL 7.10.8, this is a legacy alias of CURLINFO_RESPONSE_CODE
• CURLINFO_FILETIME — Remote time of the retrieved document, with the CURLOPT_FILETIME enabled; if -1 is returned the time of the document is unknown
• CURLINFO_TOTAL_TIME — Total transaction time in seconds for last transfer
• CURLINFO_NAMELOOKUP_TIME — Time in seconds until name resolving was complete
• CURLINFO_CONNECT_TIME — Time in seconds it took to establish the connection
• CURLINFO_PRETRANSFER_TIME — Time in seconds from start until just before file transfer begins
• CURLINFO_STARTTRANSFER_TIME — Time in seconds until the first byte is about to be transferred
• CURLINFO_REDIRECT_COUNT — Number of redirects, with the CURLOPT_FOLLOWLOCATION option enabled
• CURLINFO_REDIRECT_TIME — Time in seconds of all redirection steps before final transaction was started, with the CURLOPT_FOLLOWLOCATION option enabled
• CURLINFO_REDIRECT_URL — With the CURLOPT_FOLLOWLOCATION option disabled: redirect URL found in the last transaction, that should be requested manually next. With the CURLOPT_FOLLOWLOCATION option enabled: this is empty. The redirect URL in this case is available in CURLINFO_EFFECTIVE_URL
• CURLINFO_PRIMARY_IP — IP address of the most recent connection
• CURLINFO_PRIMARY_PORT — Destination port of the most recent connection
• CURLINFO_LOCAL_IP — Local (source) IP address of the most recent connection
• CURLINFO_LOCAL_PORT — Local (source) port of the most recent connection
• CURLINFO_SIZE_UPLOAD — Total number of bytes uploaded
• CURLINFO_SIZE_DOWNLOAD — Total number of bytes downloaded
• CURLINFO_SPEED_DOWNLOAD — Average download speed
• CURLINFO_SPEED_UPLOAD — Average upload speed
• CURLINFO_HEADER_SIZE — Total size of all headers received
• CURLINFO_HEADER_OUT — The request string sent. For this to work, add the CURLINFO_HEADER_OUT option to the handle by calling curl_setopt()
• CURLINFO_REQUEST_SIZE — Total size of issued requests, currently only for HTTP requests
• CURLINFO_SSL_VERIFYRESULT — Result of SSL certification verification requested by setting CURLOPT_SSL_VERIFYPEER
• CURLINFO_CONTENT_LENGTH_DOWNLOAD — Content length of download, read from Content-Length: field
• CURLINFO_CONTENT_LENGTH_UPLOAD — Specified size of upload
• CURLINFO_CONTENT_TYPE — Content-Type: of the requested document. NULL indicates server did not send valid Content-Type: header
• CURLINFO_PRIVATE — Private data associated with this cURL handle, previously set with the CURLOPT_PRIVATE option of curl_setopt()
• CURLINFO_RESPONSE_CODE — The last response code
• CURLINFO_HTTP_CONNECTCODE — The CONNECT response code
• CURLINFO_HTTPAUTH_AVAIL — Bitmask indicating the authentication method(s) available according to the previous response
• CURLINFO_PROXYAUTH_AVAIL — Bitmask indicating the proxy authentication method(s) available according to the previous response
• CURLINFO_OS_ERRNO — Errno from a connect failure. The number is OS and system specific.
• CURLINFO_NUM_CONNECTS — Number of connections curl had to create to achieve the previous transfer
• CURLINFO_SSL_ENGINES — OpenSSL crypto-engines supported
• CURLINFO_COOKIELIST — All known cookies
• CURLINFO_FTP_ENTRY_PATH — Entry path in FTP server
• CURLINFO_APPCONNECT_TIME — Time in seconds it took from the start until the SSL/SSH connect/handshake to the remote host was completed
• CURLINFO_CERTINFO — TLS certificate chain
• CURLINFO_CONDITION_UNMET — Info on unmet time conditional
• CURLINFO_RTSP_CLIENT_CSEQ — Next RTSP client CSeq
• CURLINFO_RTSP_CSEQ_RECV — Recently received CSeq
• CURLINFO_RTSP_SERVER_CSEQ — Next RTSP server CSeq
• CURLINFO_RTSP_SESSION_ID — RTSP session ID
• CURLINFO_CONTENT_LENGTH_DOWNLOAD_T — The content-length of the download. This is the value read from the Content-Type: field. -1 if the size isn’t known
• CURLINFO_CONTENT_LENGTH_UPLOAD_T — The specified size of the upload. -1 if the size isn’t known
• CURLINFO_HTTP_VERSION — The version used in the last HTTP connection. The return value will be one of the defined CURL_HTTP_VERSION_* constants or 0 if the version can’t be determined
• CURLINFO_PROTOCOL — The protocol used in the last HTTP connection. The returned value will be exactly one of the CURLPROTO_* values
• CURLINFO_PROXY_SSL_VERIFYRESULT — The result of the certificate verification that was requested (using the CURLOPT_PROXY_SSL_VERIFYPEER option). Only used for HTTPS proxies
• CURLINFO_SCHEME — The URL scheme used for the most recent connection
• CURLINFO_SIZE_DOWNLOAD_T — Total number of bytes that were downloaded. The number is only for the latest transfer and will be reset again for each new transfer
• CURLINFO_SIZE_UPLOAD_T — Total number of bytes that were uploaded
• CURLINFO_SPEED_DOWNLOAD_T — The average download speed in bytes/second that curl measured for the complete download
• CURLINFO_SPEED_UPLOAD_T — The average upload speed in bytes/second that curl measured for the complete upload
• CURLINFO_APPCONNECT_TIME_T — Time, in microseconds, it took from the start until the SSL/SSH connect/handshake to the remote host was completed
• CURLINFO_CONNECT_TIME_T — Total time taken, in microseconds, from the start until the connection to the remote host (or proxy) was completed
• CURLINFO_FILETIME_T — Remote time of the retrieved document (as Unix timestamp), an alternative to CURLINFO_FILETIME to allow systems with 32 bit long variables to extract dates outside of the 32bit timestamp range
• CURLINFO_NAMELOOKUP_TIME_T — Time in microseconds from the start until the name resolving was completed
• CURLINFO_PRETRANSFER_TIME_T — Time taken from the start until the file transfer is just about to begin, in microseconds
• CURLINFO_REDIRECT_TIME_T — Total time, in microseconds, it took for all redirection steps include name lookup, connect, pretransfer and transfer before final transaction was started
• CURLINFO_STARTTRANSFER_TIME_T — Time, in microseconds, it took from the start until the first byte is received
• CURLINFO_TOTAL_TIME_T — Total time in microseconds for the previous transfer, including name resolving, TCP connect etc.

Return Values

If option is given, returns its value. Otherwise, returns an associative array with the following elements (which correspond to option ), or false on failure:

• «url»
• «content_type»
• «http_code»
• «header_size»
• «request_size»
• «filetime»
• «ssl_verify_result»
• «redirect_count»
• «total_time»
• «namelookup_time»
• «connect_time»
• «pretransfer_time»
• «size_upload»
• «size_download»
• «speed_download»
• «speed_upload»
• «download_content_length»
• «upload_content_length»
• «starttransfer_time»
• «redirect_time»
• «certinfo»
• «primary_ip»
• «primary_port»
• «local_ip»
• «local_port»
• «redirect_url»
• «request_header» (This is only set if the CURLINFO_HEADER_OUT is set by a previous call to curl_setopt() )

Note that private data is not included in the associative array and must be retrieved individually with the CURLINFO_PRIVATE option.

Changelog

Examples

Example #1 curl_getinfo() example

// Create a cURL handle
$ch = curl_init ( ‘http://www.example.com/’ );

// Execute
curl_exec ( $ch );

// Check if any error occurred
if (! curl_errno ( $ch )) <
$info = curl_getinfo ( $ch );
echo ‘Took ‘ , $info [ ‘total_time’ ], ‘ seconds to send a request to ‘ , $info [ ‘url’ ], «n» ;
>

// Close handle
curl_close ( $ch );
?>

Example #2 curl_getinfo() example with option parameter

// Create a cURL handle
$ch = curl_init ( ‘http://www.example.com/’ );

// Execute
curl_exec ( $ch );

// Check HTTP status code
if (! curl_errno ( $ch )) <
switch ( $http_code = curl_getinfo ( $ch , CURLINFO_HTTP_CODE )) <
case 200 : # OK
break;
default:
echo ‘Unexpected HTTP code: ‘ , $http_code , «n» ;
>
>

// Close handle
curl_close ( $ch );
?>

Notes

Information gathered by this function is kept if the handle is re-used. This means that unless a statistic is overridden internally by this function, the previous info is returned.

User Contributed Notes 12 notes

Here are the response codes ready for pasting in an ini-style file. Can be used to provide more descriptive message, corresponding to ‘http_code’ index of the arrray returned by curl_getinfo().
These are taken from the W3 consortium HTTP/1.1: Status Code Definitions, found at
http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html

[Informational 1xx]
100=»Continue»
101=»Switching Protocols»

[Successful 2xx]
200=»OK»
201=»Created»
202=»Accepted»
203=»Non-Authoritative Information»
204=»No Content»
205=»Reset Content»
206=»Partial Content»

[Redirection 3xx]
300=»Multiple Choices»
301=»Moved Permanently»
302=»Found»
303=»See Other»
304=»Not Modified»
305=»Use Proxy»
306=»(Unused)»
307=»Temporary Redirect»

[Client Error 4xx]
400=»Bad Request»
401=»Unauthorized»
402=»Payment Required»
403=»Forbidden»
404=»Not Found»
405=»Method Not Allowed»
406=»Not Acceptable»
407=»Proxy Authentication Required»
408=»Request Timeout»
409=»Conflict»
410=»Gone»
411=»Length Required»
412=»Precondition Failed»
413=»Request Entity Too Large»
414=»Request-URI Too Long»
415=»Unsupported Media Type»
416=»Requested Range Not Satisfiable»
417=»Expectation Failed»

[Server Error 5xx]
500=»Internal Server Error»
501=»Not Implemented»
502=»Bad Gateway»
503=»Service Unavailable»
504=»Gateway Timeout»
505=»HTTP Version Not Supported»

And an example usage:
= curl_init (); // create cURL handle (ch)
if (! $ch ) <
die( «Couldn’t initialize a cURL handle» );
>
// set some cURL options
$ret = curl_setopt ( $ch , CURLOPT_URL , «http://mail.yahoo.com» );
$ret = curl_setopt ( $ch , CURLOPT_HEADER , 1 );
$ret = curl_setopt ( $ch , CURLOPT_FOLLOWLOCATION , 1 );
$ret = curl_setopt ( $ch , CURLOPT_RETURNTRANSFER , 0 );
$ret = curl_setopt ( $ch , CURLOPT_TIMEOUT , 30 );

// execute
$ret = curl_exec ( $ch );

if (empty( $ret )) <
// some kind of an error happened
die( curl_error ( $ch ));
curl_close ( $ch ); // close cURL handler
> else <
$info = curl_getinfo ( $ch );
curl_close ( $ch ); // close cURL handler

if (empty( $info [ ‘http_code’ ])) <
die( «No HTTP code was returned» );
> else <
// load the HTTP codes
$http_codes = parse_ini_file ( «path/to/the/ini/file/I/pasted/above» );

// echo results
echo «The server responded:
» ;
echo $info [ ‘http_code’ ] . » » . $http_codes [ $info [ ‘http_code’ ]];
>

Источник

curl_exec

(PHP 4 >= 4.0.2, PHP 5, PHP 7, PHP

curl_exec — Perform a cURL session

Description

Execute the given cURL session.

This function should be called after initializing a cURL session and all the options for the session are set.

Parameters

A cURL handle returned by curl_init() .

Return Values

Returns true on success or false on failure. However, if the CURLOPT_RETURNTRANSFER option is set, it will return the result on success, false on failure.

This function may return Boolean false , but may also return a non-Boolean value which evaluates to false . Please read the section on Booleans for more information. Use the === operator for testing the return value of this function.

Note that response status codes which indicate errors (such as 404 Not found ) are not regarded as failure. curl_getinfo() can be used to check for these.

Changelog

Examples

Example #1 Fetching a web page

// create a new cURL resource
$ch = curl_init ();

// set URL and other appropriate options
curl_setopt ( $ch , CURLOPT_URL , «http://www.example.com/» );
curl_setopt ( $ch , CURLOPT_HEADER , 0 );

// grab URL and pass it to the browser
curl_exec ( $ch );

// close cURL resource, and free up system resources
curl_close ( $ch );
?>

See Also

• curl_multi_exec() — Run the sub-connections of the current cURL handle

User Contributed Notes 23 notes

Just in case anyone is looking for a a couple of simple functions [to help automate cURL processes for POST and GET queries] I thought I’d post these.

/**
* Send a POST requst using cURL
* @param string $url to request
* @param array $post values to send
* @param array $options for cURL
* @return string
*/
function curl_post ( $url , array $post = NULL , array $options = array())
<
$defaults = array(
CURLOPT_POST => 1 ,
CURLOPT_HEADER => 0 ,
CURLOPT_URL => $url ,
CURLOPT_FRESH_CONNECT => 1 ,
CURLOPT_RETURNTRANSFER => 1 ,
CURLOPT_FORBID_REUSE => 1 ,
CURLOPT_TIMEOUT => 4 ,
CURLOPT_POSTFIELDS => http_build_query ( $post )
);

$ch = curl_init ();
curl_setopt_array ( $ch , ( $options + $defaults ));
if( ! $result = curl_exec ( $ch ))
<
trigger_error ( curl_error ( $ch ));
>
curl_close ( $ch );
return $result ;
>

/**
* Send a GET requst using cURL
* @param string $url to request
* @param array $get values to send
* @param array $options for cURL
* @return string
*/
function curl_get ( $url , array $get = NULL , array $options = array())
<
$defaults = array(
CURLOPT_URL => $url . ( strpos ( $url , ‘?’ ) === FALSE ? ‘?’ : » ). http_build_query ( $get ),
CURLOPT_HEADER => 0 ,
CURLOPT_RETURNTRANSFER => TRUE ,
CURLOPT_TIMEOUT => 4
);

$ch = curl_init ();
curl_setopt_array ( $ch , ( $options + $defaults ));
if( ! $result = curl_exec ( $ch ))
<
trigger_error ( curl_error ( $ch ));
>
curl_close ( $ch );
return $result ;
>
?>

Don’t disable SSL verification! You don’t need to, and it’s super easy to stay secure! If you found that turning off «CURLOPT_SSL_VERIFYHOST» and «CURLOPT_SSL_VERIFYPEER» solved your problem, odds are you’re just on a Windows box. Takes 2 min to solve the problem. Walkthrough here:

Be careful when using curl_exec() and the CURLOPT_RETURNTRANSFER option. According to the manual and assorted documentation:
Set CURLOPT_RETURNTRANSFER to TRUE to return the transfer as a string of the return value of curl_exec() instead of outputting it out directly.

When retrieving a document with no content (ie. 0 byte file), curl_exec() will return bool(true), not an empty string. I’ve not seen any mention of this in the manual.

Example code to reproduce this:
// fictional URL to an existing file with no data in it (ie. 0 byte file)
$url = ‘http://www.example.com/empty_file.txt’ ;

curl_setopt ( $curl , CURLOPT_URL , $url );
curl_setopt ( $curl , CURLOPT_RETURNTRANSFER , true );
curl_setopt ( $curl , CURLOPT_HEADER , false );

// execute and return string (this should be an empty string »)
$str = curl_exec ( $curl );

// the value of $str is actually bool(true), not empty string »
var_dump ( $str );

If you are looking the debug curl_exec, you may wish to log its details, and analyze the various time points during its execution.

// this will produce a curl log
curl_setopt ( $curl , CURLOPT_VERBOSE , true );
curl_setopt ( $curl , CURLOPT_STDERR , fopen ( ‘/your/writable/app/logdir/curl.log’ , ‘a+’ )); // a+ to append.
?>

after curl_exec, but before curl_close:

// this will extract the timing information
extract ( curl_getinfo ( $curl )); // create metrics variables from getinfo
$appconnect_time = curl_getinfo ( $curl , CURLINFO_APPCONNECT_TIME ); // request this time explicitly
$downloadduration = number_format ( $total_time — $starttransfer_time , 9 ); // format, to get rid of scientific notation
$namelookup_time = number_format ( $namelookup_time , 9 );
$metrics = «CURL. $url Time. $total_time DNS: $namelookup_time Connect: $connect_time SSL/SSH: $appconnect_time PreTransfer: $pretransfer_time StartTransfer: $starttransfer_time Download: $downloadduration » ;
error_log ( $metrics ); // write to php-fpm default www-error.log, or append it to same log as above with file_put_contents( , $metrics, FILE_APPEND)
?>

Happy debugging

class CurlRequest
<
private $ch ;
/**
* Init curl session
*
* $params = array(‘url’ => »,
* ‘host’ => »,
* ‘header’ => »,
* ‘method’ => »,
* ‘referer’ => »,
* ‘cookie’ => »,
* ‘post_fields’ => »,
* [‘login’ => »,]
* [‘password’ => »,]
* ‘timeout’ => 0
* );
*/
public function init ( $params )
<
$this -> ch = curl_init ();
$user_agent = ‘Mozilla/5.0 (Windows; U;
Windows NT 5.1; ru; rv:1.8.0.9) Gecko/20061206 Firefox/1.5.0.9′ ;
$header = array(
«Accept: text/xml,application/xml,application/xhtml+xml,
text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5″ ,
«Accept-Language: ru-ru,ru;q=0.7,en-us;q=0.5,en;q=0.3» ,
«Accept-Charset: windows-1251,utf-8;q=0.7,*;q=0.7» ,
«Keep-Alive: 300» );
if (isset( $params [ ‘host’ ]) && $params [ ‘host’ ]) $header []= «Host: » . $host ;
if (isset( $params [ ‘header’ ]) && $params [ ‘header’ ]) $header []= $params [ ‘header’ ];

@ curl_setopt ( $this -> ch , CURLOPT_RETURNTRANSFER , 1 );
@ curl_setopt ( $this -> ch , CURLOPT_VERBOSE , 1 );
@ curl_setopt ( $this -> ch , CURLOPT_HEADER , 1 );

if ( $params [ ‘method’ ] == «HEAD» ) @ curl_setopt ( $this -> ch , CURLOPT_NOBODY , 1 );
@ curl_setopt ( $this -> ch , CURLOPT_FOLLOWLOCATION , 1 );
@ curl_setopt ( $this -> ch , CURLOPT_HTTPHEADER , $header );
if ( $params [ ‘referer’ ]) @ curl_setopt ( $this -> ch , CURLOPT_REFERER , $params [ ‘referer’ ] );
@ curl_setopt ( $this -> ch , CURLOPT_USERAGENT , $user_agent );
if ( $params [ ‘cookie’ ]) @ curl_setopt ( $this -> ch , CURLOPT_COOKIE , $params [ ‘cookie’ ]);

if ( $params [ ‘method’ ] == «POST» )
<
curl_setopt ( $this -> ch , CURLOPT_POST , true );
curl_setopt ( $this -> ch , CURLOPT_POSTFIELDS , $params [ ‘post_fields’ ] );
>
@ curl_setopt ( $this -> ch , CURLOPT_URL , $params [ ‘url’ ]);
@ curl_setopt ( $this -> ch , CURLOPT_SSL_VERIFYPEER , 0 );
@ curl_setopt ( $this -> ch , CURLOPT_SSL_VERIFYHOST , 0 );
if (isset( $params [ ‘login’ ]) & isset( $params [ ‘password’ ]))
@ curl_setopt ( $this -> ch , CURLOPT_USERPWD , $params [ ‘login’ ]. ‘:’ . $params [ ‘password’ ]);
@ curl_setopt ( $this -> ch , CURLOPT_TIMEOUT , $params [ ‘timeout’ ]);
>

/**
* Make curl request
*
* @return array ‘header’,’body’,’curl_error’,’http_code’,’last_url’
*/
public function exec ()
<
$response = curl_exec ( $this -> ch );
$error = curl_error ( $this -> ch );
$result = array( ‘header’ => » ,
‘body’ => » ,
‘curl_error’ => » ,
‘http_code’ => » ,
‘last_url’ => » );
if ( $error != «» )
<
$result [ ‘curl_error’ ] = $error ;
return $result ;
>

$header_size = curl_getinfo ( $this -> ch , CURLINFO_HEADER_SIZE );
$result [ ‘header’ ] = substr ( $response , 0 , $header_size );
$result [ ‘body’ ] = substr ( $response , $header_size );
$result [ ‘http_code’ ] = curl_getinfo ( $this -> ch , CURLINFO_HTTP_CODE );
$result [ ‘last_url’ ] = curl_getinfo ( $this -> ch , CURLINFO_EFFECTIVE_URL );
return $result ;
>
>
?>

Example of use:
.
try
<
$params = array( ‘url’ => ‘http://www.google.com’ ,
‘host’ => » ,
‘header’ => » ,
‘method’ => ‘GET’ , // ‘POST’,’HEAD’
‘referer’ => » ,
‘cookie’ => » ,
‘post_fields’ => » , // ‘var1=value&var2=value
‘timeout’ => 20
);

$this -> curl -> init ( $params );
$result = $this -> curl -> exec ();
if ( $result [ ‘curl_error’ ]) throw new Exception ( $result [ ‘curl_error’ ]);
if ( $result [ ‘http_code’ ]!= ‘200’ ) throw new Exception ( «HTTP Code = » . $result [ ‘http_code’ ]);
if (! $result [ ‘body’ ]) throw new Exception ( «Body of file is empty» );
.
>
catch ( Exception $e )
<
echo $e -> getMessage ();
>
?>

Источник

Я использую функции PHP curl для отправки данных на веб-сервер с моей локальной машины. Мой код выглядит следующим образом:

$c = curl_init();

curl_setopt($c, CURLOPT_URL, $url);

curl_setopt($c, CURLOPT_RETURNTRANSFER, true);

curl_setopt($c, CURLOPT_POST, true);

curl_setopt($c, CURLOPT_POSTFIELDS, $data);

$result = curl_exec($c);

if (curl_exec($c) === false) {

    echo «ok»;

} else {

    echo «error»;

}

curl_close($c);

 К сожалению, я не могу поймать ни одной ошибки типа 404, 500 или сетевого уровня. Как же мне узнать, что данные не были размещены или получены с удаленного сервера?

Ответ 1

Вы можете использовать функцию curl_error(), чтобы определить, произошла ли какая-то ошибка. Например:

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $your_url);

curl_setopt($ch, CURLOPT_FAILONERROR, true); // Требуется для того, чтобы коды ошибок HTTP сообщались через наш вызов к curl_error($ch)

//…

curl_exec($ch);

if (curl_errno($ch)) {

    $error_msg = curl_error($ch);

}

curl_close($ch);

if (isset($error_msg)) {

    // TODO — Обработать ошибку cURL соответствующим образом

}

Ответ 2

Если CURLOPT_FAILONERROR равно false, ошибки http не будут вызывать ошибок curl.

<?php

if (@$_GET[‘curl’]==»yes») {

  header(‘HTTP/1.1 503 Service Temporarily Unavailable’);

} else {

  $ch=curl_init($url = «http://».$_SERVER[‘SERVER_NAME’].$_SERVER[‘PHP_SELF’].»?curl=yes»);

  curl_setopt($ch, CURLOPT_FAILONERROR, true);

  $response=curl_exec($ch);

  $http_status = curl_getinfo($ch, CURLINFO_HTTP_CODE);

  $curl_errno= curl_errno($ch);

  if ($http_status==503)

    echo «HTTP Status == 503 <br/>»;

  echo «Curl Errno returned $curl_errno <br/>»;

}

Ответ 3

Вы можете сгенерировать ошибку curl после его выполнения:

$url = ‘http://example.com’;

$ch = curl_init($url);

curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$result = curl_exec($ch);

if(curl_errno($ch)){

    echo ‘Request Error:’ . curl_error($ch);

}

 И вот коды ошибок curl:

если кому-то нужна дополнительная информация об ошибках curl

<?php

    $error_codes=array(

    [1] => ‘CURLE_UNSUPPORTED_PROTOCOL’,

    [2] => ‘CURLE_FAILED_INIT’,

    [3] => ‘CURLE_URL_MALFORMAT’,

    [4] => ‘CURLE_URL_MALFORMAT_USER’,

    [5] => ‘CURLE_COULDNT_RESOLVE_PROXY’,

    [6] => ‘CURLE_COULDNT_RESOLVE_HOST’,

    [7] => ‘CURLE_COULDNT_CONNECT’,

    [8] => ‘CURLE_FTP_WEIRD_SERVER_REPLY’,

    [9] => ‘CURLE_REMOTE_ACCESS_DENIED’,

    [11] => ‘CURLE_FTP_WEIRD_PASS_REPLY’,

    [13] => ‘CURLE_FTP_WEIRD_PASV_REPLY’,

    [14]=>’CURLE_FTP_WEIRD_227_FORMAT’,

    [15] => ‘CURLE_FTP_CANT_GET_HOST’,

    [17] => ‘CURLE_FTP_COULDNT_SET_TYPE’,

    [18] => ‘CURLE_PARTIAL_FILE’,

    [19] => ‘CURLE_FTP_COULDNT_RETR_FILE’,

    [21] => ‘CURLE_QUOTE_ERROR’,

    [22] => ‘CURLE_HTTP_RETURNED_ERROR’,

    [23] => ‘CURLE_WRITE_ERROR’,

    [25] => ‘CURLE_UPLOAD_FAILED’,

    [26] => ‘CURLE_READ_ERROR’,

    [27] => ‘CURLE_OUT_OF_MEMORY’,

    [28] => ‘CURLE_OPERATION_TIMEDOUT’,

    [30] => ‘CURLE_FTP_PORT_FAILED’,

    [31] => ‘CURLE_FTP_COULDNT_USE_REST’,

    [33] => ‘CURLE_RANGE_ERROR’,

    [34] => ‘CURLE_HTTP_POST_ERROR’,

    [35] => ‘CURLE_SSL_CONNECT_ERROR’,

    [36] => ‘CURLE_BAD_DOWNLOAD_RESUME’,

    [37] => ‘CURLE_FILE_COULDNT_READ_FILE’,

    [38] => ‘CURLE_LDAP_CANNOT_BIND’,

    [39] => ‘CURLE_LDAP_SEARCH_FAILED’,

    [41] => ‘CURLE_FUNCTION_NOT_FOUND’,

    [42] => ‘CURLE_ABORTED_BY_CALLBACK’,

    [43] => ‘CURLE_BAD_FUNCTION_ARGUMENT’,

    [45] => ‘CURLE_INTERFACE_FAILED’,

    [47] => ‘CURLE_TOO_MANY_REDIRECTS’,

    [48] => ‘CURLE_UNKNOWN_TELNET_OPTION’,

    [49] => ‘CURLE_TELNET_OPTION_SYNTAX’,

    [51] => ‘CURLE_PEER_FAILED_VERIFICATION’,

    [52] => ‘CURLE_GOT_NOTHING’,

    [53] => ‘CURLE_SSL_ENGINE_NOTFOUND’,

    [54] => ‘CURLE_SSL_ENGINE_SETFAILED’,

    [55] => ‘CURLE_SEND_ERROR’,

    [56] => ‘CURLE_RECV_ERROR’,

    [58] => ‘CURLE_SSL_CERTPROBLEM’,

    [59] => ‘CURLE_SSL_CIPHER’,

    [60] => ‘CURLE_SSL_CACERT’,

    [61] => ‘CURLE_BAD_CONTENT_ENCODING’,

    [62] => ‘CURLE_LDAP_INVALID_URL’,

    [63] => ‘CURLE_FILESIZE_EXCEEDED’,

    [64] => ‘CURLE_USE_SSL_FAILED’,

    [65] => ‘CURLE_SEND_FAIL_REWIND’,

    [66] => ‘CURLE_SSL_ENGINE_INITFAILED’,

    [67] => ‘CURLE_LOGIN_DENIED’,

    [68] => ‘CURLE_TFTP_NOTFOUND’,

    [69] => ‘CURLE_TFTP_PERM’,

    [70] => ‘CURLE_REMOTE_DISK_FULL’,

    [71] => ‘CURLE_TFTP_ILLEGAL’,

    [72] => ‘CURLE_TFTP_UNKNOWNID’,

    [73] => ‘CURLE_REMOTE_FILE_EXISTS’,

    [74] => ‘CURLE_TFTP_NOSUCHUSER’,

    [75] => ‘CURLE_CONV_FAILED’,

    [76] => ‘CURLE_CONV_REQD’,

    [77] => ‘CURLE_SSL_CACERT_BADFILE’,

    [78] => ‘CURLE_REMOTE_FILE_NOT_FOUND’,

    [79] => ‘CURLE_SSH’,

    [80] => ‘CURLE_SSL_SHUTDOWN_FAILED’,

    [81] => ‘CURLE_AGAIN’,

    [82] => ‘CURLE_SSL_CRL_BADFILE’,

    [83] => ‘CURLE_SSL_ISSUER_ERROR’,

    [84] => ‘CURLE_FTP_PRET_FAILED’,

    [84] => ‘CURLE_FTP_PRET_FAILED’,

    [85] => ‘CURLE_RTSP_CSEQ_ERROR’,

    [86] => ‘CURLE_RTSP_SESSION_ERROR’,

    [87] => ‘CURLE_FTP_BAD_FILE_LIST’,

    [88] => ‘CURLE_CHUNK_FAILED’);

    ?>

Ответ 4

Поскольку вы заинтересованы в отлове ошибок, связанных с сетью, и ошибок HTTP, ниже приведен лучший подход:

function curl_error_test($url) {

    $ch = curl_init();

    curl_setopt($ch, CURLOPT_URL, $url);

    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    $responseBody = curl_exec($ch);

    /*

     * if curl_exec failed then

     * $responseBody равно false

     * curl_errno() возвращает ненулевое число

     * curl_error() возвращает непустую строку

     * Какой из них использовать — решать вам

     */

    if ($responseBody === false) {

        return «CURL Error: » . curl_error($ch);

    }

    $responseCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

    /*

     * 4xx коды состояния — ошибки клиента

     * 5xx коды состояния — ошибки сервера

     */

    if ($responseCode >= 400) {

        return «HTTP Error: » . $responseCode;

    }

    return «Нет ошибки CURL или HTTP «;

}

 Тесты:

curl_error_test(«http://expamle.com»);          //  Ошибка CURL : Невозможно определить хост : expamle.com

curl_error_test(«http://example.com/whatever»); // Ошибка HTTP: 404

curl_error_test(«http://example.com»);          // Все в порядке с CURL или HTTP

Ответ 5

Еще один вариант кода:

  $responseInfo = curl_getinfo($ch);

    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

    $header_size = curl_getinfo($ch, CURLINFO_HEADER_SIZE);

    $body = substr($response, $header_size);

    $result=array();

    $result[‘httpCode’]=$httpCode;

    $result[‘body’]=json_decode($body);

    $result[‘responseInfo’]=$responseInfo;

    print_r($httpCode); 

     print_r($result[‘body’]); exit;

    curl_close($ch);

    if($httpCode == 403) {

        print_r(«Доступ запрещен»);

        exit;

    }   else {

         // другие ошибки 

     }

PHP’s cURL functions are extremely useful for sending HTTP requests.

Some examples of its usefulness.

• Retrieving data from an external API.
• Sending data to an external web service.
• Checking to see if a HTTP resource exists.
• Crawling / scraping web pages (logging into other websites with PHP).

Although you can easily request external content via the function file_get_contents, cURL is much more useful in the sense that it allows us to detect and handle certain HTTP errors.

Let’s take the following example.

$url = 'http://example.com';
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$result = curl_exec($ch);
echo $result;

As you can see, we have setup a very simple GET request that returns the contents of a website called example.com.

Unfortunately, this code doesn’t take into account the fact that the cURL request could fail. As a result, the request might fail without providing us with any details about what happened.

Using curl_errno to detect cURL errors.

This is where the curl_errno function comes in handy.

The curl_errno function will return the number 0 (zero) if the request was successful. In other words, it will return a “falsey” value if no error occurs. This is because PHP sees 0 as a false value in a boolean context.

This allows us to figure out whether or not our cURL request resulted in an error.

Take a look at the following example.

$url = 'http://example.com';

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$result = curl_exec($ch);
if(curl_errno($ch)){
    echo 'Request Error:' . curl_error($ch);
}

If an error occurs, then our script will print out the result of the curl_error function.

Throwing Exceptions.

In certain situations, you might want to throw an exception if a cURL request fails.

For this example, let us pretend that we have an object function called get.

/**
 * Send a GET request to a URL.
 * 
 * @param string $url
 * @return string
 * @throws Exception If cURL request fails.
 */
public function get($url){
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $result = curl_exec($ch);
    if(curl_errno($ch)){
        throw new Exception(curl_error($ch));
    }
    return $result;
}

As you can see, the function above will attempt to send a GET request to a given URL.

If all goes well, the function will return the contents of the URL.

However, if the request fails and a cURL error exists, PHP will throw an Exception.

This allows us to handle the request like so.

try{
    $object->get('http://test.com');
} catch(Exception $e){
    //do something with the exception you caught
}

In the above piece of code, we are using a TRY-CATCH block.

If we do not want our application to continue after a failed HTTP request, we can omit the TRY-CATCH block and let our Exception Handler deal with it.

PHP поддерживает libcurl, библиотеку, созданную Daniel»ом Stenberg»ом,
которая даёт возможность соединяться с серверами различных типов и по разным протоколам.
libcurl в настоящее время поддерживает протоколы http, https, ftp, gopher, telnet, dict, file и ldap.
libcurl также поддерживает сертификаты HTTPS, HTTP POST, HTTP PUT, загрузку по FTP (это можно сделать также РНР-расширением ftp),
загрузку на основе форм HTTP, прокси, куки и аутентификацию user+password.

Эти функции были введены в PHP 4.0.2.

curl_init

curl_init — инициализирует CURL-сессию.

Описание

resource curl_init([string url])

Функция curl_init() инициализирует новую сессию и возвратит CURL-дескриптор для
использования в функциях curl_setopt(),
curl_exec() и curl_close().
Если необязательный параметр url предоставлен, то опция
CURLOPT_URL получит значение этого параметра. Вы можете вручную устанавливать его с помощью функции
curl_setopt().

curl_setopt

curl_setopt — устанавливает опции для CURL-трансфера/transfer.

Описание

bool curl_setopt (resource ch, string option, mixed value)

Функция curl_setopt() устанавливает опции для CURL-сессии, идентифицируемой параметром ch.
Параметр option является опцией, которую вы хотите установить, а value это значение опции
option.

Параметр value должен быть long для следующих опций (специфицированных параметром option):

• CURLOPT_INFILESIZE: Если вы выгружаете файл на удалённый сайт, эта опция должна использоваться,
  для того чтобы сообщит PHP, какой будет ожидаемый размер infile.
• CURLOPT_VERBOSE: Установите эту опцию в ненулевое значение, если вы хотите, чтобы CURL
  сообщала обо всех действиях.
• CURLOPT_HEADER: Установите эту опцию в ненулевое значение, если вы хотите, чтобы шапка/header
  включалась в вывод.
• CURLOPT_NOPROGRESS: Установите эту опцию в ненулевое значение, если вы не хотите, чтобы PHP
  выводил индикатор процесса CURL-трансфера.
  (PHP автоматически устанавливает эту опцию в ненулевое значение, изменять её необходимо лишь при отладке.)
• CURLOPT_NOBODY: Установите эту опцию в ненулевое значение, если вы не хотите, чтобы тело/body
  включалось в вывод.
• CURLOPT_FAILONERROR: Установите эту опцию в ненулевое значение, если вы хотите, чтобы PHP завершал
  работу скрыто, если возвращаемый HTTP-код имеет значение выше 300. По
  умолчанию страница возвращается нормально с игнорированием кода.
• CURLOPT_UPLOAD: Установите эту опцию в ненулевое значение, если вы хотите, чтобы PHP
  подготавливал файл к выгрузке.
• CURLOPT_POST: Установите эту опцию в ненулевое значение, если вы хотите, чтобы PHP выполнял
  регулярный HTTP POST. Этот POST имеет нормальный вид application/x-www-form-urlencoded, чаще всего используемый HTML-формами.
• CURLOPT_FTPLISTONLY: Установите эту опцию в ненулевое значение, и PHP будет выводит листинг имён FTP-директории.
• CURLOPT_FTPAPPEND: Установите эту опцию в ненулевое значение, и PHP будет присоединять к
  удалённому/remote файлу, вместо его перезаписи.
• CURLOPT_NETRC: Установите эту опцию в ненулевое значение, и PHP будет сканировать ваш файл
  ~./netrc с целью поиска ваших username и password для удалённого сайта, с которым вы
  устанавливаете соединение.
• CURLOPT_FOLLOWLOCATION: Установите эту опцию в ненулевое значение, чтобы следовать любому «Location: » header,
  который сервер высылает как часть HTTP header»а (заметьте,
  что это рекурсия, PHP будет следовать за всеми «Location: «-header»ами, которые высылаются.)
• CURLOPT_PUT: Установите эту опцию в ненулевое значение, чтобы HTTP PUT файл. Файл для PUT
  обязан быть установлен с помощью CURLOPT_INFILE и CURLOPT_INFILESIZE.
• CURLOPT_MUTE: Установите эту опцию в ненулевое значение, и PHP будет работать скрыто в
  отношении CURL-функций.
• CURLOPT_TIMEOUT: Передаёт long как параметр, который содержит максимальное время в секундах,
  которое вы отводите для работы CURL-функций.
• CURLOPT_CONNECTTIMEOUT: Передаёт long как параметр, который содержит максимальное время в секундах,
  которое вы отводите для ожидания при попытке подключения. Используйте 0 чтобы ждать бесконечно.
• CURLOPT_LOW_SPEED_LIMIT: Передаёт long как параметр, который содержит скорость трансфера в байтах в
  секунду, ниже которого трансфер должен работать в процессе выполнения
  CURLOPT_LOW_SPEED_TIME, в секундах, чтобы PHP считал его слишком медленным и прерывал его.
• CURLOPT_LOW_SPEED_TIME: Передаёт long как параметр, который содержит время в секундах, ниже которого
  трансфер должен работать в процессе выполнения CURLOPT_LOW_SPEED_LIMIT,
  чтобы PHP считал его слишком медленным и прерывал его.
• CURLOPT_RESUME_FROM: Передаёт long как параметр, который содержит смещение в байтах, с которого
  трансфер должен стартовать.
• CURLOPT_SSLVERSION: Передаёт long как параметр, который содержит используемую версию SSL (2 или 3).
  По умолчанию PHP пытается определить это сам, хотя в некоторых случаях вы обязаны устанавливать это вручную.
• CURLOPT_SSL_VERIFYHOST: Передаёт long, если
  CURL должна проверять Common-имя peer-сертификата в SSL handshake/»рукопожатие». Значение 1 указывает, что мы должны
  проверить существование общего /common имени, значение 2 указывает, что мы
  должны убедиться в совпадении с предоставленным hostname.
• CURLOPT_TIMECONDITION: Передаёт long как параметр, который определяет, как рассматривается CURLOPT_TIMEVALUE.
  Вы можете установить этот параметр для TIMECOND_IFMODSINCE или
  TIMECOND_ISUNMODSINCE. Это действует только для HTTP.
• CURLOPT_TIMEVALUE: Передаёт long как параметр, который является временем в секундах, прошедшим
  после 1 января 1970. Это время используется, как специфицировано опцией CURLOPT_TIMEVALUE,
  или по умолчанию будет использоваться TIMECOND_IFMODSINCE.
• CURLOPT_RETURNTRANSFER: Передаёт ненулевое значение, если вы хотите, чтобы CURL непосредственно
  возвращала полученную информацию, вместо её печати напрямую.

Параметр value должен быть строкой для следующих значений параметра option:

• CURLOPT_URL: Это URL, который PHP должен получать. Вы можете также устанавливать эту
  опцию при инициализации сессии функцией curl_init().
• CURLOPT_USERPWD: Передаёт в РНР строку, отформатированную в виде [username]:[password], для
  использования при соединении.
• CURLOPT_PROXYUSERPWD: Передаёт в РНР строку, отформатированную в виде [username]:[password], для
  соединения с HTTP-прокси.
• CURLOPT_RANGE:
  Передаёт специфицированный вами диапазон. Он должен быть в формате
  «X-Y», где X или Y могут отсутствовать. HTTP-трансферы поддерживают
  также различные интервалы, разделённые запятыми, как, например, X-Y,N-M.
• CURLOPT_POSTFIELDS: Передаёт строку, содержащую полные данные для передачи операцией HTTP «POST».
• CURLOPT_REFERER: Передаёт строку, содержащую «referer/ссылающийся» header, используемый в HTTP-запросе.
• CURLOPT_USERAGENT: Передаёт строку, содержащую «user-agent» header, используемый в HTTP-запросе.
• CURLOPT_FTPPORT: Передаёт строку, содержащую значение, которое будет использоваться для
  получения IP-адреса для инструкции ftp «POST». POST-инструкция указывает
  удалённому серверу: соединиться со специфицированным IP-адресом. Строка
  может быть обычным IP-адресом, hostname/именем хоста, именем сетевого
  интерфейса (под UNIX), или просто обычным «-«, используемым для системного IP-адреса по умолчанию.
• CURLOPT_COOKIE: Передаёт строку с содержимым куки/cookie, установленным в HTTP header»е.
• CURLOPT_SSLCERT: Передаёт строку, содержащую filename форматированного сертификата PEM.
• CURLOPT_SSLCERTPASSWD: Передаёт строку, содержащую password, необходимый для работы сертификата CURLOPT_SSLCERT.
• CURLOPT_COOKIEFILE: Передаёт строку, содержащую имя файла с данными куки.
  Этот cookie-файл может иметь формат Netscape, или содержать обычные
  шапки/headers в HTTP-стиле, забитые в файл.
• CURLOPT_CUSTOMREQUEST: Передаёт строку, используемую вместо
  GET или HEAD при выполнении HTTP-запроса. Это делается для выполнения DELETE или других, более скрытых HTTP-запросов.
  Верными значениями являются GET, POST и так далее; то есть не вводите здесь полную строку HTTP-запроса.
  Например, ввод «GET /index.html HTTP/1.0» будет некорректным.
  (не делайте это, если не уверены, что ваш сервер поддерживает эту команду.)
• CURLOPT_PROXY: Передаёт имя HTTP-прокси туннельным запросам.
• CURLOPT_INTERFACE: Передаёт имя исходящего сетевого интерфейса для использования. Это может
  быть имя интерфейса, IP-адрес или имя хоста.

( curl_setopt($ch, CURLOPT_INTERFACE, $extip) )

• CURLOPT_KRB4LEVEL: Передаёт KRB4 (Kerberos
  4) уровень секретности. Это любая из следующих строк (в порядке от менее до более мощной): «clear», «safe»,
  «confidential», «private».
  Если эта строка не совпадает с какой-либо из указанных, то используется «private».
  Если вы установите здесь NULL, это отключит KRB4-безопасность. KRB4-безопасность работает в настоящее
  время только с транзакциями FTP.
• CURLOPT_HTTPHEADER: Передаёт массив полей HTTP-header»а для установки.
• CURLOPT_QUOTE: Передаёт массив FTP-команд для выполнения на сервере до выполнения FTP-запроса.
• CURLOPT_POSTQUOTE: Передаёт массив FTP-команд для выполнения на сервере после выполнения FTP-запроса.

Следующие опции ожидают дескриптора файла, который получается с помощью функции
fopen():

• CURLOPT_FILE: Файл, куда должен быть помещён вывод вашего трансфера, по умолчанию это STDOUT.
• CURLOPT_INFILE: Файл, из которого приходит ввод вашего трансфера.
• CURLOPT_WRITEHEADER: Файл для записи header-части вывода.
• CURLOPT_STDERR: Файл для записи ошибок, вместо stderr.

Параметр value должен быть функцией следующего вида
long write_callback (resource ch, string data){ … return strlen($data);}
для следующих значений параметра option:

• CURLOPT_WRITEFUNCTION: .
• CURLOPT_HEADERFUNCTION: .

Параметр value должен быть функцией следующего вида
string read_callback (resource ch, resource fd, long length){}
для следующих значений параметра option:

• CURLOPT_READFUNCTION: .

curl_exec

curl_exec — выполняет CURL-сессию.

Описание

bool curl_exec (resource ch)

Эта функция должна вызываться после того, как вы инициализируете сессию CURL
и все опции этой сессии уже установлены. Её назначение в том, чтобы просто
выполнить предопределённую CURL-сессию (заданную в параметре ch).

curl_close

curl_close — закрывает CURL-сессию.

Описание

void curl_close ( resource ch)

Эта функция закрывает сессию CURL и освобождает все ресурсы.
CURL-дескриптор ch также удаляется.

curl_errno

curl_errno — возвращает целое число, содержащее номер последней ошибки.

Описание

int curl_errno ( resource ch)

curl_error

curl_error — возвращает строку содержащую номер последней ошибки для текущей сессии.

Описание

string curl_error (resource ch)

curl_getinfo

curl_getinfo — получает информацию, касающуюся специфической передачи/transfer.

Описание

string curl_getinfo (resource ch, int opt)

• 
  CURLINFO_EFFECTIVE_URL — Последний
  использованный URL
  
• 
  CURLINFO_HTTP_CODE — Последний полученный код
  HTTP
  
• 
  CURLINFO_FILETIME — Дата модификации
  загруженного документа, если она неизвестна, возвращается -1.
  
• 
  CURLINFO_TOTAL_TIME — Полное время выполнения
  операции в секундах.
  
• 
  CURLINFO_NAMELOOKUP_TIME — Время разрешения
  имени сервера в секундах.
  
• 
  CURLINFO_CONNECT_TIME — Время, затраченное на
  установку соединения, в секундах
  
• 
  CURLINFO_PRETRANSFER_TIME — Время, прошедшее
  от начала операции до готовности к фактической передаче данных, в
  секундах
  
• 
  CURLINFO_STARTTRANSFER_TIME — Время, прошедшее
  от начала операции до момента передачи первого байта данных, в
  секундах
  
• 
  CURLINFO_REDIRECT_TIME — Общее время,
  затраченное на перенапрвления, в секундах
  
• 
  CURLINFO_SIZE_UPLOAD — Количество байт при
  закачке
  
• 
  CURLINFO_SIZE_DOWNLOAD — Количество байт при
  загрузке
  
• 
  CURLINFO_SPEED_DOWNLOAD — Средняя скорость
  закачки
  
• 
  CURLINFO_SPEED_UPLOAD — Средняя скорость
  загрузки
  
• 
  CURLINFO_HEADER_SIZE — Суммарный размер всех
  полученных заголовков
  
• 
  CURLINFO_REQUEST_SIZE — Суммарный размер всех
  отправленных запросов, в настоящее время используется только для HTTP запросов
  
• 
  CURLINFO_SSL_VERIFYRESULT — Результат
  проверки SSL сертификата, запрошенной с помощью установки
  параметра CURLOPT_SSL_VERIFYPEER
  
• 
  CURLINFO_CONTENT_LENGTH_DOWNLOAD —
  размер загруженного документа, прочитанный из заголовка
  Content-Length
  
• 
  CURLINFO_CONTENT_LENGTH_UPLOAD — Размер
  закачиваемых данных
  
• 
  CURLINFO_CONTENT_TYPE — Содержимое
  полученного заголовка Content-type, или NULL в случае, когда этот
  заголовок не был получен
  

При вызове без необязательного аргумента opt
возвращается ассоциативный массив со следующими индексами, которые
соответствуют значениям аргумента opt:

• 
  «url»
  
• 
  «content_type»
  
• 
  «http_code»
  
• 
  «header_size»
  
• 
  «request_size»
  
• 
  «filetime»
  
• 
  «ssl_verify_result»
  
• 
  «redirect_count»
  
• 
  «total_time»
  
• 
  «namelookup_time»
  
• 
  «connect_time»
  
• 
  «pretransfer_time»
  
• 
  «size_upload»
  
• 
  «size_download»
  
• 
  «speed_download»
  
• 
  «speed_upload»
  
• 
  «download_content_length»
  
• 
  «upload_content_length»
  
• 
  «starttransfer_time»
  
• 
  «redirect_time»
  

Пример использования curl_getinfo:

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "http://www.example.com/");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLINFO_HEADER_OUT, true);	// если этот параметр не указать не работает!
curl_exec($ch);
var_dump(curl_getinfo($ch,CURLINFO_HEADER_OUT));

Пример использования curl_getinfo:

$ch = curl_init(); // create cURL handle (ch)
if (!$ch) {
    die("Couldn't initialize a cURL handle");
}
// set some cURL options
$ret = curl_setopt($ch, CURLOPT_URL,            "http://mail.yahoo.com");
$ret = curl_setopt($ch, CURLOPT_HEADER,         1);
$ret = curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
$ret = curl_setopt($ch, CURLOPT_RETURNTRANSFER, 0);
$ret = curl_setopt($ch, CURLOPT_TIMEOUT,        30);

// execute
$ret = curl_exec($ch);

if (empty($ret)) {
    // some kind of an error happened
    die(curl_error($ch));
    curl_close($ch); // close cURL handler
} else {
    $info = curl_getinfo($ch);
    curl_close($ch); // close cURL handler

    if (empty($info['http_code'])) {
            die("No HTTP code was returned");
    } else {
        // load the HTTP codes
        $http_codes = parse_ini_file("path/to/the/ini/file/I/pasted/above");

        // echo results
        echo "The server responded: <br />";
        echo $info['http_code'] . " " . $http_codes[$info['http_code']];
    }

}

curl_version

curl_version — возвращает версию текущей CURL.

Описание

string curl_version (void)

Функция curl_version() возвращает строку с текущей версией CURL.

curl_version=Array
(
[version_number] => 472065
[age] => 3
[features] => 4179869
[ssl_version_number] => 0
[version] => 7.52.1
[host] => x86_64-pc-linux-gnu
[ssl_version] => OpenSSL/1.0.2u
[libz_version] => 1.2.8
[protocols] => Array
(
[0] => dict
[1] => file
[2] => ftp
[3] => ftps
[4] => gopher
[5] => http
[6] => https
[7] => imap
[8] => imaps
[9] => ldap
[10] => ldaps
[11] => pop3
[12] => pop3s
[13] => rtmp
[14] => rtsp
[15] => scp
[16] => sftp
[17] => smb
[18] => smbs
[19] => smtp
[20] => smtps
[21] => telnet
[22] => tftp
)

Предопределённые константы

Эти константы определены данным расширением и будут доступны только в том
случае, если либо вкомпилированы в РНР, либо динамически загружены на этапе прогона.

CURLOPT_PORT (integer)

CURLOPT_FILE (integer)

CURLOPT_INFILE (integer)

CURLOPT_INFILESIZE (integer)

CURLOPT_URL (integer)

CURLOPT_PROXY (integer)

CURLOPT_VERBOSE (integer)

CURLOPT_HEADER (integer)

CURLOPT_HTTPHEADER (integer)

CURLOPT_NOPROGRESS (integer)

CURLOPT_NOBODY (integer)

CURLOPT_FAILONERROR (integer)

CURLOPT_UPLOAD (integer)

CURLOPT_POST (integer)

CURLOPT_FTPLISTONLY (integer)

CURLOPT_FTPAPPEND (integer)

CURLOPT_NETRC (integer)

CURLOPT_FOLLOWLOCATION (integer)

CURLOPT_FTPASCII (integer)

CURLOPT_PUT (integer)

CURLOPT_MUTE (integer)

CURLOPT_USERPWD (integer)

CURLOPT_PROXYUSERPWD (integer)

CURLOPT_RANGE (integer)

CURLOPT_TIMEOUT (integer)

CURLOPT_POSTFIELDS (integer)

CURLOPT_REFERER (integer)

CURLOPT_USERAGENT (integer)

CURLOPT_FTPPORT (integer)

CURLOPT_LOW_SPEED_LIMIT (integer)

CURLOPT_LOW_SPEED_TIME (integer)

CURLOPT_RESUME_FROM (integer)

CURLOPT_COOKIE (integer)

CURLOPT_SSLCERT (integer)

CURLOPT_SSLCERTPASSWD (integer)

CURLOPT_WRITEHEADER (integer)

CURLOPT_SSL_VERIFYHOST (integer)

CURLOPT_COOKIEFILE (integer)

CURLOPT_SSLVERSION (integer)

CURLOPT_TIMECONDITION (integer)

CURLOPT_TIMEVALUE (integer)

CURLOPT_CUSTOMREQUEST (integer)

CURLOPT_STDERR (integer)

CURLOPT_TRANSFERTEXT (integer)

CURLOPT_RETURNTRANSFER (integer)

CURLOPT_QUOTE (integer)

CURLOPT_POSTQUOTE (integer)

CURLOPT_INTERFACE (integer)

CURLOPT_KRB4LEVEL (integer)

CURLOPT_HTTPPROXYTUNNEL (integer)

CURLOPT_FILETIME (integer)

CURLOPT_WRITEFUNCTION (integer)

CURLOPT_READFUNCTION (integer)

CURLOPT_PASSWDFUNCTION (integer)

CURLOPT_HEADERFUNCTION (integer)

CURLOPT_MAXREDIRS (integer)

CURLOPT_MAXCONNECTS (integer)

CURLOPT_CLOSEPOLICY (integer)

CURLOPT_FRESH_CONNECT (integer)

CURLOPT_FORBID_REUSE (integer)

CURLOPT_RANDOM_FILE (integer)

CURLOPT_EGDSOCKET (integer)

CURLOPT_CONNECTTIMEOUT (integer)

CURLOPT_SSL_VERIFYPEER (integer)

CURLOPT_CAINFO (integer)

CURLOPT_COOKIEJAR (integer)

CURLOPT_SSL_CIPHER_LIST (integer)

CURLOPT_BINARYTRANSFER (integer)

CURLCLOSEPOLICY_LEAST_RECENTLY_USED (integer)

CURLCLOSEPOLICY_LEAST_TRAFFIC (integer)

CURLCLOSEPOLICY_SLOWEST (integer)

CURLCLOSEPOLICY_CALLBACK (integer)

CURLCLOSEPOLICY_OLDEST (integer)

CURLINFO_EFFECTIVE_URL (integer)

CURLINFO_HTTP_CODE (integer)

CURLINFO_HEADER_SIZE (integer)

CURLINFO_REQUEST_SIZE (integer)

CURLINFO_TOTAL_TIME (integer)

CURLINFO_NAMELOOKUP_TIME (integer)

CURLINFO_CONNECT_TIME (integer)

CURLINFO_PRETRANSFER_TIME (integer)

CURLINFO_SIZE_UPLOAD (integer)

CURLINFO_SIZE_DOWNLOAD (integer)

CURLINFO_SPEED_DOWNLOAD (integer)

CURLINFO_SPEED_UPLOAD (integer)

CURLINFO_FILETIME (integer)

CURLINFO_SSL_VERIFYRESULT (integer)

CURLINFO_CONTENT_LENGTH_DOWNLOAD (integer)

CURLINFO_CONTENT_LENGTH_UPLOAD (integer)

CURLE_OK (integer)

CURLE_UNSUPPORTED_PROTOCOL (integer)

CURLE_FAILED_INIT (integer)

CURLE_URL_MALFORMAT (integer)

CURLE_URL_MALFORMAT_USER (integer)

CURLE_COULDNT_RESOLVE_PROXY (integer)

CURLE_COULDNT_RESOLVE_HOST (integer)

CURLE_COULDNT_CONNECT (integer)

CURLE_FTP_WEIRD_SERVER_REPLY (integer)

CURLE_FTP_ACCESS_DENIED (integer)

CURLE_FTP_USER_PASSWORD_INCORRECT (integer)

CURLE_FTP_WEIRD_PASS_REPLY (integer)

CURLE_FTP_WEIRD_USER_REPLY (integer)

CURLE_FTP_WEIRD_PASV_REPLY (integer)

CURLE_FTP_WEIRD_227_FORMAT (integer)

CURLE_FTP_CANT_GET_HOST (integer)

CURLE_FTP_CANT_RECONNECT (integer)

CURLE_FTP_COULDNT_SET_BINARY (integer)

CURLE_PARTIAL_FILE (integer)

CURLE_FTP_COULDNT_RETR_FILE (integer)

CURLE_FTP_WRITE_ERROR (integer)

CURLE_FTP_QUOTE_ERROR (integer)

CURLE_HTTP_NOT_FOUND (integer)

CURLE_WRITE_ERROR (integer)

CURLE_MALFORMAT_USER (integer)

CURLE_FTP_COULDNT_STOR_FILE (integer)

CURLE_READ_ERROR (integer)

CURLE_OUT_OF_MEMORY (integer)

CURLE_OPERATION_TIMEOUTED (integer)

CURLE_FTP_COULDNT_SET_ASCII (integer)

CURLE_FTP_PORT_FAILED (integer)

CURLE_FTP_COULDNT_USE_REST (integer)

CURLE_FTP_COULDNT_GET_SIZE (integer)

CURLE_HTTP_RANGE_ERROR (integer)

CURLE_HTTP_POST_ERROR (integer)

CURLE_SSL_CONNECT_ERROR (integer)

CURLE_FTP_BAD_DOWNLOAD_RESUME (integer)

CURLE_FILE_COULDNT_READ_FILE (integer)

CURLE_LDAP_CANNOT_BIND (integer)

CURLE_LDAP_SEARCH_FAILED (integer)

CURLE_LIBRARY_NOT_FOUND (integer)

CURLE_FUNCTION_NOT_FOUND (integer)

CURLE_ABORTED_BY_CALLBACK (integer)

CURLE_BAD_FUNCTION_ARGUMENT (integer)

CURLE_BAD_CALLING_ORDER (integer)

CURLE_HTTP_PORT_FAILED (integer)

CURLE_BAD_PASSWORD_ENTERED (integer)

CURLE_TOO_MANY_REDIRECTS (integer)

CURLE_UNKNOWN_TELNET_OPTION (integer)

CURLE_TELNET_OPTION_SYNTAX (integer)

CURLE_OBSOLETE (integer)

CURLE_SSL_PEER_CERTIFICATE (integer)

Примеры

После того как вы скомпилировали PHP с поддержкой CURL, вы можете начать
использовать curl-функций. Основная идея функций CURL — вы инициализируете CURL-сессию
с использованием curl_init(), затем можно установить все ваши опции для трансфера через использование
curl_exec(), а затем закрыть сессию функцией curl_close().

Пример 1. Инициализация новой сессии CURL и получение web-страницы.

<?php
$ch = curl_init();

curl_setopt ($ch, CURLOPT_URL, "http://www.example.com/");
curl_setopt ($ch, CURLOPT_HEADER, 0);

curl_exec ($ch);

curl_close ($ch);
?>

Пример 2. Использование модуля CURL РНР для получения example.com

<?php
$ch = curl_init ("http://www.example.com/");
$fp = fopen ("example_homepage.txt", "w");

curl_setopt ($ch, CURLOPT_FILE, $fp);
curl_setopt ($ch, CURLOPT_HEADER, 0);

curl_exec ($ch);
curl_close ($ch);
fclose ($fp);
?>

Пример 3. Проверка доступности URL с помощью CURL РНР

<?php
function check_url($url) {
    $c = curl_init();
    curl_setopt($c, CURLOPT_URL, $url);
    curl_setopt($c, CURLOPT_HEADER, 1); // читать заголовок
    curl_setopt($c, CURLOPT_NOBODY, 1); // читать ТОЛЬКО заголовок без тела
    curl_setopt($c, CURLOPT_RETURNTRANSFER, 1);
    curl_setopt($c, CURLOPT_FRESH_CONNECT, 1); // не использовать cache
    if (!curl_exec($c)) return false;

    $httpcode = curl_getinfo($c, CURLINFO_HTTP_CODE);
    return ($httpcode < 400);
}
?>

Пример 4. Отделение заголовка от тела, полученного с помощью CURL РНР

<?php
$header_size = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
$headers = substr($output, 0, $header_size - 4);
$body = substr($output, $header_size);
?>

Пример 5. Определение адреса перехода URL с помощью CURL РНР

the problem: curl_setopt($ch,FOLLOW_LOCATION,1);
the error: trouble with open_basedir and safe_mode
the solution: a function already developed by someone
the solution n 2: the same function, modifed, works great for me..

<?php
    function curl_redir_exec($ch)
    {
        static $curl_loops = 0;
        static $curl_max_loops = 20;
        if ($curl_loops++ >= $curl_max_loops)
        {
            $curl_loops = 0;
            return FALSE;
        }
        curl_setopt($ch, CURLOPT_HEADER, true);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        $data = curl_exec($ch);
        list($header, $data) = explode("nn", $data, 2);
        $http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        if ($http_code == 301 || $http_code == 302)
        {
            $matches = [];
            preg_match('/Location:(.*?)n/', $header, $matches);
            $url = @parse_url(trim(array_pop($matches)));
            if (!$url)
            {
                //couldn't process the url to redirect to
                $curl_loops = 0;
                return $data;
            }
            $last_url = parse_url(curl_getinfo($ch, CURLINFO_EFFECTIVE_URL));
            if (!$url['scheme'])
                $url['scheme'] = $last_url['scheme'];
            if (!$url['host'])
                $url['host'] = $last_url['host'];
            if (!$url['path'])
                $url['path'] = $last_url['path'];
            $new_url = $url['scheme'] . '://' . $url['host'] . $url['path'] . ($url['query']?'?'.$url['query']:'');
            curl_setopt($ch, CURLOPT_URL, $new_url);
            debug('Redirecting to', $new_url);
            return curl_redir_exec($ch);
        } else {
            $curl_loops=0;
            return $data;
        }
    }
?>

just use this function without de FOLLOW_LOCATION and should work. the problem was that when you get to the line where you return the data if http_code was different than 301 oe 302, $data has obsolete information or none. so $debbbb does the job.

Пример 6. Разбор cookie из заголовка с помощью CURL РНР

Sometimes you can’t use CURLOPT_COOKIEJAR and CURLOPT_COOKIEFILE becoz of the server
php-settings(They say u may grab any files from server using these options). Here is the solution
1)Don’t use CURLOPT_FOLLOWLOCATION
2)Use curl_setopt($ch, CURLOPT_HEADER, 1)
3)Grab from the header cookies like this:

preg_match_all('|Set-Cookie: (.*);|U', $content, $results);
$cookies = implode(';', $results[1]);

4)Set them using curl_setopt($ch, CURLOPT_COOKIE, $cookies);

Пример 7. Разбор cookie из заголовка с помощью CURL РНР

As Yevgen mentioned earlier sometimes we can’t use CURLOPT_COOKIEJAR and CURLOPT_COOKIEFILE. Below is a header callback function I wrote back in
January that lets you maintain cookies between cURL requests. Cookies are added to $ch during all requests even during redirection,
so you can use it together with CURLOPT_FOLLOWLOCATION.
Here is the code:

function read_header($ch, $string)
{
global $location; #keep track of location/redirects
global $cookiearr; #store cookies here
global $ch;
# ^overrides the function param $ch
# this is okay because we need to
# update the global $ch with
# new cookies

$length = strlen($string);
if(!strncmp($string, "Location:", 9))
{ #keep track of last redirect
$location = trim(substr($string, 9, -1));
}
if(!strncmp($string, "Set-Cookie:", 11))
{ #get the cookie
    $cookiestr = trim(substr($string, 11, -1));
    $cookie = explode(';', $cookiestr);
    $cookie = explode('=', $cookie[0]);
    $cookiename = trim(array_shift($cookie));
    $cookiearr[$cookiename] = trim(implode('=', $cookie));
    }
    $cookie = "";
    if(trim($string) == "")
    {  #execute only at end of header
        foreach ($cookiearr as $key=>$value)
        {
            $cookie .= "$key=$value; ";
        }
        curl_setopt($ch, CURLOPT_COOKIE, $cookie);
    }

    return $length;
}
curl_setopt($ch, CURLOPT_HEADERFUNCTION, 'read_header');

This code assumes that you will reuse $ch without initializing it every time (call curl_init only once, in the beginning).
If you need to initialize $ch again at any point in your code you can access the currently stored cookies in $cookiearr and include them in the new $ch.

I wrote this function before I had enough experience with regular expressions so you won’t find any preg_match calls here.
I have used this code for quite a while and without any problems accessing gmail, yahoo, hotmail, aol etc.
where I had to go through login and a few pages before getting to what I was looking for.

Пример 8. Установка обработчика загрузки заголовка с помощью CURL РНР

Using cURL, I needed to call a third-party script which was returning binary data as attachment to pass on retrieved data again as attachment.

Problem was that the third-party script occassionally returned HTTP errors and I wanted to avoid passing on zero-length attachment in such case.

Combination of using CURLOPT_FAILONERROR and CURLOPT_HEADERFUNCTION callback helped to process the third-party script HTTP errors neatly:

function curlHeaderCallback($resURL, $strHeader) {
    if (preg_match('/^HTTP/i', $strHeader)) {
        header($strHeader);
        header('Content-Disposition: attachment; filename="file-name.zip"');
    }
    return strlen($strHeader);
}

$resURL = curl_init('http://htmlweb.ru/');
curl_setopt($resURL, CURLOPT_BINARYTRANSFER, 1);
curl_setopt($resURL, CURLOPT_HEADERFUNCTION, 'curlHeaderCallback');
curl_setopt($resURL, CURLOPT_FAILONERROR, 1);
curl_exec ($resURL);

$intReturnCode = curl_getinfo($resURL, CURLINFO_HTTP_CODE);
curl_close ($resURL);

if ($intReturnCode != 200) {
    print 'Ошибка с кодом: ' . $intReturnCode;
}

Пример 9. Сохранение страницы в файл с подсчетом скорости передачи с помощью CURL РНР

WritePageToFile( 'http://es.php.net', 'es.php.net.txt' );

function WritePageToFile( $sHTMLpage, $sTxtfile ) {
    $sh =          curl_init( $sHTMLpage );
    $hFile =       FOpen( $sTxtfile, 'w' );
    curl_setopt( $sh, CURLOPT_FILE, $hFile );
    curl_setopt( $sh, CURLOPT_HEADER, 0 );
    curl_exec  ( $sh );
    $sAverageSpeedDownload = curl_getInfo( $sh, CURLINFO_SPEED_DOWNLOAD );
    $sAverageSpeedUpload   = curl_getInfo( $sh, CURLINFO_SPEED_UPLOAD );
    echo '<pre>';
    echo 'Average speed download == ' . $sAverageSpeedDownload . '<br>';
    echo 'Average Speed upload    == ' . $sAverageSpeedUpload   . '<br>';
    echo '<br>';
    $aCURLinfo = curl_getInfo( $sh );
    print_r( $aCURLinfo );
    echo '</pre>';
    curl_close(  $sh );
    FClose    (  $hFile );
    echo '(<b>See the file  "'.$sTxtfile.'"  in the same path of the hosting'.
        ' to where this script PHP</b>).<br>';
}

Пример 9. Получение страницы через SSL соединение (https)

$ch=curl_init('https://htmlweb.ru');
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
// Отключить ошибку "SSL certificate problem, verify that the CA cert is OK"
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
// Отключить ошибку "SSL: certificate subject name 'hostname.ru' does not match target host name '123.123'"
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
$out=curl_exec($ch);
    //$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    //echo "http_code=".$http_code,', err='.curl_error($ch);
curl_close($ch);

Пример 10. Использование сессий и cookie в curl

$cookie_filename=sys_get_temp_dir()+'/cookie.tmp';
$curl=curl_init('http://htmlweb.ru');
curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($curl, CURLOPT_COOKIEJAR, $cookie_filename);//сохранять полученные COOKIE в файл
curl_setopt($curl, CURLOPT_COOKIEFILE, $cookie_filename); //отсылаем серверу COOKIE полученные от него при авторизации
$out=curl_exec($curl);

Пример 11. Отправка файла и многомерный массив в Curl. CURLOPT_POSTFIELDS + CurlFile

Если Вам нужно будет отправить в POST запросе многомерный массив и файл, то вы столкнетесь с неразрешимой проблемой.
Если передавать в CURLOPT_POSTFIELDS многомерный массив, то второй уровень будет передан как строка «Array».
Если преобразовать с помощью http_build_query, то Вы не сможете передать файл.

Ниже представлена функция кодирования двумерного массива с подгрузкой файлов для Curl,
которая будет работать как в старых версиях PHP 5.3, PHP 5.4, так и в PHP 5.6

/** преобразует многомерный массив в одномерный, используйя сложные индексы и заменяет @ в префиксе на CurlFile для испрользоания в Curl
* @param $inputArray
* @param string $inputKey
* @return array
$requestVars = array(
'id' => array(1, 2,'id'=>1234),
'name' => 'log',
'logfile' => '@/tmp/test.log');
получим:
["id[0]"]=> int(1)
["id[1]"]=> int(2)
["id[id]"]=> int(1234)
["name"]=> string(3) "log"
["logfile"]=> string(13) "/tmp/test.log" }
*/
function convertToStringArray($inputArray, $inputKey='') {
 $resultArray=[];
 foreach ($inputArray as $key => $value) {
  $tmpKey = (bool)$inputKey ? $inputKey."[$key]" : $key;
  if (is_array($value)) {
    $resultArray+=convertToStringArray($value, $tmpKey);
   } elseif ($value[0] == '@'){
    $resultArray[$tmpKey] = (class_exists(' CURLFile ', false)) ? new CurlFile(ltrim($value, '@')) : $value;
   } else {
    $resultArray[$tmpKey] = $value;
   }
  }
 return $resultArray;
}
// проверяем
$requestVars = array(
'id' => array(1, 2,'id'=>1234),
'name' => 'log',
'logfile' => '@/tmp/test.log');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'htmlweb.ru');
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, convertToStringArray($requestVars));
$res = curl_exec($ch);
curl_close($ch);

Прикладные примеры использования Curl

Читать дальше: htaccess и PHP

cURL PHP – это библиотека предназначенная для получения и передачи данных через такие протоколы, как HTTP, FTP, HTTPS. Библиотека используется для получения данных в виде XML, JSON и непосредственно в HTML, парсинга, загрузки и передачи файлов и т.д.

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, false);
$html = curl_exec($ch);
curl_close($ch);

echo $html;

$get = array(
	'name'  => 'Alex',
	'email' => 'mail@example.com'
);

$ch = curl_init('https://example.com?' . http_build_query($get));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, false);
$html = curl_exec($ch);
curl_close($ch);

echo $html;

$array = array(
	'login'    => 'admin',
	'password' => '1234'
);		

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($array, '', '&'));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, false);
$html = curl_exec($ch);
curl_close($ch);	

echo $html;

$data = array(
	'name'  => 'Маффин',
	'price' => 100.0
);		

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type:application/json'));
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data, JSON_UNESCAPED_UNICODE)); 
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, false);
$res = curl_exec($ch);
curl_close($ch);

$res = json_encode($res, JSON_UNESCAPED_UNICODE);
print_r($res);

$data = array(
	'name'  => 'Маффин',
	'price' => 100.0
);	

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($array, '', '&'));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, false);
$html = curl_exec($ch);
curl_close($ch);	

echo $html;

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, false);
curl_exec($ch);
curl_close($ch);

$proxy = '165.22.115.179:8080';

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_TIMEOUT, 400);
curl_setopt($ch, CURLOPT_PROXY, $proxy); 
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, false);
$html = curl_exec($ch);
curl_close($ch);

$ch = curl_init('https://example.com');  
curl_setopt($ch, CURLOPT_POST, 1);  
curl_setopt($ch, CURLOPT_POSTFIELDS, array('photo' => '@' . __DIR__ . '/image.png'); 
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, false);
$html = curl_exec($ch);
curl_close($ch);

$curl_file = curl_file_create(__DIR__ . '/image.png', 'image/png' , 'image.png');

$ch = curl_init('https://example.com');  
curl_setopt($ch, CURLOPT_POST, 1);  
curl_setopt($ch, CURLOPT_POSTFIELDS, array('photo' => $curl_file));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, false);
$res = curl_exec($ch);
curl_close($ch);

$curl_files = array(
	'photo[0]' => curl_file_create(__DIR__ . '/image.png', 'image/png' , 'image.png'),
	'photo[1]' => curl_file_create(__DIR__ . '/image-2.png', 'image/png' , 'image-2.png')
);

$ch = curl_init('https://example.com');  
curl_setopt($ch, CURLOPT_POST, 1);  
curl_setopt($ch, CURLOPT_POSTFIELDS, $curl_files);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, false);
$res = curl_exec($ch);
curl_close($ch);

$file = __DIR__ . '/image.jpg';
$fp = fopen($file, 'r');

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_PUT, true);
curl_setopt($ch, CURLOPT_UPLOAD, true);
curl_setopt($ch, CURLOPT_INFILESIZE, filesize($file));
curl_setopt($ch, CURLOPT_INFILE, $fp);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, false);
curl_exec($ch);
curl_close($ch);

$file_name = __DIR__ . '/file.html';
$file = @fopen($file_name, 'w');

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_FILE, $file);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, false);
curl_exec($ch);
curl_close($ch);

fclose($file);

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, false);
$html = curl_exec($ch);
curl_close($ch);

file_put_contents(__DIR__ . '/file.html', $html);

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_COOKIEFILE, __DIR__ . '/cookie.txt');
curl_setopt($ch, CURLOPT_COOKIEJAR, __DIR__ . '/cookie.txt');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, false);

$html = curl_exec($ch);
curl_close($ch);	

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_COOKIE, 'PHPSESSID=61445603b6a0809b061080ed4bb93da3');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, false);

$html = curl_exec($ch);
curl_close($ch);

$headers = array(
	'cache-control: max-age=0',
	'upgrade-insecure-requests: 1',
	'user-agent: Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.97 Safari/537.36',
	'sec-fetch-user: ?1',
	'accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3',
	'x-compress: null',
	'sec-fetch-site: none',
	'sec-fetch-mode: navigate',
	'accept-encoding: deflate, br',
	'accept-language: ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7',
);

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_COOKIEFILE, __DIR__ . '/cookie.txt');
curl_setopt($ch, CURLOPT_COOKIEJAR, __DIR__ . '/cookie.txt');
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, true);
$html = curl_exec($ch);
curl_close($ch);

echo $html;

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_USERPWD, 'login:password');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, false);
$html = curl_exec($ch);
curl_close($ch);

echo $html;

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_HTTPHEADER, array('Authorization: OAuth TOKEN'));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, false);
$html = curl_exec($ch);
curl_close($ch);

echo $html;

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HEADER, false);
curl_exec($ch);
$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

echo $http_code; // Выведет: 200

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HEADER, false);
curl_exec($ch);
$res = curl_exec($ch);

var_dump($res); // false

if ($errno = curl_errno($ch)) {
	$message = curl_strerror($errno);
	echo "cURL error ({$errno}):n {$message}"; // Выведет: cURL error (35): SSL connect error
}
					
curl_close($ch);