home *** CD-ROM | disk | FTP | other *** search
/ Cricao de Sites - 650 Layouts Prontos / WebMasters.iso / Servidores / xampp-win32-1.6.7-installer.exe / php / PEAR / Net / Curl.php < prev    next >
Encoding:
PHP Script  |  2008-07-02  |  24.4 KB  |  877 lines

  1. <?php
  2.  
  3. /**
  4.  * An Object Oriented interface to PHP's cURL extension
  5.  *
  6.  * PHP version 5.1.0+
  7.  *
  8.  * Copyright (c) 2007, The PEAR Group
  9.  * 
  10.  * All rights reserved.
  11.  * 
  12.  * Redistribution and use in source and binary forms, with or without 
  13.  * modification, are permitted provided that the following conditions are met:
  14.  *
  15.  *  - Redistributions of source code must retain the above copyright notice,
  16.  *    this list of conditions and the following disclaimer.
  17.  *  - Redistributions in binary form must reproduce the above copyright notice,
  18.  *    this list of conditions and the following disclaimer in the documentation
  19.  *    and/or other materials provided with the distribution.
  20.  *  - Neither the name of the The PEAR Group nor the names of its contributors 
  21.  *    may be used to endorse or promote products derived from this software 
  22.  *    without specific prior written permission.
  23.  *
  24.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
  25.  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
  26.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
  27.  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
  28.  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
  29.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
  30.  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
  31.  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
  32.  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  33.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
  34.  * POSSIBILITY OF SUCH DAMAGE.
  35.  *
  36.  * @category  Net
  37.  * @package   Net_Curl
  38.  * @author    David Costa <gurugeek@php.net>
  39.  * @author    Sterling Hughes <sterling@php.net>
  40.  * @author    Joe Stump <joe@joestump.net>
  41.  * @author    Philippe Jausions <jausions@php.net>
  42.  * @copyright 1997-2008 The PHP Group
  43.  * @license   http://www.opensource.org/licenses/bsd-license.php New BSD License
  44.  * @version   CVS: $Revision: 1.15 $
  45.  * @link      http://pear.php.net/package/Net_Curl
  46.  */
  47.  
  48. /**
  49.  * Include PEAR package for error handling
  50.  */
  51. require_once 'PEAR.php';
  52.  
  53. /**
  54.  * Object-oriented implementation of the Curl extension
  55.  *
  56.  * @category Net
  57.  * @package  Net_Curl
  58.  * @author   David Costa <gurugeek@php.net>
  59.  * @author   Sterling Hughes <sterling@php.net>
  60.  * @author   Joe Stump <joe@joestump.net>
  61.  * @author   Philippe Jausions <jausions@php.net>
  62.  * @license  http://www.opensource.org/licenses/bsd-license.php New BSD License
  63.  * @link     http://pear.php.net/package/Net_Curl
  64.  */
  65. class Net_Curl
  66. {
  67.     // {{{ Public Properties
  68.     /**
  69.      * The URL for cURL to work with
  70.      *
  71.      * @var string $url
  72.      * @access public
  73.      */
  74.     var $url;
  75.  
  76.     /**
  77.      * The Username for standard HTTP Authentication
  78.      *
  79.      * @var string $username
  80.      * @access public
  81.      */
  82.     var $username = '';
  83.  
  84.     /**
  85.      * The Password for standard HTTP Authentication
  86.      *
  87.      * @var string $password
  88.      * @access public
  89.      */
  90.     var $password = '';
  91.  
  92.     /**
  93.      * The SSL version for the transfer
  94.      *
  95.      * @var integer $sslVersion
  96.      * @access public
  97.      */
  98.     var $sslVersion;
  99.  
  100.     /**
  101.      * The filename of the SSL certificate
  102.      *
  103.      * @var string $sslCert
  104.      * @access public
  105.      */
  106.     var $sslCert;
  107.  
  108.     /**
  109.      * The password corresponding to the certificate
  110.      * in the $sslCert property
  111.      *
  112.      * @var string $sslCertPasswd
  113.      * @access public
  114.      */
  115.     var $sslCertPasswd;
  116.  
  117.     /**
  118.      * User Agent string when making an HTTP request
  119.      *
  120.      * @var string $userAgent
  121.      * @access public
  122.      */
  123.     var $userAgent;
  124.  
  125.     /**
  126.      * Whether or not to include the header in the results
  127.      * of the CURL transfer
  128.      *
  129.      * @var boolean $header
  130.      */
  131.     var $header = false;
  132.  
  133.     /**
  134.      * Whether or not to output debug information while executing a
  135.      * curl transfer
  136.      *
  137.      * @var boolean $verbose
  138.      * @access public
  139.      */
  140.     var $verbose = false;
  141.  
  142.     /**
  143.      * Whether or not to display a progress meter for the current transfer
  144.      *
  145.      * @var boolean $progress
  146.      * @access public
  147.      */
  148.     var $progress = false;
  149.  
  150.     /**
  151.      * Whether or not to suppress error messages
  152.      *
  153.      * @var boolean $mute
  154.      * @access public
  155.      */
  156.     var $mute = false;
  157.  
  158.     /**
  159.      * Whether or not to follow HTTP Location headers.
  160.      *
  161.      * @var boolean $followLocation
  162.      * @access public
  163.      */
  164.     var $followLocation = true;
  165.  
  166.     /**
  167.      * Whether or not to follow HTTP Location headers.
  168.      *
  169.      * @var boolean $follow_location
  170.      * @access public
  171.      * @deprecated
  172.      */
  173.     var $follow_location = false;
  174.  
  175.     /**
  176.      * Time allowed for current transfer, in seconds.  0 means no limit
  177.      *
  178.      * @var int $timeout
  179.      * @access public
  180.      */
  181.     var $timeout = 0;
  182.  
  183.     /**
  184.      * Whether or not to return the results of the
  185.      * current transfer
  186.      *
  187.      * @var boolean $returnTransfer
  188.      * @access public
  189.      */
  190.     var $returnTransfer = true;
  191.  
  192.     /**
  193.      * Whether or not to return the results of the
  194.      * current transfer
  195.      *
  196.      * @var boolean $return_transfer
  197.      * @access public
  198.      * @deprecated
  199.      */
  200.     var $return_transfer = false;
  201.  
  202.     /**
  203.      * The type of transfer to perform (ie. 'POST', 'GET', 'PUT', etc)
  204.      *
  205.      * @var string $type
  206.      * @access public
  207.      */
  208.     var $type;
  209.  
  210.     /**
  211.      * The file to upload (PUT, or FTP methods)
  212.      *
  213.      * @var string $file
  214.      * @access public
  215.      */
  216.     var $file;
  217.  
  218.     /**
  219.      * The file size of the file pointed to by the $file
  220.      * property
  221.      *
  222.      * @var integer $fileSize
  223.      * @access public
  224.      */
  225.     var $fileSize;
  226.  
  227.     /**
  228.      * The file size of the file pointed to by the $file
  229.      * property
  230.      *
  231.      * @var integer $file_size
  232.      * @access public
  233.      * @deprecated
  234.      */
  235.     var $file_size = false;
  236.  
  237.  
  238.     /**
  239.      * The cookies to send to the remote site
  240.      *
  241.      * @var array $cookies
  242.      * @access public
  243.      */
  244.     var $cookies = array();
  245.  
  246.     /**
  247.      * Additional HTTP headers to send to the remote site
  248.      *
  249.      * @var array $httpHeaders
  250.      * @access public
  251.      */
  252.     var $httpHeaders = null;
  253.  
  254.     /**
  255.      * Additional HTTP headers to send to the remote site
  256.      *
  257.      * @var array $http_headers
  258.      * @access public
  259.      * @deprecated
  260.      */
  261.     var $http_headers = false;
  262.  
  263.     /**
  264.      * The fields to send in a 'POST' request
  265.      *
  266.      * @var array $fields
  267.      * @access public
  268.      */
  269.     var $fields;
  270.  
  271.     /**
  272.      * The proxy server to go through
  273.      *
  274.      * @var string $proxy
  275.      * @access public
  276.      */
  277.     var $proxy;
  278.  
  279.     /**
  280.      * The username for the Proxy server
  281.      *
  282.      * @var string $proxyUser
  283.      * @access public
  284.      */
  285.     var $proxyUser;
  286.  
  287.     /**
  288.      * The password for the Proxy server
  289.      *
  290.      * @var string $proxyPassword
  291.      * @access public
  292.      */
  293.     var $proxyPassword;
  294.  
  295.     /**
  296.      * $verifyPeer
  297.      *
  298.      * FALSE to stop CURL from verifying the peer's certificate.
  299.      * Alternate certificates to verify against can be specified
  300.      * with the CURLOPT_CAINFO option or a certificate directory
  301.      * can be specified with the CURLOPT_CAPATH option.
  302.      * CURLOPT_SSL_VERIFYHOST may also need to be TRUE or FALSE
  303.      * if CURLOPT_SSL_VERIFYPEER is disabled (it defaults to 2).
  304.      *
  305.      * @var boolean $verifyPeer
  306.      * @access public
  307.      */
  308.     var $verifyPeer = true;
  309.  
  310.     /**
  311.      * $verifyHost
  312.      *
  313.      * 0 : to stop CURL from verifying the host's certificate.
  314.      * 1 : to check the existence of a common name in the SSL peer certificate.
  315.      * 2 : to check the existence of a common name  and also verify that it
  316.      *     matches the hostname provided.
  317.      *
  318.      * @var bool $verifyHost
  319.      * @access public
  320.      */
  321.     var $verifyHost = 2;
  322.  
  323.     /**
  324.      * $caInfo
  325.      *
  326.      * Set value for CURLOPT_CAINFO. The name of a file holding one or more
  327.      * certificates to verify the peer with. This only makes sense when used
  328.      * in combination with CURLOPT_SSL_VERIFYPEER. curl-ca-bundle.crt is
  329.      * avaible on the Curl website http://curl.haxx.se/ for download inside
  330.      * the packages.
  331.      *
  332.      * @var string $caInfo
  333.      * @access public
  334.      */
  335.     var $caInfo = '';
  336.  
  337.     /**
  338.      * $caPath
  339.      *
  340.      * Set value for CURLOPT_CAPATH. A directory that holds multiple CA
  341.      * certificates. Use this option alongside CURLOPT_SSL_VERIFYPEER.
  342.      *
  343.      * @var string $caPath
  344.      * @access public
  345.      */
  346.     var $caPath;
  347.     // }}}
  348.     // {{{ Private Properties
  349.     /**
  350.      * The current curl handle
  351.      *
  352.      * @var resource $_ch
  353.      * @access private
  354.      * @see Net_Curl::create()
  355.      */
  356.     var $_ch = null;
  357.  
  358.     /**
  359.      * The file upload resource
  360.      *
  361.      * The CURLOPT_INFILE requires a file resource and not just a file name.
  362.      * This is used by execute to open the file.
  363.      *
  364.      * @var resource $_fp
  365.      * @access private
  366.      * @see Net_Curl::execute()
  367.      */
  368.     var $_fp = null;
  369.     // }}}
  370.  
  371.     // {{{ __construct($url = '', $userAgent = '')
  372.     /**
  373.      * The Net_Curl PHP 5.x constructor, called when a new Net_Curl object
  374.      * is initialized (also called via 4.x constructor)
  375.      *
  376.      * @param string $url       The URL to fetch (can be set using the $url 
  377.      *                          property as well)
  378.      * @param string $userAgent The userAgent string (can be set using the 
  379.      *                          $userAgent property as well)
  380.      *
  381.      * @access public
  382.      * @author Joe Stump <joe@joestump.net>
  383.      * @return void
  384.      */
  385.     function __construct($url = '', $userAgent = '')
  386.     {
  387.         if (is_string($url) && strlen($url)) {
  388.             $this->url = $url;
  389.         }
  390.  
  391.         if (is_string($userAgent) && strlen($userAgent)) {
  392.             $this->userAgent = $userAgent;
  393.         }
  394.     }
  395.     // }}}
  396.  
  397.     // {{{ Net_Curl($url = '', $userAgent = '')
  398.     /**
  399.      * Net_Curl
  400.      *
  401.      * PHP 4.x constructor.
  402.      *
  403.      * @param string $url       The URL to fetch (can be set using the $url 
  404.      *                          property as well)
  405.      * @param string $userAgent The userAgent string (can be set using the 
  406.      *                          $userAgent property as well)
  407.      *
  408.      * @access public
  409.      * @return void
  410.      */
  411.     function Net_Curl($url = '', $userAgent = '')
  412.     {
  413.         $this->__construct($url, $userAgent);
  414.     }
  415.     // }}}
  416.  
  417.     // {{{ execute()
  418.     /**
  419.      * Executes a prepared CURL transfer
  420.      *
  421.      * Run this function to execute your cURL request. If all goes well you
  422.      * should get a string (the output from the remote host regarding your
  423.      * request) or true (if you choose to output directly to the browser). If
  424.      * something fails then PEAR_Error is returned.
  425.      *
  426.      * <code>
  427.      * <?php
  428.      *     require_once 'Net/Curl.php';
  429.      *
  430.      *     $curl = new Net_Curl('http://www.example.com');
  431.      *     $curl->fields = array('foo' => '1', 'bar' => 'apple');
  432.      *     $result = $curl->execute();
  433.      *     if (!PEAR::isError($result)) {
  434.      *         echo $result;
  435.      *     }
  436.      * ?>
  437.      * </code>
  438.      *
  439.      * @access public
  440.      * @author Sterling Hughes <sterling@php.net>
  441.      * @author Joe Stump <joe@joestump.net>
  442.      * @return PEAR_Error on failure, true/result on success
  443.      * @since  PHP 4.0.5
  444.      */
  445.     function execute()
  446.     {
  447.         // Create cURL handle if it hasn't already been created
  448.         if (!is_resource($this->_ch)) {
  449.             $result = $this->create();
  450.             if (PEAR::isError($result)) {
  451.                 return $result;
  452.             }
  453.         }
  454.  
  455.         // Map the deprecated variables and throw a bunch of errors
  456.         $this->_mapDeprecatedVariables();
  457.  
  458.         // Default return value is true.
  459.         $ret = true;
  460.  
  461.         // Basic stuff
  462.         $ret = curl_setopt($this->_ch, CURLOPT_URL, $this->url);
  463.         $ret = curl_setopt($this->_ch, CURLOPT_HEADER, $this->header);
  464.  
  465.         // Whether or not to return the transfer contents
  466.         if ($this->returnTransfer === true || $this->mute === true) {
  467.             $ret = curl_setopt($this->_ch, CURLOPT_RETURNTRANSFER, true);
  468.         }
  469.  
  470.         // HTTP Authentication
  471.         if ($this->username != '') {
  472.             $ret = curl_setopt($this->_ch, 
  473.                                CURLOPT_USERPWD, 
  474.                                $this->username . ':' . $this->password);
  475.         }
  476.  
  477.         // SSL Checks
  478.         if (isset($this->sslVersion)) {
  479.             $ret = curl_setopt($this->_ch, 
  480.                                CURLOPT_SSLVERSION, 
  481.                                $this->sslVersion);
  482.         }
  483.  
  484.         if (isset($this->sslCert)) {
  485.             $ret = curl_setopt($this->_ch, CURLOPT_SSLCERT, $this->sslCert);
  486.         }
  487.  
  488.         if (isset($this->sslCertPasswd)) {
  489.             $ret = curl_setopt($this->_ch, 
  490.                                CURLOPT_SSLCERTPASSWD, 
  491.                                $this->sslCertPasswd);
  492.         }
  493.  
  494.         // Proxy Related checks
  495.         if (isset($this->proxy)) {
  496.             $ret = curl_setopt($this->_ch, CURLOPT_PROXY, $this->proxy);
  497.         }
  498.  
  499.         if (isset($this->proxyUser) || isset($this->proxyPassword)) {
  500.             $ret = curl_setopt($this->_ch, 
  501.                                CURLOPT_PROXYUSERPWD, 
  502.                                $this->proxyUser . ':' . $this->proxyPassword);
  503.         }
  504.  
  505.         if (is_bool($this->verifyPeer)) {
  506.             if (!$this->setOption(CURLOPT_SSL_VERIFYPEER, $this->verifyPeer)) {
  507.                 return PEAR::raiseError('Error setting CURLOPT_SSL_VERIFYPEER');
  508.             }
  509.         }
  510.  
  511.         if (is_numeric($this->verifyHost) && $this->verifyHost >= 0 &&
  512.             $this->verifyHost <= 2) {
  513.             if (!$this->setOption(CURLOPT_SSL_VERIFYHOST, $this->verifyHost)) {
  514.                 return PEAR::raiseError('Error setting CURLOPT_SSL_VERIFYPEER');
  515.             }
  516.         }
  517.  
  518.         if (is_bool($this->verifyPeer) && $this->verifyPeer == true) {
  519.             if (isset($this->caInfo) && strlen($this->caInfo)) {
  520.                 if (file_exists($this->caInfo)) {
  521.                     if (!$this->setOption(CURLOPT_CAINFO, $this->caInfo)) {
  522.                         return PEAR::raiseError('Error setting CURLOPT_CAINFO');
  523.                     }
  524.                 } else {
  525.                     return PEAR::raiseError('Could not find CA info: '.
  526.                                             $this->caInfo);
  527.                 }
  528.             }
  529.  
  530.             if (isset($this->caPath) && is_string($this->caPath)) {
  531.                 if (!$this->setOption(CURLOPT_CAPATH, $this->caPath)) {
  532.                     return PEAR::raiseError('Error setting CURLOPT_CAPATH');
  533.                 }
  534.             }
  535.         }
  536.  
  537.         // Transfer type
  538.         if (isset($this->type)) {
  539.             switch (strtolower($this->type)) {
  540.             case 'post':
  541.                 $ret = curl_setopt($this->_ch, CURLOPT_POST, true);
  542.                 break;
  543.             case 'put':
  544.                 $ret = curl_setopt($this->_ch, CURLOPT_PUT, true);
  545.                 break;
  546.             }
  547.         }
  548.  
  549.         // Transfer upload, etc. related
  550.         if (isset($this->file)) {
  551.             if (!file_exists($this->file)) {
  552.                 return PEAR::raiseError('File does not exist: '.$this->file);
  553.             }
  554.  
  555.             $this->_fp = fopen($this->file, 'r');
  556.             if (!is_resource($this->_fp)) {
  557.                 return PEAR::raiseError('Could not open file: '.$this->file);
  558.             }
  559.  
  560.             if (!isset($this->fileSize)) {
  561.                 $this->fileSize = filesize($this->file);
  562.             }
  563.  
  564.             $ret = curl_setopt($this->_ch, CURLOPT_INFILE, $this->_fp);
  565.             $ret = curl_setopt($this->_ch, CURLOPT_INFILESIZE, $this->fileSize);
  566.             $ret = curl_setopt($this->_ch, CURLOPT_UPLOAD, true);
  567.         }
  568.  
  569.         if (isset($this->fields)) {
  570.             $sets = null;
  571.             if (!isset($this->type)) {
  572.                 $this->type = 'post';
  573.                 $ret        = curl_setopt($this->_ch, CURLOPT_POST, true);
  574.             }
  575.  
  576.             // If fields is an array then turn it into a string. Sometimes
  577.             // cURL doesn't like fields as an array.
  578.             // Exception: if a value is prefixed with "@" and the rest of the
  579.             //            value resolves to an existing file, then pass
  580.             //            the values as the original array.
  581.             if (is_array($this->fields)) {
  582.                 $sets = array();
  583.                 foreach ($this->fields as $key => $val) {
  584.                     if (strlen($val) > 1 && $val{0} == '@') {
  585.                         $file = substr($val, 1);
  586.                         if (is_file($file) && is_readable($file)) {
  587.                             $sets = null;
  588.                             break;
  589.                         }
  590.                     }
  591.                     $sets[] = urlencode($key) . '=' . urlencode($val);
  592.                 }
  593.             }
  594.  
  595.             if (!is_null($sets)) {
  596.                 $fields = implode('&', $sets);
  597.             } else {
  598.                 $fields = $this->fields;
  599.             }
  600.             $ret = curl_setopt($this->_ch, CURLOPT_POSTFIELDS, $fields);
  601.         }
  602.  
  603.         // Error related
  604.         if ($this->progress === true) {
  605.             $ret = curl_setopt($this->_ch, CURLOPT_PROGRESS, true);
  606.         }
  607.  
  608.         if ($this->verbose === true) {
  609.             $ret = curl_setopt($this->_ch, CURLOPT_VERBOSE, true);
  610.         }
  611.  
  612.         // If a Location: header is passed then follow it
  613.         $ret = curl_setopt($this->_ch, 
  614.                            CURLOPT_FOLLOWLOCATION, 
  615.                            $this->followLocation);
  616.  
  617.         // If a timeout is set and is greater then zero then set it
  618.         if (is_numeric($this->timeout) && $this->timeout > 0) {
  619.             $ret = curl_setopt($this->_ch, CURLOPT_TIMEOUT, $this->timeout);
  620.         }
  621.  
  622.         if (isset($this->userAgent)) {
  623.             $ret = curl_setopt($this->_ch, CURLOPT_USERAGENT, $this->userAgent);
  624.         }
  625.  
  626.         // Cookies
  627.         if (is_array($this->cookies) && count($this->cookies)) {
  628.             $cookieData = '';
  629.             foreach ($this->cookies as $name => $value) {
  630.                 $cookieData .= $name . '=' . $value . ';';
  631.             }
  632.  
  633.             $ret = curl_setopt($this->_ch, CURLOPT_COOKIE, $cookieData);
  634.         }
  635.  
  636.         // Other HTTP headers
  637.         if ($this->httpHeaders !== null) {
  638.             if (is_array($this->httpHeaders)) {
  639.                 $ret = curl_setopt($this->_ch, 
  640.                                    CURLOPT_HTTPHEADER, 
  641.                                    $this->httpHeaders);
  642.             } else {
  643.                 return PEAR::raiseError('Net_Curl::$httpHeaders must be an array');
  644.             }
  645.         }
  646.  
  647.         $ret = curl_exec($this->_ch);
  648.  
  649.         // Close the file before we return anything
  650.         if (is_resource($this->_fp)) {
  651.             fclose($this->_fp);
  652.         }
  653.  
  654.         if (curl_errno($this->_ch)) {
  655.             return PEAR::raiseError(curl_error($this->_ch), curl_errno($this->_ch));
  656.         }
  657.  
  658.         // Check to make sure we get a 2XX/3XX code and not a 404 or something.
  659.         $info = $this->getInfo();
  660.         if (!isset($info['http_code'])) {
  661.             return PEAR::raiseError('Unknown or invalid HTTP response');
  662.         } else {
  663.             $type = substr($info['http_code'], 0, 1);
  664.             if ($type != 2 && $type != 3) {
  665.                 return PEAR::raiseError('Unexpected HTTP code: ' .
  666.                                         $info['http_code']);
  667.             }
  668.         }
  669.  
  670.         return $ret;
  671.     }
  672.     // }}}
  673.  
  674.     // {{{ setOption($option, $value)
  675.     /**
  676.      * Sets an option for your cURL session. Please note that the cURL handler
  677.      * is NOT created before execute(). This is for error checking purposes.
  678.      * You should use setOption() in the following manner:
  679.      *
  680.      * <code>
  681.      * <?php
  682.      *
  683.      * require_once 'Net/Curl.php';
  684.      * $curl = new Net_Curl('http://www.example.com');
  685.      * $check = $curl->create();
  686.      * if (!PEAR::isError($check)) {
  687.      *     $curl->setOption(CURLOPT_FOO, 'bar');
  688.      *     $result = $curl->execute();
  689.      *     if (!PEAR::isError($result)) {
  690.      *         echo $result;
  691.      *     }
  692.      * }
  693.      *
  694.      * ?>
  695.      * </code>
  696.      *
  697.      * @param int   $option cURL constant (ie. CURLOPT_URL)
  698.      * @param mixed $value  The option's value
  699.      * 
  700.      * @author Joe Stump <joe@joestump.net>
  701.      * @access public
  702.      * @return boolean
  703.      */
  704.     function setOption($option, $value)
  705.     {
  706.         if (is_resource($this->_ch)) {
  707.             return curl_setopt($this->_ch, $option, $value);
  708.         }
  709.  
  710.         return false;
  711.     }
  712.     // }}}
  713.  
  714.     // {{{ getInfo()
  715.     /**
  716.      * Returns the info from the cURL session. PEAR_Error if you try and run
  717.      * this before you execute the session.
  718.      *
  719.      * @author Joe Stump <joe@joestump.net>
  720.      * @access public
  721.      * @return mixed PEAR_Error if there is no resource, info on success
  722.      */
  723.     function getInfo()
  724.     {
  725.         if (is_resource($this->_ch)) {
  726.             return curl_getinfo($this->_ch);
  727.         }
  728.  
  729.         return PEAR::isError('cURL handler does not exist!');
  730.     }
  731.     // }}}
  732.  
  733.     // {{{ create()
  734.     /**
  735.      * Creates a cURL resource. If curl_init() doesn't exist or we could not
  736.      * create a resource it will error out.
  737.      *
  738.      * @author Joe Stump <joe@joestump.net>
  739.      * @return boolean TRUE on success, PEAR_Error on failure
  740.      */
  741.     function create()
  742.     {
  743.         if (!PEAR::loadExtension('curl')) {
  744.             return PEAR::raiseError('CURL extension is not available');
  745.         }
  746.         if (!function_exists('curl_init')) {
  747.             return PEAR::raiseError('Function curl_init() not found');
  748.         }
  749.  
  750.         $this->_ch = curl_init();
  751.         if (!is_resource($this->_ch)) {
  752.             return PEAR::raiseError('Could not initialize cURL handler');
  753.         }
  754.  
  755.         return true;
  756.     }
  757.     // }}}
  758.  
  759.     // {{{ verboseAll()
  760.     /**
  761.      * Sets verbose output
  762.      *
  763.      * Turns on super debugging mode by not suppressing errors, turning on
  764.      * verbose mode, showing headers and displaying progress.
  765.      *
  766.      * @access public
  767.      * @author David Costa <gurugeek@php.net>
  768.      * @return void
  769.      */
  770.     function verboseAll()
  771.     {
  772.         $this->verbose  = true;
  773.         $this->mute     = false;
  774.         $this->header   = true;
  775.         $this->progress = true;
  776.     }
  777.     // }}}
  778.  
  779.     // {{{ verbose_all()
  780.     /**
  781.      * Sets verbose output
  782.      *
  783.      * @access public
  784.      * @author David Costa <gurugeek@php.net>
  785.      * @return void
  786.      * @deprecated
  787.      */
  788.     function verbose_all()
  789.     {
  790.         $this->verboseAll();
  791.         PEAR::raiseError('Net_Curl::verbose_all() is deprecated! Please use Net_Curl::verboseAll()'." <br />\n", null, PEAR_ERROR_PRINT);
  792.     }
  793.     // }}}
  794.  
  795.     // {{{ close()
  796.     /**
  797.      * Closes the curl transfer and finishes the object (kinda ;)
  798.      *
  799.      * @access public
  800.      * @author Sterling Hughes <sterling@php.net>
  801.      * @return void
  802.      * @since  PHP 4.0.5
  803.      */
  804.     function close()
  805.     {
  806.         if (is_resource($this->_ch)) {
  807.             curl_close($this->_ch);
  808.         }
  809.     }
  810.     // }}}
  811.  
  812.     // {{{ _mapDeprecatedVariables()
  813.     /**
  814.      * Maps deprecated variables into the appropriate places. It also throws
  815.      * the necessary notices.
  816.      *
  817.      * @author Joe Stump <joe@joestump.net>
  818.      * @access private
  819.      * @return void
  820.      */
  821.     function _mapDeprecatedVariables() 
  822.     {
  823.         $bad = array();
  824.         if ($this->follow_location !== false) {
  825.             if ($this->follow_location > 0) {
  826.                 $this->followLocation = true;
  827.             } else {
  828.                 $this->followLocation = false;
  829.             }
  830.  
  831.             $bad[] = array('follow_location', 'followLocation');
  832.         }
  833.  
  834.         if ($this->return_transfer !== false) {
  835.             if ($this->return_transfer > 0) {
  836.                 $this->returnTransfer = true;
  837.             } else {
  838.                 $this->returnTransfer = false;
  839.             }
  840.  
  841.             $bad[] = array('return_transfer', 'returnTransfer');
  842.         }
  843.  
  844.         if ($this->file_size !== false) {
  845.             $this->fileSize = $this->file_size;
  846.             $bad[]          = array('file_size', 'fileSize');
  847.         }
  848.  
  849.         if ($this->http_headers !== false) {
  850.             $this->httpHeaders = $this->http_headers;
  851.             $bad[]             = array('http_headers', 'httpHeaders');
  852.         }
  853.  
  854.         foreach ($bad as $map) {
  855.             PEAR::raiseError('Net_Curl::$'. $map[0]. ' is deprecated! Please use Net_Curl::$'.$map[1]." instead! <br />\n", null, PEAR_ERROR_PRINT);
  856.         }
  857.     }
  858.     // }}}
  859.  
  860.     // {{{ __destruct()
  861.     /**
  862.      * PHP 5.x destructor.
  863.      *
  864.      * Runs Net_Curl::close() to make sure we close our cURL connection.
  865.      *
  866.      * @author Joe Stump <joe@joestump.net>
  867.      * @see Net_Curl::close()
  868.      */
  869.     function __destruct()
  870.     {
  871.         $this->close();
  872.     }
  873.     // }}}
  874. }
  875.  
  876. ?>
  877.