The number of seconds to wait between processing batches of requests.

If the value of this property is greater than 0, the library will process as many requests as defined by the threads property and then wait for pause_interval seconds before processing the next batch of requests.

Default is 0 (the library will keep as many parallel threads as defined by threads running at all times until there are no more requests to process).

Tags

The number of parallel, asynchronous requests to be processed by the library, at once.

1. // process 30 simultaneous requests at once
2. $curl->threads = 30;

Note that unless pause_interval is set to a value greater than 0, the library will process a constant number of requests, at all times; it is doing this by starting a new request as soon as another one finishes.

If pause_interval is set to a value greater than 0, the library will process as many requests as set by the threads property and then wait for pause_interval seconds before processing the next batch of requests.

Default is 10

void __construct ( [ boolean $htmlentities = true ] )

Constructor of the class.

Below is the list of default options set by the library when instantiated. Various methods of the library may overwrite some of these options when called (see delete, download, ftp_download, get, header, post, put). The value of any of these options may also be changed with the option method. For a full list of available options and their description, consult the PHP documentation.

• CURLINFO_HEADER_OUT - the last request string sent
  default: TRUE

• CURLOPT_AUTOREFERER - TRUE to automatically set the "Referer:" field in requests where it follows a "Location:" redirect
  default: TRUE

• CURLOPT_COOKIEFILE - the name of the file containing the cookie data. the cookie file can be in Netscape format, or just plain HTTP-style headers dumped into a file. if the name is an empty string, no cookies are loaded, but cookie handling is still enabled
  default: an empty string

• CURLOPT_CONNECTTIMEOUT - the number of seconds to wait while trying to connect
  default: 10 (use 0 to wait indefinitely)

• CURLOPT_ENCODING - the contents of the "Accept-Encoding: " header. this enables decoding of the response. supported encodings are identity, deflate, and gzip. if an empty string is set, a header containing all supported encoding types is sent
  default: gzip,deflate

• CURLOPT_FOLLOWLOCATION - TRUE to follow any "Location:" header that the server sends as part of the HTTP header (note this is recursive, PHP will follow as many "Location:" headers that it is sent, unless CURLOPT_MAXREDIRS is set - see below)
  default: TRUE

• CURLOPT_HEADER - TRUE to include the header in the output
  default: TRUE

• CURLOPT_MAXREDIRS - the maximum amount of HTTP redirections to follow. use this option alongside CURLOPT_FOLLOWLOCATION - see above
  default: 50

• CURLOPT_RETURNTRANSFER - TRUE to return the transfer's body as a string instead of outputting it directly
  default: TRUE

• CURLOPT_SSL_VERIFYHOST - 1 to check the existence of a common name in the SSL peer certificate. 2 to check the existence of a common name and also verify that it matches the hostname provided. 0 to not check the names
  see the ssl method for more info
  default: TRUE

• CURLOPT_SSL_VERIFYPEER - FALSE to stop cURL from verifying the peer's certificate
  see the ssl method for more info
  default: TRUE

• CURLOPT_TIMEOUT - the maximum number of seconds to allow cURL functions to execute
  default: 10

• CURLOPT_USERAGENT - a (slightly) random user agent (Internet Explorer 9 or 10, on Windows Vista, 7 or 8, with other extra strings). Some web services will not respond unless a valid user-agent string is provided

Arguments

void cache ( mixed $path , [ integer $lifetime = 3600 ] , [ boolean $compress = true ] , [ integer $chmod = 0755 ] )

Enables caching of request results.

Note that in case of downloads, only the actual request is cached and not the associated downloads

1. // instantiate the class
2. $curl = new Zebra_cURL();
3.  
4. // if making requests over HTTPS we need to load a CA bundle
5. // so we don't get CURLE_SSL_CACERT response from cURL
6. // you can get this bundle from https://curl.se/docs/caextract.html
7. $curl->ssl(true, 2, 'path/to/cacert.pem');
8.  
9. // cache results in the "cache" folder and for 86400 seconds (24 hours)
10. $curl->cache('cache', 86400);
11.  
12. // fetch the RSS feeds of some popular tech-related websites
13. // and execute a callback function for each request, as soon as it finishes
14. $curl->get(array(
15.  
16.     'https://alistapart.com/main/feed/',
17.     'https://www.smashingmagazine.com/feed/',
18.     'https://code.tutsplus.com/posts.atom',
19.  
20. // the callback function receives as argument an object with 4 properties
21. // (info, header, body and response)
22. ), function($result) {
23.  
24.     // everything went well at cURL level
25.     if ($result->response[1] == CURLE_OK) {
26.  
27.         // if server responded with code 200 (meaning that everything went well)
28.         // see https://httpstatus.es/ for a list of possible response codes
29.         if ($result->info['http_code'] == 200) {
30.  
31.             // see all the returned data
32.             print_r('<pre>');
33.             print_r($result);
34.  
35.         // show the server's response code
36.         } else trigger_error('Server responded with code ' . $result->info['http_code'], E_USER_ERROR);
37.  
38.     // something went wrong
39.     // ($result still contains all data that could be gathered)
40.     } else trigger_error('cURL responded with: ' . $result->response[0], E_USER_ERROR);
41.  
42. });

Arguments

void cookies ( string $path )

Sets the path and name of the file to save cookie to / retrieve cookies from. All cookie data will be stored in this file on a per-domain basis. Important when cookies need to stored/restored to maintain status/session of requests made to the same domains.

This method will automatically set the CURLOPT_COOKIEJAR and CURLOPT_COOKIEFILE options.

Arguments

void delete ( mixed $urls , [ mixed $callback = '' ] )

Performs an HTTP DELETE request to one or more URLs with optional POST data, and executes the callback function specified by the $callback argument for each and every request, as soon as the request finishes.

This method will automatically set the following options:

• CURLINFO_HEADER_OUT = TRUE
• CURLOPT_CUSTOMREQUEST = DELETE
• CURLOPT_HEADER = TRUE
• CURLOPT_NOBODY = FALSE
• CURLOPT_POST = FALSE
• CURLOPT_POSTFIELDS = the POST data

...and will unset the following options:

• CURLOPT_BINARYTRANSFER
• CURLOPT_HTTPGET
• CURLOPT_FILE

Multiple requests are processed asynchronously, in parallel, and the callback function is called for each and every request as soon as the request finishes. The number of parallel requests to be constantly processed, at all times, is set through the threads property. See also pause_interval.

Because requests are done asynchronously, when initiating multiple requests at once, these may not finish in the order in which they were initiated!

1. // instantiate the class
2. $curl = new Zebra_cURL();
3.  
4. // if making requests over HTTPS we need to load a CA bundle
5. // so we don't get CURLE_SSL_CACERT response from cURL
6. // you can get this bundle from https://curl.se/docs/caextract.html
7. $curl->ssl(true, 2, 'path/to/cacert.pem');
8.  
9. // do a DELETE request
10. // and execute a callback function for each request, as soon as it finishes
11. $curl->delete(array(
12.  
13.     'https://www.somewebsite.com'   =>  array(
14.         'data_1'  =>  'value 1',
15.         'data_2'  =>  'value 2',
16.     ),
17.  
18. // the callback function receives as argument an object with 4 properties
19. // (info, header, body and response)
20. ), function($result) {
21.  
22.     // everything went well at cURL level
23.     if ($result->response[1] == CURLE_OK) {
24.  
25.         // if server responded with code 200 (meaning that everything went well)
26.         // see https://httpstatus.es/ for a list of possible response codes
27.         if ($result->info['http_code'] == 200) {
28.  
29.             // see all the returned data
30.             print_r('<pre>');
31.             print_r($result);
32.  
33.         // show the server's response code
34.         } else trigger_error('Server responded with code ' . $result->info['http_code'], E_USER_ERROR);
35.  
36.     // something went wrong
37.     // ($result still contains all data that could be gathered)
38.     } else trigger_error('cURL responded with: ' . $result->response[0], E_USER_ERROR);
39.  
40. });

Arguments

Tags

void download ( mixed $urls , string $path , [ mixed $callback = '' ] )

Downloads one or more files from one or more URLs, saves the downloaded files to the path specified by the $path argument, and executes the callback function specified by the $callback argument for each and every request, as soon as the request finishes.

If the path you are downloading from refers to a file, the file's original name will be preserved but, if you are downloading a file generated by a script (i.e. https://foo.com/bar.php?w=1200&h=800), the downloaded file's name will be random generated. Refer to the downloaded file's name in the result's info attribute, in the downloaded_filename section - see the example below.

If you are downloading multiple files with the same name the later ones will overwrite the previous ones.

Downloads are streamed (bytes downloaded are directly written to disk) removing the unnecessary strain from your server of reading files into memory first, and then writing them to disk.

This method will automatically set the following options:

• CURLINFO_HEADER_OUT = TRUE
• CURLOPT_BINARYTRANSFER = TRUE
• CURLOPT_HEADER = TRUE
• CURLOPT_FILE

...and will unset the following options:

• CURLOPT_CUSTOMREQUEST
• CURLOPT_HTTPGET
• CURLOPT_NOBODY
• CURLOPT_POST
• CURLOPT_POSTFIELDS

Multiple requests are processed asynchronously, in parallel, and the callback function is called for each and every request as soon as the request finishes. The number of parallel requests to be constantly processed, at all times, is set through the threads property. See also pause_interval.

Because requests are done asynchronously, when initiating multiple requests at once, these may not finish in the order in which they were initiated!

1. // instantiate the class
2. $curl = new Zebra_cURL();
3.  
4. // if making requests over HTTPS we need to load a CA bundle
5. // so we don't get CURLE_SSL_CACERT response from cURL
6. // you can get this bundle from https://curl.se/docs/caextract.html
7. $curl->ssl(true, 2, 'path/to/cacert.pem');
8.  
9. // download 2 images from 2 different websites
10. // and execute a callback function for each request, as soon as it finishes
11. $curl->download(array(
12.  
13.     'https://www.somewebsite.com/images/alpha.jpg',
14.     'https://www.otherwebsite.com/images/omega.jpg',
15.  
16. // the callback function receives as argument an object with 4 properties
17. // (info, header, body and response)
18. ), 'destination/path/', function($result) {
19.  
20.     // everything went well at cURL level
21.     if ($result->response[1] == CURLE_OK) {
22.  
23.         // if server responded with code 200 (meaning that everything went well)
24.         // see https://httpstatus.es/ for a list of possible response codes
25.         if ($result->info['http_code'] == 200) {
26.  
27.             // see all the returned data
28.             print_r('<pre>');
29.             print_r($result);
30.  
31.             // get the downloaded file's path
32.             $result->info['downloaded_filename'];
33.  
34.         // show the server's response code
35.         } else trigger_error('Server responded with code ' . $result->info['http_code'], E_USER_ERROR);
36.  
37.     // something went wrong
38.     // ($result still contains all data that could be gathered)
39.     } else trigger_error('cURL responded with: ' . $result->response[0], E_USER_ERROR);
40.  
41. });

Arguments

void ftp_download ( mixed $urls , string $path , [ string $username = '' ] , [ string $password = '' ] , [ mixed $callback = '' ] )

Works exactly like the download method but downloads are made from an FTP server.

Downloads one or more files from an FTP server, to which the connection is made using the given $username and $password arguments, saves the downloaded files (with their original name) to the path specified by the $path argument, and executes the callback function specified by the $callback argument for each and every request, as soon as the request finishes.

Downloads are streamed (bytes downloaded are directly written to disk) removing the unnecessary strain from your server of reading files into memory first, and then writing them to disk.

This method will automatically set the following options:

• CURLINFO_HEADER_OUT = TRUE
• CURLOPT_BINARYTRANSFER = TRUE
• CURLOPT_HEADER = TRUE
• CURLOPT_FILE

...and will unset the following options:

• CURLOPT_CUSTOMREQUEST
• CURLOPT_HTTPGET
• CURLOPT_NOBODY
• CURLOPT_POST
• CURLOPT_POSTFIELDS

If you are downloading multiple files with the same name the later ones will overwrite the previous ones.

Multiple requests are processed asynchronously, in parallel, and the callback function is called for each and every request as soon as the request finishes. The number of parallel requests to be constantly processed, at all times, is set through the threads property. See also pause_interval.

Because requests are done asynchronously, when initiating multiple requests at once, these may not finish in the order in which they were initiated!

1. // instantiate the class
2. $curl = new Zebra_cURL();
3.  
4. // if making requests over HTTPS we need to load a CA bundle
5. // so we don't get CURLE_SSL_CACERT response from cURL
6. // you can get this bundle from https://curl.se/docs/caextract.html
7. $curl->ssl(true, 2, 'path/to/cacert.pem');
8.  
9. // connect to the FTP server using the given credential, download a file to a given location
10. // and execute a callback function for each request, as soon as it finishes
11. $curl->ftp_download(
12.  
13.     'ftp://somefile.ext',
14.     'destination/path',
15.     'username',
16.     'password',
17.  
18.     // the callback function receives as argument an object with 4 properties
19.     // (info, header, body and response)
20.     function($result) {
21.  
22.         // everything went well at cURL level
23.         if ($result->response[1] == CURLE_OK) {
24.  
25.             // if server responded with code 200 (meaning that everything went well)
26.             // see https://httpstatus.es/ for a list of possible response codes
27.             if ($result->info['http_code'] == 200) {
28.  
29.                 // see all the returned data
30.                 print_r('<pre>');
31.                 print_r($result);
32.  
33.             // show the server's response code
34.             } else trigger_error('Server responded with code ' . $result->info['http_code'], E_USER_ERROR);
35.  
36.         // something went wrong
37.         // ($result still contains all data that could be gathered)
38.         } else trigger_error('cURL responded with: ' . $result->response[0], E_USER_ERROR);
39.  
40.     }
41.  
42. );

Arguments

void get ( mixed $urls , [ mixed $callback = '' ] )

Performs an HTTP GET request to one or more URLs and executes the callback function specified by the $callback argument for each and every request, as soon as the request finishes.

This method will automatically set the following options:

• CURLINFO_HEADER_OUT = TRUE
• CURLOPT_HEADER = TRUE
• CURLOPT_HTTPGET = TRUE
• CURLOPT_NOBODY = FALSE

...and will unset the following options:

• CURLOPT_BINARYTRANSFER
• CURLOPT_CUSTOMREQUEST
• CURLOPT_FILE
• CURLOPT_POST
• CURLOPT_POSTFIELDS

Multiple requests are processed asynchronously, in parallel, and the callback function is called for each and every request as soon as the request finishes. The number of parallel requests to be constantly processed, at all times, is set through the threads property. See also pause_interval.

Because requests are done asynchronously, when initiating multiple requests at once, these may not finish in the order in which they were initiated!

1. // instantiate the class
2. $curl = new Zebra_cURL();
3.  
4. // if making requests over HTTPS we need to load a CA bundle
5. // so we don't get CURLE_SSL_CACERT response from cURL
6. // you can get this bundle from https://curl.se/docs/caextract.html
7. $curl->ssl(true, 2, 'path/to/cacert.pem');
8.  
9. // cache results in the "cache" folder and for 3600 seconds (one hour)
10. $curl->cache('cache', 3600);
11.  
12. // let's fetch the RSS feeds of some popular websites
13. // execute the callback function for each request, as soon as it finishes
14. $curl->get(array(
15.  
16.     'https://alistapart.com/main/feed/',
17.     'https://www.smashingmagazine.com/feed/',
18.     'https://code.tutsplus.com/posts.atom',
19.  
20. // the callback function receives as argument an object with 4 properties
21. // (info, header, body and response)
22. ), function($result) {
23.  
24.     // everything went well at cURL level
25.     if ($result->response[1] == CURLE_OK) {
26.  
27.         // if server responded with code 200 (meaning that everything went well)
28.         // see https://httpstatus.es/ for a list of possible response codes
29.         if ($result->info['http_code'] == 200) {
30.  
31.             // see all the returned data
32.             print_r('<pre>');
33.             print_r($result);
34.  
35.         // show the server's response code
36.         } else trigger_error('Server responded with code ' . $result->info['http_code'], E_USER_ERROR);
37.  
38.     // something went wrong
39.     // ($result still contains all data that could be gathered)
40.     } else trigger_error('cURL responded with: ' . $result->response[0], E_USER_ERROR);
41.  
42. });

Arguments

void header ( mixed $urls , [ mixed $callback = '' ] )

Works exactly like the get method, the only difference being that this method will only return the headers, without body.

This method will automatically set the following options:

• CURLINFO_HEADER_OUT = TRUE
• CURLOPT_HEADER = TRUE
• CURLOPT_HTTPGET = TRUE
• CURLOPT_NOBODY = TRUE

...and will unset the following options:

• CURLOPT_BINARYTRANSFER
• CURLOPT_CUSTOMREQUEST
• CURLOPT_FILE
• CURLOPT_POST
• CURLOPT_POSTFIELDS

Multiple requests are processed asynchronously, in parallel, and the callback function is called for each and every request as soon as the request finishes. The number of parallel requests to be constantly processed, at all times, is set through the threads property. See also pause_interval.

Because requests are done asynchronously, when initiating multiple requests at once, these may not finish in the order in which they were initiated!

1. // instantiate the class
2. $curl = new Zebra_cURL();
3.  
4. // process given URLs
5. // and execute a callback function for each request, as soon as it finishes
6. // the callback function receives as argument an object with 4 properties
7. // (info, header, body and response)
8. $curl->header('https://www.somewebsite.com', function($result) {
9.  
10.     // everything went well at cURL level
11.     if ($result->response[1] == CURLE_OK) {
12.  
13.         // if server responded with code 200 (meaning that everything went well)
14.         // see https://httpstatus.es/ for a list of possible response codes
15.         if ($result->info['http_code'] == 200) {
16.  
17.             // see all the returned data
18.             print_r('<pre>');
19.             print_r($result);
20.  
21.         // show the server's response code
22.         } else trigger_error('Server responded with code ' . $result->info['http_code'], E_USER_ERROR);
23.  
24.     // something went wrong
25.     // ($result still contains all data that could be gathered)
26.     } else trigger_error('cURL responded with: ' . $result->response[0], E_USER_ERROR);
27.  
28. });

Arguments

void http_authentication ( [ string $username = '' ] , [ string $password = '' ] , [ integer $type = CURLAUTH_ANY ] )

Use this method to make requests to pages that require prior HTTP authentication.

1. // instantiate the class
2. $curl = new Zebra_cURL();
3.  
4. // prepare user name and password
5. $curl->http_authentication('username', 'password');
6.  
7. // if making requests over HTTPS we need to load a CA bundle
8. // so we don't get CURLE_SSL_CACERT response from cURL
9. // you can get this bundle from https://curl.se/docs/caextract.html
10. $curl->ssl(true, 2, 'path/to/cacert.pem');
11.  
12. // get content from a page that requires prior HTTP authentication
13. // the callback function receives as argument an object with 4 properties
14. // (info, header, body and response)
15. $curl->get('https://www.some-page-requiring-prior-http-authentication.com', function($result) {
16.  
17.     // everything went well at cURL level
18.     if ($result->response[1] == CURLE_OK) {
19.  
20.         // if server responded with code 200 (meaning that everything went well)
21.         // see https://httpstatus.es/ for a list of possible response codes
22.         if ($result->info['http_code'] == 200) {
23.  
24.             // see all the returned data
25.             print_r('<pre>');
26.             print_r($result);
27.  
28.         // show the server's response code
29.         } else trigger_error('Server responded with code ' . $result->info['http_code'], E_USER_ERROR);
30.  
31.     // something went wrong
32.     // ($result still contains all data that could be gathered)
33.     } else trigger_error('cURL responded with: ' . $result->response[0], E_USER_ERROR);
34.  
35. });

If you have to unset previously set values use

1. $curl->http_authentication();

Arguments

void option ( mixed $option , [ mixed $value = '' ] )

Allows the setting of one or more cURL options.

1. // instantiate the class
2. $curl = new Zebra_cURL();
3.  
4. // setting a single option
5. $curl->option(CURLOPT_CONNECTTIMEOUT, 10);
6.  
7. // setting multiple options at once
8. $curl->option(array(
9.     CURLOPT_TIMEOUT         =>  10,
10.     CURLOPT_CONNECTTIMEOUT  =>  10,
11. ));
12.  
13. // requests are made here...

Arguments

void patch ( mixed $urls , [ mixed $callback = '' ] )

Performs an HTTP PATCH request to one or more URLs and executes the callback function specified by the $callback argument for each and every request, as soon as the request finishes.

This method will automatically set the following options:

• CURLINFO_HEADER_OUT - TRUE
• CURLOPT_CUSTOMREQUEST - PATCH
• CURLOPT_HEADER - TRUE
• CURLOPT_NOBODY - FALSE
• CURLOPT_POST - FALSE
• CURLOPT_POSTFIELDS - the POST data

...and will unset the following options:

• CURLOPT_BINARYTRANSFER
• CURLOPT_HTTPGET
• CURLOPT_FILE

Multiple requests are processed asynchronously, in parallel, and the callback function is called for each and every request as soon as the request finishes. The number of parallel requests to be constantly processed, at all times, is set through the threads property. See also pause_interval.

Because requests are done asynchronously, when initiating multiple requests at once, these may not finish in the order in which they were initiated!

1. // instantiate the class
2. $curl = new Zebra_cURL();
3.  
4. // if making requests over HTTPS we need to load a CA bundle
5. // so we don't get CURLE_SSL_CACERT response from cURL
6. // you can get this bundle from https://curl.se/docs/caextract.html
7. $curl->ssl(true, 2, 'path/to/cacert.pem');
8.  
9. // do a PATCH request and execute a callback function for each request, as soon as it finishes
10. $curl->patch(array(
11.  
12.     'https://www.somewebsite.com'  =>  array(
13.         'data_1'  =>  'value 1',
14.         'data_2'  =>  'value 2',
15.     ),
16.  
17. // the callback function receives as argument an object with 4 properties
18. // (info, header, body and response)
19. ), function($result) {
20.  
21.     // everything went well at cURL level
22.     if ($result->response[1] == CURLE_OK) {
23.  
24.         // if server responded with code 200 (meaning that everything went well)
25.         // see https://httpstatus.es/ for a list of possible response codes
26.         if ($result->info['http_code'] == 200) {
27.  
28.             // see all the returned data
29.             print_r('<pre>');
30.             print_r($result);
31.  
32.         // show the server's response code
33.         } else trigger_error('Server responded with code ' . $result->info['http_code'], E_USER_ERROR);
34.  
35.     // something went wrong
36.     // ($result still contains all data that could be gathered)
37.     } else trigger_error('cURL responded with: ' . $result->response[0], E_USER_ERROR);
38.  
39. });

Arguments

Tags

void post ( mixed $urls , [ mixed $callback = '' ] )

Performs an HTTP POST request to one or more URLs and executes the callback function specified by the $callback argument for each and every request, as soon as the request finishes.

This method will automatically set the following options:

• CURLINFO_HEADER_OUT = TRUE
• CURLOPT_HEADER = TRUE
• CURLOPT_NOBODY = FALSE
• CURLOPT_POST = TRUE
• CURLOPT_POSTFIELDS = the POST data

...and will unset the following options:

• CURLOPT_BINARYTRANSFER
• CURLOPT_CUSTOMREQUEST
• CURLOPT_HTTPGET
• CURLOPT_FILE

Multiple requests are processed asynchronously, in parallel, and the callback function is called for each and every request as soon as the request finishes. The number of parallel requests to be constantly processed, at all times, is set through the threads property. See also pause_interval.

Because requests are done asynchronously, when initiating multiple requests at once, these may not finish in the order in which they were initiated!

1. // instantiate the class
2. $curl = new Zebra_cURL();
3.  
4. // if making requests over HTTPS we need to load a CA bundle
5. // so we don't get CURLE_SSL_CACERT response from cURL
6. // you can get this bundle from https://curl.se/docs/caextract.html
7. $curl->ssl(true, 2, 'path/to/cacert.pem');
8.  
9. // do a POST request and execute a callback function for each request, as soon as it finishes
10. $curl->post(array(
11.  
12.     'https://www.somewebsite.com'  =>  array(
13.         'data_1'  =>  'value 1',
14.         'data_2'  =>  'value 2',
15.     ),
16.  
17. // the callback function receives as argument an object with 4 properties
18. // (info, header, body and response)
19. ), function($result) {
20.  
21.     // everything went well at cURL level
22.     if ($result->response[1] == CURLE_OK) {
23.  
24.         // if server responded with code 200 (meaning that everything went well)
25.         // see https://httpstatus.es/ for a list of possible response codes
26.         if ($result->info['http_code'] == 200) {
27.  
28.             // see all the returned data
29.             print_r('<pre>');
30.             print_r($result);
31.  
32.         // show the server's response code
33.         } else trigger_error('Server responded with code ' . $result->info['http_code'], E_USER_ERROR);
34.  
35.     // something went wrong
36.     // ($result still contains all data that could be gathered)
37.     } else trigger_error('cURL responded with: ' . $result->response[0], E_USER_ERROR);
38.  
39. });

When uploading a file, we need to prefix the file name with @

1. $curl->post(array(
2.     'https://www.somewebsite.com'  =>  array(
3.         'data_1'  =>  'value 1',
4.         'data_2'  =>  'value 2',
5.         'data_3'  =>  '@absolute/path/to/file.ext',
6. ), 'mycallback');

Arguments

void proxy ( string $proxy , [ integer $port = 80 ] , [ string $username = '' ] , [ string $password = '' ] )

Instructs the library to tunnel all requests through a proxy server.

1. // instantiate the class
2. $curl = new Zebra_cURL();
3.  
4. // if making requests over HTTPS we need to load a CA bundle
5. // so we don't get CURLE_SSL_CACERT response from cURL
6. // you can get this bundle from https://curl.se/docs/caextract.html
7. $curl->ssl(true, 2, 'path/to/cacert.pem');
8.  
9. // connect to a proxy server
10. // (that's a random one i got from https://www.proxynova.com/proxy-server-list/)
11. $curl->proxy('91.221.252.18', '8080');
12.  
13. // fetch a page and execute a callback function when done
14. // the callback function receives as argument an object with 4 properties
15. // (info, header, body and response)
16. $curl->get('https://www.somewebsite.com/', function($result) {
17.  
18.     // everything went well at cURL level
19.     if ($result->response[1] == CURLE_OK) {
20.  
21.         // if server responded with code 200 (meaning that everything went well)
22.         // see https://httpstatus.es/ for a list of possible response codes
23.         if ($result->info['http_code'] == 200) {
24.  
25.             // see all the returned data
26.             print_r('<pre>');
27.             print_r($result);
28.  
29.         // show the server's response code
30.         } else trigger_error('Server responded with code ' . $result->info['http_code'], E_USER_ERROR);
31.  
32.     // something went wrong
33.     // ($result still contains all data that could be gathered)
34.     } else trigger_error('cURL responded with: ' . $result->response[0], E_USER_ERROR);
35.  
36. });

Arguments

void put ( mixed $urls , [ mixed $callback = '' ] )

Performs an HTTP PUT request to one or more URLs and executes the callback function specified by the $callback argument for each and every request, as soon as the request finishes.

This method will automatically set the following options:

• CURLINFO_HEADER_OUT - TRUE
• CURLOPT_CUSTOMREQUEST - PUT
• CURLOPT_HEADER - TRUE
• CURLOPT_NOBODY - FALSE
• CURLOPT_POST - FALSE
• CURLOPT_POSTFIELDS - the POST data

...and will unset the following options:

• CURLOPT_BINARYTRANSFER
• CURLOPT_HTTPGET
• CURLOPT_FILE

Multiple requests are processed asynchronously, in parallel, and the callback function is called for each and every request as soon as the request finishes. The number of parallel requests to be constantly processed, at all times, is set through the threads property. See also pause_interval.

Because requests are done asynchronously, when initiating multiple requests at once, these may not finish in the order in which they were initiated!

1. // instantiate the class
2. $curl = new Zebra_cURL();
3.  
4. // if making requests over HTTPS we need to load a CA bundle
5. // so we don't get CURLE_SSL_CACERT response from cURL
6. // you can get this bundle from https://curl.se/docs/caextract.html
7. $curl->ssl(true, 2, 'path/to/cacert.pem');
8.  
9. // do a PUT request and execute a callback function for each request, as soon as it finishes
10. $curl->put(array(
11.  
12.     'https://www.somewebsite.com'  =>  array(
13.         'data_1'  =>  'value 1',
14.         'data_2'  =>  'value 2',
15.     ),
16.  
17. // the callback function receives as argument an object with 4 properties
18. // (info, header, body and response)
19. ), function($result) {
20.  
21.     // everything went well at cURL level
22.     if ($result->response[1] == CURLE_OK) {
23.  
24.         // if server responded with code 200 (meaning that everything went well)
25.         // see https://httpstatus.es/ for a list of possible response codes
26.         if ($result->info['http_code'] == 200) {
27.  
28.             // see all the returned data
29.             print_r('<pre>');
30.             print_r($result);
31.  
32.         // show the server's response code
33.         } else trigger_error('Server responded with code ' . $result->info['http_code'], E_USER_ERROR);
34.  
35.     // something went wrong
36.     // ($result still contains all data that could be gathered)
37.     } else trigger_error('cURL responded with: ' . $result->response[0], E_USER_ERROR);
38.  
39. });

Arguments

Tags

void queue ()

Instructs the library to queue requests rather than processing them right away. Useful for grouping different types of requests and treat them as a single request.

Until start method is called, all calls to delete, download, ftp_download, get, header, post and put methods will queue up rather than being executed right away. Once the start method is called, all queued requests will be processed while values of threads and pause_interval properties will still apply.

1. // the callback function to be executed for each and every
2. // request, as soon as the request finishes
3. // the callback function receives as argument an object with 4 properties
4. // (info, header, body and response)
5. function mycallback($result) {
6.  
7.     // everything went well at cURL level
8.     if ($result->response[1] == CURLE_OK) {
9.  
10.         // if server responded with code 200 (meaning that everything went well)
11.         // see https://httpstatus.es/ for a list of possible response codes
12.         if ($result->info['http_code'] == 200) {
13.  
14.             // see all the returned data
15.             print_r('<pre>');
16.             print_r($result);
17.  
18.         // show the server's response code
19.         } else trigger_error('Server responded with code ' . $result->info['http_code'], E_USER_ERROR);
20.  
21.     // something went wrong
22.     // ($result still contains all data that could be gathered)
23.     } else trigger_error('cURL responded with: ' . $result->response[0], E_USER_ERROR);
24.  
25. }
26.  
27. // instantiate the class
28. $curl = new Zebra_cURL();
29.  
30. // if making requests over HTTPS we need to load a CA bundle
31. // so we don't get CURLE_SSL_CACERT response from cURL
32. // you can get this bundle from https://curl.se/docs/caextract.html
33. $curl->ssl(true, 2, 'path/to/cacert.pem');
34.  
35. // queue requests - useful for grouping different types of requests
36. // in this example, when the "start" method is called, we'll execute
37. // the "get" and the "post" requests asynchronously
38. $curl->queue();
39.  
40. // do a POST and execute the callback function when done
41. $curl->post(array(
42.     'https://www.somewebsite.com'  =>  array(
43.         'data_1'  =>  'value 1',
44.         'data_2'  =>  'value 2',
45.     ),
46. ), 'mycallback');
47.  
48. // fetch the RSS feeds of some popular websites
49. // and execute the callback function for each request, as soon as it finishes
50. $curl->get(array(
51.     'https://alistapart.com/main/feed/',
52.     'https://www.smashingmagazine.com/feed/',
53.     'https://code.tutsplus.com/posts.atom',
54. ), 'mycallback')
55.  
56. // execute queued requests
57. $curl->start();

Tags

mixed scrap ( mixed $url , [ boolean $body_only = true ] )

A shorthand for making a single get request without the need of a callback function.

1. // instantiate the class
2. $curl = new Zebra_cURL();
3.  
4. // if making requests over HTTPS we need to load a CA bundle
5. // so we don't get CURLE_SSL_CACERT response from cURL
6. // you can get this bundle from https://curl.se/docs/caextract.html
7. $curl->ssl(true, 2, 'path/to/cacert.pem');
8.  
9. // get page's content only
10. $content = $curl->scrap('https://www.somewebsite.com/');
11.  
12. // print that to screen
13. echo $content;
14.  
15. // also get extra information about the page
16. $content = $curl->scrap('https://www.somewebsite.com/', false);
17.  
18. // print that to screen
19. print_r('<pre>');
20. print_r($content);

Arguments

Tags

void ssl ( [ boolean $verify_peer = true ] , [ integer $verify_host = 2 ] , [ mixed $file = false ] , [ mixed $path = false ] )

Requests made over HTTPS usually require additional configuration, depending on the server. Most of the times the defaults set by the library will get you through but, if defaults are not working, you can set specific options using this method.

1. // instantiate the class
2. $curl = new Zebra_cURL();
3.  
4. // instruct the library to skip verifying peer's SSL certificate
5. // (ignored if request is not made through HTTPS)
6. $curl->ssl(false);
7.  
8. // fetch a page
9. $curl->get('https://www.somewebsite.com/', function($result) {
10.     print_r("<pre>");
11.     print_r($result);
12. });

Arguments

void start ()

Executes queued requests.

See queue method.

Tags