PHP Class Zebra_cURL

__construct() public method

Below is the list of default options set by the library when instantiated: - CURLINFO_HEADER_OUT - TRUE; get the last request header; if set to FALSE the "last_request" entry of the "headers" attribute of the object given as argument to the callback function, will be an empty string; - CURLOPT_AUTOREFERER - TRUE; automatically set the Referer: field in requests where it follows a Location: redirect; - CURLOPT_COOKIEFILE - empty string; no cookies are loaded, but cookie handling is still enabled - CURLOPT_CONNECTTIMEOUT - 10; the number of seconds to wait while trying to connect. use 0 to wait indefinitely; - CURLOPT_ENCODING - gzip,deflate; the contents of the "Accept-Encoding:" header; it enables decoding of the response - CURLOPT_FOLLOWLOCATION - TRUE; automatically 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 as specified by the value of CURLOPT_MAXREDIRS - see below); - CURLOPT_HEADER - TRUE; get the response header(s); if set to FALSE the "responses" entry of the "headers" attribute of the object given as argument to the callback function, will be an empty string; - CURLOPT_MAXREDIRS - 50; the maximum amount of HTTP redirections to follow; used together with CURLOPT_FOLLOWLOCATION; - CURLOPT_RETURNTRANSFER - TRUE; return the transfer's body as a string instead of outputting it directly; if set to FALSE the "body" attribute of the object given as argument to a callback function will be an empty string; - CURLOPT_SSL_VERIFYHOST - 2; check the existence of a common name in the SSL peer certificate (for when connecting to HTTPS), and that it matches with the provided hostname; see also the {@link ssl} method; - CURLOPT_SSL_VERIFYPEER - FALSE; stop cURL from verifying the peer's certificate (which would most likely cause the request to fail). see also the {@link ssl} method; - CURLOPT_TIMEOUT - 10; the maximum number of seconds to allow cURL functions to execute; - 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

public __construct ( boolean $htmlentities = true ) : void
$htmlentities	boolean	Instructs the script whether the response body returned by the {@link get} and {@link post} methods should be run through PHP's {@link http://php.net/manual/en/function.htmlentities.php htmlentities} function. @return void
return	void

cache() public method

Note that only the actual request is cached and not associated downloads, if any! Caching is disabled by default! the callback function to be executed for each and every request, as soon as a request finishes the callback function receives as argument an object with 4 properties (info, header, body and response) function mycallback($result) { everything went well at cURL level if ($result->response[1] == CURLE_OK) { if server responded with code 200 (meaning that everything went well) see http://httpstatus.es/ for a list of possible response codes if ($result->info['http_code'] == 200) { see all the returned data print_r('

');
            print_r($result);
show the server's response code
        } else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
    } else die('cURL responded with: ' . $result->response[0]);

}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
cache results in the "cache" folder and for 86400 seconds (24 hours)
$curl->cache('cache', 86400);
let's fetch the RSS feeds of some popular tech-related websites
execute the "mycallback" function for each request, as soon as it finishes
$curl->get(array(
    'http://feeds.feedburner.com/alistapart/main',
    'http://feeds.feedburner.com/TechCrunch',
    'http://feeds.mashable.com/mashable',
), 'mycallback')
        

public cache ( string $path, integer $lifetime = 3600, boolean $compress = true, octal $chmod = 493 ) : void
$path	string	Path where cache files to be stored. Setting this to FALSE will disable caching. If set to a non-existing path, the library will try to create the folder and will trigger an error if, for whatever reasons, it is unable to do so. If the folder can be created, its permissions will be set to the value of $chmod @param integer $lifetime (Optional) The number of seconds after which cache will be considered expired. Default is 3600 (one hour). @param boolean $compress (Optional) If set to TRUE, cache files will be {@link http://php.net/manual/en/function.gzcompress.php gzcompress}-ed so that they occupy less disk space. Default is TRUE. @param octal $chmod (Optional) The file system permissions to be set for newly created cache files. I suggest using the value "0755" (without the quotes) but, if you know what you are doing, here is how you can calculate the permission levels: - 400 Owner Read - 200 Owner Write - 100 Owner Execute - 40 Group Read - 20 Group Write - 10 Group Execute - 4 Global Read - 2 Global Write - 1 Global Execute Default is "0755" (without the quotes). @return void
$lifetime	integer
$compress	boolean
$chmod	octal
return	void

cookies() public method

This method will automatically set the CURLOPT_COOKIEJAR and CURLOPT_COOKIEFILE options.

public cookies ( string $path ) : void
$path	string	The path to a file to save to / retrieve cookies from. If file does not exist the library will attempt to create it, and if it is unable to create it will trigger an error. @return void
return	void

delete() public method

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 - TRUE - CURLOPT_FILE Multiple requests are processed asynchronously, in parallel, and the callback function is called for each and every request, as soon as a request finishes. The number of parallel requests to be constantly processed, at all times, can be set through the {@link threads} property. See also the {@link pause_interval} property. Note that requests may not finish in the same order as initiated! the callback function to be executed for each and every request, as soon as a request finishes the callback function receives as argument an object with 4 properties (info, header, body and response) function mycallback($result) { everything went well at cURL level if ($result->response[1] == CURLE_OK) { if server responded with code 200 (meaning that everything went well) see http://httpstatus.es/ for a list of possible response codes if ($result->info['http_code'] == 200) { see all the returned data print_r('

');
            print_r($result);
show the server's response code
        } else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
    } else die('cURL responded with: ' . $result->response[0]);

}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
do a PUT and execute the "mycallback" function for each
request, as soon as it finishes
$curl->delete(array(
    'http://www.somewebsite.com'  =>  array(
        'data_1'  =>  'value 1',
        'data_2'  =>  'value 2',
    ),
), 'mycallback');
        

public delete ( mixed $urls, mixed $callback = '' ) : void
$urls	mixed	An associative array in the form of url => delete-data, where "delete-data" is an associative array in the form of name => value. "delete-data" can also be an arbitrary string - useful if you want to send raw data (like a JSON) The Content-Type header will be set to multipart/form-data. @param mixed $callback (Optional) Callback function to be called as soon as a request finishes. May be given as a string representing a name of an existing function, as an anonymous function created on the fly via {@link http://www.php.net/manual/en/function.create-function.php create_function} or via a {@link http://www.php.net/manual/en/function.create-function.php closure}. The callback function receives as first argument an object with 4 properties as described below, while any further arguments passed to the {@link delete} method will be passed as extra arguments to the callback function: - info - an associative array containing information about the request that just finished, as returned by PHP's {@link http://php.net/manual/en/function.curl-getinfo.php curl_getinfo()} function; - headers - an associative array with 2 items: - last_request an array with a single entry containing the request headers generated by the last request; so, remember, if there are redirects involved, there will be more requests made, but only information from the last one will be available; if explicitly disabled via the {@link option} method by setting CURLINFO_HEADER_OUT to 0 or FALSE, this will be an empty string; - responses an array with one or more entries (if there are redirects involved) with the response headers of all the requests made; if explicitly disabled via the {@link option} method by setting CURLOPT_HEADER to 0 or FALSE, this will be an empty string; Unless disabled, each entry in the headers' array is an associative array in the form of property => value - body - the response of the request (the content of the page at the URL). Unless disabled via the {@link __construct() constructor}, all applicable characters will be converted to HTML entities via PHP's {@link http://php.net/manual/en/function.htmlentities.php htmlentities} function, so remember to use PHP's {@link http://www.php.net/manual/en/function.html-entity-decode.php html_entity_decode} function to do reverse this, if it's the case; If "body" is explicitly disabled via the {@link option} method by setting CURLOPT_NOBODY to 0 or FALSE, this will be an empty string; - response - the response given by the cURL library as an array with 2 entries: the first entry is the textual representation of the result's code, while second is the result's code itself; if the request was successful, these values will be array(CURLE_OK, 0); consult {@link http://www.php.net/manual/en/function.curl-errno.php#103128 this list} to see the possible values of this property; If the callback function returns FALSE while {@link cache} is enabled, the library will not cache the respective request, making it easy to retry failed requests without having to clear all cache. @since 1.3.3 @return void
$callback	mixed
return	void

download() public method

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 Files are downloaded preserving their original names, so you may want to check that if you are downloading more files having the same name! Multiple requests are processed asynchronously, in parallel, and the callback function is called for each and every request, as soon as a request finishes. The number of parallel requests to be constantly processed, at all times, can be set through the {@link threads} property. See also the {@link pause_interval} property. Note that requests may not finish in the same order as initiated! the callback function to be executed for each and every request, as soon as a request finishes the callback function receives as argument an object with 4 properties (info, header, body and response) function mycallback($result) { everything went well at cURL level if ($result->response[1] == CURLE_OK) { if server responded with code 200 (meaning that everything went well) see http://httpstatus.es/ for a list of possible response codes if ($result->info['http_code'] == 200) { see all the returned data print_r('

');
            print_r($result);
show the server's response code
        } else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
    } else die('cURL responded with: ' . $result->response[0]);

}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
download 2 images from 2 different websites, and
execute the "mycallback" function for each request, as soon as it finishes
$curl->download(array(
    'http://www.somewebsite.com/images/alpha.jpg',
    'http://www.otherwebsite.com/images/omega.jpg',
), 'destination/path/', 'mycallback');
        

public download ( mixed $urls, string $path, mixed $callback = '' ) : void
$urls	mixed	A single URL or an array of URLs to process. @param string $path The path to where to save the file(s) to. If path is not pointing to a directory or is not writable, the library will trigger an error. @param mixed $callback (Optional) Callback function to be called as soon as a request finishes. May be given as a string representing a name of an existing function, as an anonymous function created on the fly via {@link http://www.php.net/manual/en/function.create-function.php create_function} or via a {@link http://www.php.net/manual/en/function.create-function.php closure}. The callback function receives as first argument an object with 4 properties as described below, while any further arguments passed to the {@link download} method will be passed as extra arguments to the callback function: - info - an associative array containing information about the request that just finished, as returned by PHP's {@link http://php.net/manual/en/function.curl-getinfo.php curl_getinfo} function; there's also an extra entry called original_url because, as curl_getinfo() only returns information about the last request, the original URL may be lost otherwise. - headers - an associative array with 2 items: - last_request an array with a single entry containing the request headers generated by the last request; so, remember, if there are redirects involved, there will be more requests made, but only information from the last one will be available; if explicitly disabled via the {@link option} method by setting CURLINFO_HEADER_OUT to 0 or FALSE, this will be an empty string; - responses an empty string as it is not available for this method; Unless disabled, each entry in the headers' array is an associative array in the form of property => value - body - an empty string as it is not available for this method; - response - the response given by the cURL library as an array with 2 entries: the first entry is the textual representation of the result's code, while second is the result's code itself; if the request was successful, these values will be array(CURLE_OK, 0); consult {@link http://www.php.net/manual/en/function.curl-errno.php#103128 this list} to see the possible values of this property; If the callback function returns FALSE while {@link cache} is enabled, the library will not cache the respective request, making it easy to retry failed requests without having to clear all cache. @return void
$path	string
$callback	mixed
return	void

ftp_download() public method

Downloads from an FTP server to which the connection is made using the given $username and $password arguments, one or more files specified by the $urls argument, 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 a 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 Files are downloaded preserving their name so you may want to check that, if you are downloading more files having the same name (either from the same, or from different servers)! Multiple requests are processed asynchronously, in parallel, and the callback function is called for each and every request, as soon as a request finishes. The number of parallel requests to be constantly processed, at all times, can be set through the {@link threads} property. See also the {@link pause_interval} property. Note that requests may not finish in the same order as initiated! the callback function to be executed for each and every request, as soon as a request finishes the callback function receives as argument an object with 4 properties (info, header, body and response) function mycallback($result) { everything went well at cURL level if ($result->response[1] == CURLE_OK) { if server responded with code 200 (meaning that everything went well) see http://httpstatus.es/ for a list of possible response codes if ($result->info['http_code'] == 200) { see all the returned data print_r('

');
            print_r($result);
show the server's response code
        } else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
    } else die('cURL responded with: ' . $result->response[0]);

}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
connect to the FTP server using the given credential, download a file to a given location and
execute the "mycallback" function for each request, as soon as it finishes
$curl->ftp_download('ftp://somefile.ext', 'destination/path', 'username', 'password', 'mycallback');
        

public ftp_download ( mixed $urls, string $path, string $username = '', string $password = '', mixed $callback = '' ) : void
$urls	mixed	A single URL or an array of URLs to process. @param string $path The path to where to save the file(s) to. If path is not pointing to a directory or is not writable, the library will trigger an error. @param string $username (Optional) The username to be used to connect to the FTP server (if required). @param string $password (Optional) The password to be used to connect to the FTP server (if required). @param mixed $callback (Optional) Callback function to be called as soon as a request finishes. May be given as a string representing a name of an existing function, as an anonymous function created on the fly via {@link http://www.php.net/manual/en/function.create-function.php create_function} or via a {@link http://www.php.net/manual/en/function.create-function.php closure}. The callback function receives as first argument an object with 4 properties as described below, while any further arguments passed to the {@link ftp_download} method will be passed as extra arguments to the callback function: - info - an associative array containing information about the request that just finished, as returned by PHP's {@link http://php.net/manual/en/function.curl-getinfo.php curl_getinfo} function; - headers - an associative array with 2 items: - last_request an array with a single entry containing the request headers generated by the last request; so, remember, if there are redirects involved, there will be more requests made, but only information from the last one will be available; if explicitly disabled via the {@link option} method by setting CURLINFO_HEADER_OUT to 0 or FALSE, this will be an empty string; - responses an empty string as it is not available for this method; Unless disabled, each entry in the headers' array is an associative array in the form of property => value - body - an empty string as it is not available for this method; - response - the response given by the cURL library as an array with 2 entries: the first entry is the textual representation of the result's code, while second is the result's code itself; if the request was successful, these values will be array(CURLE_OK, 0); consult {@link http://www.php.net/manual/en/function.curl-errno.php#103128 this list} to see the possible values of this property; If the callback function returns FALSE while {@link cache} is enabled, the library will not cache the respective request, making it easy to retry failed requests without having to clear all cache. @return void
$path	string
$username	string
$password	string
$callback	mixed
return	void

get() public method

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 a request finishes. The number of parallel requests to be constantly processed, at all times, can be set through the {@link threads} property. See also the {@link pause_interval} property. Note that requests may not finish in the same order as initiated! the callback function to be executed for each and every request, as soon as a request finishes the callback function receives as argument an object with 4 properties (info, header, body and response) function mycallback($result) { everything went well at cURL level if ($result->response[1] == CURLE_OK) { if server responded with code 200 (meaning that everything went well) see http://httpstatus.es/ for a list of possible response codes if ($result->info['http_code'] == 200) { see all the returned data print_r('

');
            print_r($result);
show the server's response code
        } else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
    } else die('cURL responded with: ' . $result->response[0]);

}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
cache results in the "cache" folder and for 3600 seconds (one hour)
$curl->cache('cache', 3600);
let's fetch the RSS feeds of some popular websites
execute the "mycallback" function for each request, as soon as it finishes
$curl->get(array(
    'http://feeds.feedburner.com/alistapart/main',
    'http://feeds.feedburner.com/TechCrunch',
    'http://feeds.mashable.com/mashable',
), 'mycallback')
        

public get ( mixed $urls, mixed $callback = '' ) : void
$urls	mixed	A single URL or an array of URLs to process. @param mixed $callback (Optional) Callback function to be called as soon as a request finishes. May be given as a string representing a name of an existing function, as an anonymous function created on the fly via {@link http://www.php.net/manual/en/function.create-function.php create_function} or via a {@link http://www.php.net/manual/en/function.create-function.php closure}. The callback function receives as first argument an object with 4 properties as described below, while any further arguments passed to the {@link get} method will be passed as extra arguments to the callback function: - info - an associative array containing information about the request that just finished, as returned by PHP's {@link http://php.net/manual/en/function.curl-getinfo.php curl_getinfo} function; - headers - an associative array with 2 items: - last_request an array with a single entry containing the request headers generated by the last request; so, remember, if there are redirects involved, there will be more requests made, but only information from the last one will be available; - responses an array with one or more entries (if there are redirects involved) with the response headers of all the requests made; Each entry in the headers' array is an associative array in the form of property => value - body - the response of the request (the content of the page at the URL). Unless disabled via the {@link __construct() constructor}, all applicable characters will be converted to HTML entities via PHP's {@link http://php.net/manual/en/function.htmlentities.php htmlentities} function, so remember to use PHP's {@link http://www.php.net/manual/en/function.html-entity-decode.php html_entity_decode} function to do reverse this, if it's the case; - response - the response given by the cURL library as an array with 2 entries: the first entry is the textual representation of the result's code, while second is the result's code itself; if the request was successful, these values will be array(CURLE_OK, 0); consult {@link http://www.php.net/manual/en/function.curl-errno.php#103128 this list} to see the possible values of this property; If the callback function returns FALSE while {@link cache} is enabled, the library will not cache the respective request, making it easy to retry failed requests without having to clear all cache. @return void
$callback	mixed
return	void

header() public method

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 a request finishes. The number of parallel requests to be constantly processed, at all times, can be set through the {@link threads} property. See also the {@link pause_interval} property. Note that requests may not finish in the same order as initiated! the callback function to be executed for each and every request, as soon as a request finishes the callback function receives as argument an object with 4 properties (info, header, body and response) function mycallback($result) { everything went well at cURL level if ($result->response[1] == CURLE_OK) { if server responded with code 200 (meaning that everything went well) see http://httpstatus.es/ for a list of possible response codes if ($result->info['http_code'] == 200) { see all the returned data print_r('

');
            print_r($result);
show the server's response code
        } else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
    } else die('cURL responded with: ' . $result->response[0]);

}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
process given URLs execute the "mycallback" function for each
request, as soon as it finishes
$curl->header('http://www.somewebsite.com', 'mycallback');
        

public header ( mixed $urls, mixed $callback = '' ) : void
$urls	mixed	A single URL or an array of URLs to process. @param mixed $callback (Optional) Callback function to be called as soon as a request finishes. May be given as a string representing a name of an existing function, as an anonymous function created on the fly via {@link http://www.php.net/manual/en/function.create-function.php create_function} or via a {@link http://www.php.net/manual/en/function.create-function.php closure}. The callback function receives as first argument an object with 4 properties as described below, while any further arguments passed to the {@link header} method will be passed as extra arguments to the callback function: - info - an associative array containing information about the request that just finished, as returned by PHP's {@link http://php.net/manual/en/function.curl-getinfo.php curl_getinfo} function; - headers - an associative array with 2 items: - last_request an array with a single entry containing the request headers generated by the last request; so, remember, if there are redirects involved, there will be more requests made, but only information from the last one will be available; - responses an array with one or more entries (if there are redirects involved) with the response headers of all the requests made; Each entry in the headers' array is an associative array in the form of property => value - body - an empty string as it is not available for this method; - response - the response given by the cURL library as an array with 2 entries: the first entry is the textual representation of the result's code, while second is the result's code itself; if the request was successful, these values will be array(CURLE_OK, 0); consult {@link http://www.php.net/manual/en/function.curl-errno.php#103128 this list} to see the possible values of this property; If the callback function returns FALSE while {@link cache} is enabled, the library will not cache the respective request, making it easy to retry failed requests without having to clear all cache. @return void
$callback	mixed
return	void

http_authentication() public method

the callback function to be executed for each and every request, as soon as a request finishes the callback function receives as argument an object with 4 properties (info, header, body and response) function mycallback($result) { everything went well at cURL level if ($result->response[1] == CURLE_OK) { if server responded with code 200 (meaning that everything went well) see http://httpstatus.es/ for a list of possible response codes if ($result->info['http_code'] == 200) { see all the returned data print_r('

');
            print_r($result);
show the server's response code
        } else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
    } else die('cURL responded with: ' . $result->response[0]);

}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
prepare user name and password
$curl->http_authentication('username', 'password');
get content from a page that requires prior HTTP authentication
$curl->get('http://www.some-page-requiring-prior-http-authentication.com', 'mycallback');


If you have to unset previously set values use

$curl->http_authentication();
        

public http_authentication ( string $username = '', string $password = '', string $type = CURLAUTH_ANY ) : void
$username	string	User name to be used for authentication. @param string $password Password to be used for authentication. @param string $type (Optional) The HTTP authentication method(s) to use. The options are: - CURLAUTH_BASIC - CURLAUTH_DIGEST - CURLAUTH_GSSNEGOTIATE - CURLAUTH_NTLM - CURLAUTH_ANY - CURLAUTH_ANYSAFE The bitwise | (or) operator can be used to combine more than one method. If this is done, cURL will poll the server to see what methods it supports and pick the best one. CURLAUTH_ANY is an alias for CURLAUTH_BASIC | CURLAUTH_DIGEST | CURLAUTH_GSSNEGOTIATE | CURLAUTH_NTLM. CURLAUTH_ANYSAFE is an alias for CURLAUTH_DIGEST | CURLAUTH_GSSNEGOTIATE | CURLAUTH_NTLM. Default is CURLAUTH_ANY. @return void
$password	string
$type	string
return	void

option() public method

include the Zebra_cURL library require 'path/to/Zebra_cURL'; instantiate the Zebra_cURL object $curl = new Zebra_cURL(); setting a single option $curl->option(CURLOPT_CONNECTTIMEOUT, 10); setting multiple options at once $curl->option(array( CURLOPT_TIMEOUT => 10, CURLOPT_CONNECTTIMEOUT => 10, )); make a request here...

public option ( mixed $option, mixed $value = '' ) : void
$option	mixed	A single option for which to set a value, or an associative array in the form of option => value (in case of an array, the $value argument will be disregarded). Setting a value to null will "unset" that option. @param mixed $value (Optional) If the $option argument is not an array, then this argument represents the value to be set for the respective option. If the $option argument is an array, then the value of this argument will be ignored. Setting a value to null will "unset" that option. @return void
$value	mixed
return	void

post() public method

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 - TRUE - CURLOPT_FILE Multiple requests are processed asynchronously, in parallel, and the callback function is called for each and every request, as soon as a request finishes. The number of parallel requests to be constantly processed, at all times, can be set through the {@link threads} property. See also the {@link pause_interval} property. Note that requests may not finish in the same order as initiated! the callback function to be executed for each and every request, as soon as a request finishes the callback function receives as argument an object with 4 properties (info, header, body and response) function mycallback($result) { everything went well at cURL level if ($result->response[1] == CURLE_OK) { if server responded with code 200 (meaning that everything went well) see http://httpstatus.es/ for a list of possible response codes if ($result->info['http_code'] == 200) { see all the returned data print_r('

');
            print_r($result);
show the server's response code
        } else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
    } else die('cURL responded with: ' . $result->response[0]);

}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
do a POST and execute the "mycallback" function for each
request, as soon as it finishes
$curl->post(array(
    'http://www.somewebsite.com'  =>  array(
        'data_1'  =>  'value 1',
        'data_2'  =>  'value 2',
    ),
), 'mycallback');
note that we're also uploading a file this time
and note that we're prefixing the file name with @
$curl->post(array(
    'http://www.somewebsite.com'  =>  array(
        'data_1'  =>  'value 1',
        'data_2'  =>  'value 2',
        'data_3'  =>  '@absolute/path/to/file.ext',
), 'mycallback');
        

public post ( mixed $urls, mixed $callback = '' ) : void
$urls	mixed	An associative array in the form of url => post-data, where "post-data" is an associative array in the form of name => value. "post-data" can also be an arbitrary string - useful if you want to send raw data (like a JSON) To post a file, prepend the filename with @ and use the full server path. For PHP 5.5+ files are uploaded using {@link http://php.net/manual/ro/class.curlfile.php CURLFile} and {@link https://wiki.php.net/rfc/curl-file-upload CURLOPT_SAFE_UPLOAD} will be set to TRUE. For lower PHP versions, files will be uploaded the "old" way and the file's mime type should be explicitly specified by following the filename with the type in the format ';type=mimetype'. as most of the times cURL will send the wrong mime type... The Content-Type header will be set to multipart/form-data. @param mixed $callback (Optional) Callback function to be called as soon as a request finishes. May be given as a string representing a name of an existing function, as an anonymous function created on the fly via {@link http://www.php.net/manual/en/function.create-function.php create_function} or via a {@link http://www.php.net/manual/en/function.create-function.php closure}. The callback function receives as first argument an object with 4 properties as described below, while any further arguments passed to the {@link post} method will be passed as extra arguments to the callback function: - info - an associative array containing information about the request that just finished, as returned by PHP's {@link http://php.net/manual/en/function.curl-getinfo.php curl_getinfo} function; - headers - an associative array with 2 items: - last_request an array with a single entry containing the request headers generated by the last request; so, remember, if there are redirects involved, there will be more requests made, but only information from the last one will be available; if explicitly disabled via the {@link option} method by setting CURLINFO_HEADER_OUT to 0 or FALSE, this will be an empty string; - responses an array with one or more entries (if there are redirects involved) with the response headers of all the requests made; if explicitly disabled via the {@link option} method by setting CURLOPT_HEADER to 0 or FALSE, this will be an empty string; Unless disabled, each entry in the headers' array is an associative array in the form of property => value - body - the response of the request (the content of the page at the URL). Unless disabled via the {@link __construct() constructor}, all applicable characters will be converted to HTML entities via PHP's {@link http://php.net/manual/en/function.htmlentities.php htmlentities} function, so remember to use PHP's {@link http://www.php.net/manual/en/function.html-entity-decode.php html_entity_decode} function to do reverse this, if it's the case; If "body" is explicitly disabled via the {@link option} method by setting CURLOPT_NOBODY to 0 or FALSE, this will be an empty string; - response - the response given by the cURL library as an array with 2 entries: the first entry is the textual representation of the result's code, while second is the result's code itself; if the request was successful, these values will be array(CURLE_OK, 0); consult {@link http://www.php.net/manual/en/function.curl-errno.php#103128 this list} to see the possible values of this property; If the callback function returns FALSE while {@link cache} is enabled, the library will not cache the respective request, making it easy to retry failed requests without having to clear all cache. @return void
$callback	mixed
return	void

proxy() public method

the callback function to be executed for each and every request, as soon as a request finishes function mycallback($result) { everything went well at cURL level if ($result->response[1] == CURLE_OK) { if server responded with code 200 (meaning that everything went well) see http://httpstatus.es/ for a list of possible response codes if ($result->info['http_code'] == 200) { see all the returned data print_r('

');
            print_r($result);
show the server's response code
        } else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
    } else die('cURL responded with: ' . $result->response[0]);

}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the class
$curl = new Zebra_cURL();
connect to a proxy server
(that's a random one i got from http://www.hidemyass.com/proxy-list/)
$curl->proxy('187.63.32.250', '3128');
fetch a page
$curl->get('http://www.somewebsite.com/', 'mycallback');
        

public proxy ( string $proxy, string $port = 80, string $username = '', string $password = '' ) : void
$proxy	string	The HTTP proxy to tunnel requests through. Can be an URL or an IP address. This option can also be set using the {@link option} method and setting CURLOPT_PROXY option to the desired value. Setting this argument to FALSE will "unset" all the proxy-related options. @param string $port (Optional) The port number of the proxy to connect to. Default is 80. This option can also be set using the {@link option} method and setting CURLOPT_PROXYPORT option to the desired value. @param string $username (Optional) The username to be used for the connection to the proxy (if required by the proxy) Default is "" (an empty string) The username and the password can also be set using the {@link option} method and setting CURLOPT_PROXYUSERPWD option to the desired value formatted like [username]:[password]. . @param string $password (Optional) The password to be used for the connection to the proxy (if required by the proxy) Default is "" (an empty string) The username and the password can also be set using the {@link option} method and setting CURLOPT_PROXYUSERPWD option to the desired value formatted like [username]:[password]. . @return void
$port	string
$username	string
$password	string
return	void

put() public method

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 - TRUE - CURLOPT_FILE Multiple requests are processed asynchronously, in parallel, and the callback function is called for each and every request, as soon as a request finishes. The number of parallel requests to be constantly processed, at all times, can be set through the {@link threads} property. See also the {@link pause_interval} property. Note that requests may not finish in the same order as initiated! the callback function to be executed for each and every request, as soon as a request finishes the callback function receives as argument an object with 4 properties (info, header, body and response) function mycallback($result) { everything went well at cURL level if ($result->response[1] == CURLE_OK) { if server responded with code 200 (meaning that everything went well) see http://httpstatus.es/ for a list of possible response codes if ($result->info['http_code'] == 200) { see all the returned data print_r('

');
            print_r($result);
show the server's response code
        } else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
    } else die('cURL responded with: ' . $result->response[0]);

}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
do a PUT and execute the "mycallback" function for each
request, as soon as it finishes
$curl->put(array(
    'http://www.somewebsite.com'  =>  array(
        'data_1'  =>  'value 1',
        'data_2'  =>  'value 2',
    ),
), 'mycallback');
        

public put ( mixed $urls, mixed $callback = '' ) : void
$urls	mixed	An associative array in the form of url => put-data, where "put-data" is an associative array in the form of name => value. "put-data" can also be an arbitrary string - useful if you want to send raw data (like a JSON) To put a file, prepend the filename with @ and use the full server path. For PHP 5.5+ files are uploaded using {@link http://php.net/manual/ro/class.curlfile.php CURLFile} and {@link https://wiki.php.net/rfc/curl-file-upload CURLOPT_SAFE_UPLOAD} will be set to TRUE. For lower PHP versions, files will be uploaded the "old" way and the file's mime type should be explicitly specified by following the filename with the type in the format ';type=mimetype'. as most of the times cURL will send the wrong mime type... The Content-Type header will be set to multipart/form-data. @param mixed $callback (Optional) Callback function to be called as soon as a request finishes. May be given as a string representing a name of an existing function, as an anonymous function created on the fly via {@link http://www.php.net/manual/en/function.create-function.php create_function} or via a {@link http://www.php.net/manual/en/function.create-function.php closure}. The callback function receives as first argument an object with 4 properties as described below, while any further arguments passed to the {@link put} method will be passed as extra arguments to the callback function: - info - an associative array containing information about the request that just finished, as returned by PHP's {@link http://php.net/manual/en/function.curl-getinfo.php curl_getinfo} function; - headers - an associative array with 2 items: - last_request an array with a single entry containing the request headers generated by the last request; so, remember, if there are redirects involved, there will be more requests made, but only information from the last one will be available; if explicitly disabled via the {@link option} method by setting CURLINFO_HEADER_OUT to 0 or FALSE, this will be an empty string; - responses an array with one or more entries (if there are redirects involved) with the response headers of all the requests made; if explicitly disabled via the {@link option} method by setting CURLOPT_HEADER to 0 or FALSE, this will be an empty string; Unless disabled, each entry in the headers' array is an associative array in the form of property => value - body - the response of the request (the content of the page at the URL). Unless disabled via the {@link __construct() constructor}, all applicable characters will be converted to HTML entities via PHP's {@link http://php.net/manual/en/function.htmlentities.php htmlentities} function, so remember to use PHP's {@link http://www.php.net/manual/en/function.html-entity-decode.php html_entity_decode} function to do reverse this, if it's the case; If "body" is explicitly disabled via the {@link option} method by setting CURLOPT_NOBODY to 0 or FALSE, this will be an empty string; - response - the response given by the cURL library as an array with 2 entries: the first entry is the textual representation of the result's code, while second is the result's code itself; if the request was successful, these values will be array(CURLE_OK, 0); consult {@link http://www.php.net/manual/en/function.curl-errno.php#103128 this list} to see the possible values of this property; If the callback function returns FALSE while {@link cache} is enabled, the library will not cache the respective request, making it easy to retry failed requests without having to clear all cache. @since 1.3.3 @return void
$callback	mixed
return	void

queue() public method

Until {@link start} method is called, all calls to {@link delete}, {@link download}, {@link ftp_download}, {@link get}, {@link header}, {@link post} and {@link put} methods will queue up rather than being executed right away. Once the {@link start} method is called, all queued requests will be processed while values of {@link threads} and {@link pause_interval} properties will still apply. the callback function to be executed for each and every request, as soon as a request finishes the callback function receives as argument an object with 4 properties (info, header, body and response) function mycallback($result) { everything went well at cURL level if ($result->response[1] == CURLE_OK) { if server responded with code 200 (meaning that everything went well) see http://httpstatus.es/ for a list of possible response codes if ($result->info['http_code'] == 200) { see all the returned data print_r('

');
            print_r($result);
show the server's response code
        } else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
    } else die('cURL responded with: ' . $result->response[0]);

}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
queue requests - useful for grouping different types of requests
in this example, when the "start" method is called, we'll execute
the "get" and the "post" requests simultaneously as if it was a
single request
$curl->queue();
do a POST and execute the "mycallback" function for each
request, as soon as it finishes
$curl->post(array(
    'http://www.somewebsite.com'  =>  array(
        'data_1'  =>  'value 1',
        'data_2'  =>  'value 2',
    ),
), 'mycallback');
let's fetch the RSS feeds of some popular websites
execute the "mycallback" function for each request, as soon as it finishes
$curl->get(array(
    'http://feeds.feedburner.com/alistapart/main',
    'http://feeds.feedburner.com/TechCrunch',
    'http://feeds.mashable.com/mashable',
), 'mycallback')
execute queued requests
$curl->start();
        

public queue ( ) : void
return	void

scrap() public method

include the Zebra_cURL library require 'path/to/Zebra_cURL'; instantiate the class $curl = new Zebra_cURL(); get page's content only $content = $curl->get('https://www.somewebsite.com/', true); print that to screen echo $content; get everything we can about the page $content = $curl->get('https://www.somewebsite.com/'); print that to screen print_r('

');
print_r($content);
        

public scrap ( string $url, boolean $body_only = false ) : mixed
$url	string	An URL to fetch @param boolean $body_only (Optional) When set to TRUE, will instruct the method to return only the page's content, without info, headers, responses, etc. When set to FALSE, will instruct the method to return everything it can about the scrapped page, as an object with properties as described for the $callback argument of the {@link get} method. Default is FALSE. @since 1.3.3 @return mixed Returns the scrapped page's content, when $body_only is set to TRUE, or an object with properties as described for the $callback argument of the {@link get} method.
$body_only	boolean
return	mixed

ssl() public method

include the Zebra_cURL library require 'path/to/Zebra_cURL'; instantiate the class $curl = new Zebra_cURL(); instruct the library to verify peer's SSL certificate (ignored if request is not made through HTTPS) $curl->ssl(true); fetch a page $curl->get('https://www.somewebsite.com/', create_function('$result', 'print_r("

"); print_r($result);'));
        

public ssl ( boolean $verify_peer = true, integer $verify_host = 2, mixed $file = false, mixed $path = false ) : void
$verify_peer	boolean	(Optional) Should the peer's certificate be verified by cURL? Default is TRUE. This option can also be set using the {@link option} method and setting CURLOPT_SSL_VERIFYPEER option to the desired value. @param integer $verify_host (Optional) Specifies whether or not to check the existence of a common name in the SSL peer certificate and that it matches with the provided hostname. - 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; in production environments the value of this option should be kept at 2; Default is 2 Support for value 1 removed in cURL 7.28.1 This option can also be set using the {@link option} method and setting CURLOPT_SSL_VERIFYHOST option to the desired value. @param mixed $file (Optional) An absolute path to a file holding one or more certificates to verify the peer with. This only makes sense if CURLOPT_SSL_VERIFYPEER is set to TRUE. Default is FALSE. This option can also be set using the {@link option} method and setting CURLOPT_CAINFO option to the desired value. @param mixed $path (Optional) An absolute path to a directory that holds multiple CA certificates. This only makes sense if CURLOPT_SSL_VERIFYPEER is set to TRUE. Default is FALSE. This option can also be set using the {@link option} method and setting CURLOPT_CAPATH option to the desired value. @return void
$verify_host	integer
$file	mixed
$path	mixed
return	void

start() public method

See {@link queue} method for more information.

public start ( ) : void
return	void