developer.jelix.org is not used any more and exists only for history. Post new tickets on the Github account.
developer.jelix.org n'est plus utilisée, et existe uniquement pour son historique. Postez les nouveaux tickets sur le compte github.

Ticket #714: #714-trunk-netHttp-Basic.patch

File #714-trunk-netHttp-Basic.patch, 15.2 KB (added by bibo, 13 years ago)

Basic Authentication made good

  • lib/clearbricks/net.http/class.net.http.php

     
    88# it under the terms of the GNU General Public License as published by
    99# the Free Software Foundation; either version 2 of the License, or
    1010# (at your option) any later version.
    11 # 
     11#
    1212# Clearbricks is distributed in the hope that it will be useful,
    1313# but WITHOUT ANY WARRANTY; without even the implied warranty of
    1414# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    1515# GNU General Public License for more details.
    16 # 
     16#
    1717# You should have received a copy of the GNU General Public License
    1818# along with Clearbricks; if not, write to the Free Software
    1919# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
     
    7676        protected $handle_redirects = true;     ///<    <b>boolean</b>          Follow redirects
    7777        protected $max_redirects = 5;                   ///<    <b>integer</b>          Maximum redirects to follow
    7878        protected $headers_only = false;                ///<    <b>boolean</b>          Retrieve only headers
    79        
     79
    8080        protected $username;                            ///<    <b>string</b>           Authentication user name
    8181        protected $password;                            ///<    <b>string</b>           Authentication password
    82        
     82
    8383        protected $proxy_host;                          ///<    <b>string</b>           Proxy server host
    8484        protected $proxy_port;                          ///<    <b>integer</b>          Proxy server port
    85        
     85
    8686        # Response vars
    8787        protected $status;                                      ///<    <b>integer</b>          HTTP Status code
    8888        protected $status_string;                       ///< <b>string</b>              HTTP Status string
    8989        protected $headers = array();                   ///<    <b>array</b>            Response headers
    9090        protected $content = '';                                ///<    <b>string</b>           Response body
    91        
     91
    9292        # Tracker variables
    9393        protected $redirect_count = 0;          ///<    <b>integer</b>          Internal redirects count
    9494        protected $cookie_host = '';                    ///<    <b>string</b>           Internal cookie host
    95        
     95
    9696        # Output module (null is this->content)
    9797        protected $output = null;                       ///<    <b>string</b>           Output stream name
    9898        protected $output_h = null;                     ///<    <b>resource</b> Output resource
    99        
     99
    100100        /**
    101101        Constructor. Takes the web server host, an optional port and timeout.
    102        
     102
    103103        @param  host            <b>string</b>           Server host
    104104        @param  port            <b>integer</b>          Server port
    105105        @param  timeout <b>integer</b>          Connection timeout
     
    107107        public function __construct($host,$port=80,$timeout=null)
    108108        {
    109109                $this->setHost($host,$port);
    110                
     110
    111111                if (defined('HTTP_PROXY_HOST') && defined('HTTP_PROXY_PORT')) {
    112112                        $this->setProxy(HTTP_PROXY_HOST,HTTP_PROXY_PORT);
    113113                }
    114                
     114
    115115                if ($timeout) {
    116116                        $this->setTimeout($timeout);
    117117                }
    118118                $this->_timeout =& $this->timeout;
    119119        }
    120        
     120
    121121        /**
    122122        Executes a GET request for the specified path. If <var>$data</var> is
    123123        specified, appends it to a query string as part of the get request.
    124124        <var>$data</var> can be an array of key value pairs, in which case a
    125125        matching query string will be constructed. Returns true on success.
    126        
     126
    127127        @param  path            <b>string</b>           Request path
    128128        @param  data            <b>array</b>            Request parameters
    129129        @return <b>boolean</b>
     
    132132        {
    133133                $this->path = $path;
    134134                $this->method = 'GET';
    135                
     135
    136136                if ($data) {
    137137                        $this->path .= '?'.$this->buildQueryString($data);
    138138                }
    139                
     139
    140140                return $this->doRequest();
    141141        }
    142        
     142
    143143        /**
    144144        Executes a POST request for the specified path. If <var>$data</var> is
    145145        specified, appends it to a query string as part of the get request.
    146146        <var>$data</var> can be an array of key value pairs, in which case a
    147147        matching query string will be constructed. Returns true on success.
    148        
     148
    149149        @param  path            <b>string</b>           Request path
    150150        @param  data            <b>array</b>            Request parameters
    151151        @param  charset <b>string</b>           Request charset
     
    161161                $this->postdata = $this->buildQueryString($data);
    162162                return $this->doRequest();
    163163        }
    164        
     164
    165165        /**
    166166        Prepares Query String for HTTP request. <var>$data</var> is an associative
    167167        array of arguments.
    168        
     168
    169169        @param  data            <b>array</b>            Query data
    170170        @return <b>string</b>
    171171        */
     
    189189                } else {
    190190                        $qs = $data;
    191191                }
    192                
     192
    193193                return $qs;
    194194        }
    195        
     195
    196196        /**
    197197        Sends HTTP request and stores status, headers, content object properties.
    198        
     198
    199199        @return <b>boolean</b>
    200200        */
    201201        protected function doRequest()
     
    212212                        $this->_port = $this->port;
    213213                        $this->_transport = $this->use_ssl ? 'ssl://' : '';
    214214                }
    215                
     215
    216216                #Reset all the variables that should not persist between requests
    217217                $this->headers = array();
    218218                $in_headers = true;
    219219                $this->outputOpen();
    220                
     220
    221221                $request = $this->buildRequest();
    222222                $this->debug('Request',implode("\r",$request));
    223                
     223
    224224                $this->open();
    225225                $this->debug('Connecting to '.$this->_transport.$this->_host.':'.$this->_port);
    226226                foreach($this->write($request) as $index => $line)
     
    238238                                $this->debug($line);
    239239                                continue;
    240240                        }
    241                        
     241
    242242                        # Read headers
    243243                        if ($in_headers)
    244244                        {
     
    252252                                        }
    253253                                        continue;
    254254                                }
    255                                
     255
    256256                                if (!preg_match('/([^:]+):\\s*(.*)/', $line, $m)) {
    257257                                        # Skip to the next header
    258258                                        continue;
     
    271271                                }
    272272                                continue;
    273273                        }
    274                        
     274
    275275                        # We're not in the headers, so append the line to the contents
    276276                        $this->outputWrite($line);
    277277                }
    278278                $this->close();
    279279                $this->outputClose();
    280                
     280
    281281                # If data is compressed, uncompress it
    282282                if ($this->getHeader('content-encoding') && $this->use_gzip) {
    283283                        $this->debug('Content is gzip encoded, unzipping it');
    284284                        # See http://www.php.net/manual/en/function.gzencode.php
    285285                        $this->content = gzinflate(substr($this->content, 10));
    286286                }
    287                
     287
    288288                # If $persist_cookies, deal with any cookies
    289289                if ($this->persist_cookies && $this->getHeader('set-cookie') && $this->host == $this->cookie_host)
    290290                {
     
    292292                        if (!is_array($cookies)) {
    293293                                $cookies = array($cookies);
    294294                        }
    295                        
     295
    296296                        foreach ($cookies as $cookie)
    297297                        {
    298298                                if (preg_match('/([^=]+)=([^;]+);/', $cookie, $m)) {
    299299                                        $this->cookies[$m[1]] = $m[2];
    300300                                }
    301301                        }
    302                        
     302
    303303                        # Record domain of cookies for security reasons
    304304                        $this->cookie_host = $this->host;
    305305                }
    306                
     306
    307307                # If $persist_referers, set the referer ready for the next request
    308308                if ($this->persist_referers) {
    309309                        $this->debug('Persisting referer: '.$this->getRequestURL());
    310310                        $this->referer = $this->getRequestURL();
    311311                }
    312                
     312
    313313                # Finally, if handle_redirects and a redirect is sent, do that
    314314                if ($this->handle_redirects)
    315315                {
     
    318318                                $this->redirect_count = 0;
    319319                                throw new Exception('Number of redirects exceeded maximum ('.$this->max_redirects.')');
    320320                        }
    321                        
     321
    322322                        $location = isset($this->headers['location']) ? $this->headers['location'] : '';
    323323                        $uri = isset($this->headers['uri']) ? $this->headers['uri'] : '';
    324324                        if ($location || $uri)
     
    340340                }
    341341                return true;
    342342        }
    343        
     343
    344344        /**
    345345        Prepares HTTP request and returns an array of HTTP headers.
    346        
     346
    347347        @return <b>array</b>
    348348        */
    349349        protected function buildRequest()
    350350        {
    351351                $headers = array();
    352                
     352
    353353                if ($this->proxy_host) {
    354354                        $path = $this->getRequestURL();
    355355                } else {
    356356                        $path = $this->path;
    357357                }
    358                
     358
    359359                # Using 1.1 leads to all manner of problems, such as "chunked" encoding
    360360                $headers[] = $this->method.' '.$path.' HTTP/1.0';
    361                
     361
    362362                $headers[] = 'Host: '.$this->host;
    363363                $headers[] = 'User-Agent: '.$this->user_agent;
    364364                $headers[] = 'Accept: '.$this->accept;
    365                
     365
    366366                if ($this->use_gzip) {
    367367                        $headers[] = 'Accept-encoding: '.$this->accept_encoding;
    368368                }
    369369                $headers[] = 'Accept-language: '.$this->accept_language;
    370                
     370
    371371                if ($this->referer) {
    372372                        $headers[] = 'Referer: '.$this->referer;
    373373                }
    374                
     374
    375375                # Cookies
    376376                if ($this->cookies) {
    377377                        $cookie = 'Cookie: ';
     
    380380                        }
    381381                        $headers[] = $cookie;
    382382                }
    383                
     383
    384384                # Basic authentication
    385385                if ($this->username && $this->password) {
    386                         $headers[] = 'Authorization: BASIC '.base64_encode($this->username.':'.$this->password);
     386                        $headers[] = 'Authorization: Basic '.base64_encode($this->username.':'.$this->password);
    387387                }
    388                
     388
    389389                # If this is a POST, set the content type and length
    390390                if ($this->postdata) {
    391391                        $content_type = 'Content-Type: application/x-www-form-urlencoded';
     
    397397                        $headers[] = '';
    398398                        $headers[] = $this->postdata;
    399399                }
    400                
     400
    401401                return $headers;
    402402        }
    403        
     403
    404404        /**
    405405        Initializes output handler if <var>$output</var> property is not null and
    406406        is a valid stream.
     
    415415                        $this->content = '';
    416416                }
    417417        }
    418        
     418
    419419        /**
    420420        Closes output module if exists.
    421421        */
     
    425425                        fclose($this->output_h);
    426426                }
    427427        }
    428        
     428
    429429        /**
    430430        Writes data to output module.
    431431        */
     
    437437                        $this->content .= $c;
    438438                }
    439439        }
    440        
     440
    441441        /**
    442442        Returns the status code of the response - 200 means OK, 404 means file not
    443443        found, etc.
    444        
     444
    445445        @return <b>string</b>
    446446        */
    447447        public function getStatus()
    448448        {
    449449                return $this->status;
    450450        }
    451        
     451
    452452        /**
    453453        Returns the content of the HTTP response. This is usually an HTML document.
    454        
     454
    455455        @return <b>string</b>
    456456        */
    457457        public function getContent()
    458458        {
    459459                return $this->content;
    460460        }
    461        
     461
    462462        /**
    463463        Returns the HTTP headers returned by the server as an associative array.
    464        
     464
    465465        @return <b>array</b>
    466466        */
    467467        public function getHeaders()
    468468        {
    469469                return $this->headers;
    470470        }
    471        
     471
    472472        /**
    473473        Returns the specified response header, or false if it does not exist.
    474        
     474
    475475        @param  header  <b>string</b>           Header name
    476476        @return <b>string</b>
    477477        */
     
    484484                        return false;
    485485                }
    486486        }
    487        
     487
    488488        /**
    489489        Returns an array of cookies set by the server.
    490        
     490
    491491        @return <b>array</b>
    492492        */
    493493        public function getCookies()
    494494        {
    495495                return $this->cookies;
    496496        }
    497        
     497
    498498        /**
    499499        Returns the full URL that has been requested.
    500        
     500
    501501        @return <b>string</b>
    502502        */
    503503        public function getRequestURL()
     
    509509                $url .= $this->path;
    510510                return $url;
    511511        }
    512        
     512
    513513        /**
    514514        Sets server host and port.
    515        
     515
    516516        @param  host            <b>string</b>           Server host
    517517        @param  port            <b>integer</b>          Server port
    518518        */
     
    521521                $this->host = $host;
    522522                $this->port = abs((integer) $port);
    523523        }
    524        
     524
    525525        /**
    526526        Sets proxy host and port.
    527        
     527
    528528        @param  host            <b>string</b>           Proxy host
    529529        @param  port            <b>integer</b>          Proxy port
    530530        */
     
    533533                $this->proxy_host = $host;
    534534                $this->proxy_port = abs((integer) $port);
    535535        }
    536        
     536
    537537        /**
    538538        Sets connection timeout.
    539        
     539
    540540        @param  t               <b>integer</b>          Connection timeout
    541541        */
    542542        public function setTimeout($t)
    543543        {
    544544                $this->timeout = abs((integer) $t);
    545545        }
    546        
     546
    547547        /**
    548548        Sets the user agent string to be used in the request. Default is
    549549        "Clearbricks HTTP Client".
    550        
     550
    551551        @param  string  <b>string</b>           User agent string
    552552        */
    553553        public function setUserAgent($string)
    554554        {
    555555                $this->user_agent = $string;
    556556        }
    557        
     557
    558558        /**
    559559        Sets the HTTP authorization username and password to be used in requests.
    560560        Don't forget to unset this in subsequent requests to different servers.
    561        
     561
    562562        @param  username        <b>string</b>           User name
    563563        @param  password        <b>integer</b>          Password
    564564        */
     
    567567                $this->username = $username;
    568568                $this->password = $password;
    569569        }
    570        
     570
    571571        /**
    572572        Sets the cookies to be sent in the request. Takes an array of name value
    573573        pairs.
    574        
     574
    575575        @param  array   <b>array</b>            Cookies array
    576576        */
    577577        public function setCookies($array)
    578578        {
    579579                $this->cookies = $array;
    580580        }
    581        
     581
    582582        /**
    583583        Sets SSL connection usage.
    584584        */
     
    593593                        $this->use_ssl = false;
    594594                }
    595595        }
    596        
     596
    597597        /**
    598598        Specify if the client should request gzip encoded content from the server
    599599        (saves bandwidth but can increase processor time). Default behaviour is
     
    603603        {
    604604                $this->use_gzip = (boolean) $boolean;
    605605        }
    606        
     606
    607607        /**
    608608        Specify if the client should persist cookies between requests. Default
    609609        behaviour is TRUE.
     
    612612        {
    613613                $this->persist_cookies = (boolean) $boolean;
    614614        }
    615        
     615
    616616        /**
    617617        Specify if the client should use the URL of the previous request as the
    618618        referral of a subsequent request. Default behaviour is TRUE.
     
    621621        {
    622622                $this->persist_referers = (boolean) $boolean;
    623623        }
    624        
     624
    625625        /**
    626626        Specify if the client should automatically follow redirected requests.
    627627        Default behaviour is TRUE.
     
    630630        {
    631631                $this->handle_redirects = (boolean) $boolean;
    632632        }
    633        
     633
    634634        /**
    635635        Set the maximum number of redirects allowed before the client quits
    636636        (mainly to prevent infinite loops) Default is 5.
     
    639639        {
    640640                $this->max_redirects = abs((integer) $num);
    641641        }
    642        
     642
    643643        /**
    644644        If TRUE, the client only retrieves the headers from a page. This could be
    645645        useful for implementing things like link checkers. Defaults to FALSE.
     
    648648        {
    649649                $this->headers_only = (boolean) $boolean;
    650650        }
    651        
     651
    652652        /**
    653653        Should the client run in debug mode? Default behaviour is FALSE.
    654654        */
     
    656656        {
    657657                $this->debug = (boolean) $boolean;
    658658        }
    659        
     659
    660660        /**
    661661        Output module init.
    662        
     662
    663663        @param  out             <b>string</b>           Output stream
    664664        */
    665665        public function setOutput($out)
    666666        {
    667667                $this->output = $out;
    668668        }
    669        
     669
    670670        /**
    671671        Static method designed for running simple GET requests. Returns content or
    672672        false on failure.
    673        
     673
    674674        @param  url             <b>string</b>           Request URL
    675675        @param  output  <b>string</b>           Optionnal output stream
    676676        @return <b>string</b>
     
    684684                $client->get($path);
    685685                return $client->getStatus() == 200 ? $client->getContent() : false;
    686686        }
    687        
     687
    688688        /**
    689689        Static method designed for running simple POST requests. Returns content or
    690690        false on failure.
    691        
     691
    692692        @param  url             <b>string</b>           Request URL
    693693        @param  data            <b>array</b>            Array of parameters
    694694        @param  output  <b>string</b>           Optionnal output stream
     
    703703                $client->post($path,$data);
    704704                return $client->getStatus() == 200 ? $client->getContent() : false;
    705705        }
    706        
     706
    707707        /**
    708708        Returns a new instance of the class. <var>$path</var> is an output variable.
    709        
     709
    710710        @param          url             <b>string</b>           Request URL
    711711        @param[out]     path            <b>string</b>           Resulting path
    712712        @return <b>netHttp</b>
     
    716716                if (!self::readUrl($url,$ssl,$host,$port,$path,$user,$pass)) {
    717717                        return false;
    718718                }
    719                
     719
    720720                $client = new self($host,$port);
    721721                $client->useSSL($ssl);
    722722                $client->setAuthorization($user,$pass);
    723                
     723
    724724                return $client;
    725725        }
    726        
     726
    727727        /**
    728728        Parses an URL and fills <var>$ssl</var>, <var>$host</var>, <var>$port</var>,
    729729        <var>$path</var>, <var>$user</var> and <var>$pass</var> variables. Returns
     
    732732        public static function readURL($url,&$ssl,&$host,&$port,&$path,&$user,&$pass)
    733733        {
    734734                $bits = parse_url($url);
    735                
     735
    736736                if (empty($bits['host'])) {
    737737                        return false;
    738738                }
    739                
     739
    740740                if (empty($bits['scheme']) || !preg_match('%^http[s]?$%',$bits['scheme'])) {
    741741                        return false;
    742742                }
    743                
     743
    744744                $scheme = isset($bits['scheme']) ? $bits['scheme'] : 'http';
    745745                $host = isset($bits['host']) ? $bits['host'] : null;
    746746                $port = isset($bits['port']) ? $bits['port'] : null;
    747747                $path = isset($bits['path']) ? $bits['path'] : '/';
    748748                $user = isset($bits['user']) ? $bits['user'] : null;
    749749                $pass = isset($bits['pass']) ? $bits['pass'] : null;
    750                
     750
    751751                $ssl = $scheme == 'https';
    752                
     752
    753753                if (!$port) {
    754754                        $port = $ssl ? 443 : 80;
    755755                }
    756                
     756
    757757                if (isset($bits['query'])) {
    758758                        $path .= '?'.$bits['query'];
    759759                }
    760                
     760
    761761                return true;
    762762        }
    763        
     763
    764764        /**
    765765        This method is the method the class calls whenever there is debugging
    766766        information available. $msg is a debugging message and $object is an
     
    769769        debugging information to be handled in a different way you can do so by
    770770        creating a new class that extends HttpClient and over-riding the debug()
    771771        method in that class.
    772        
     772
    773773        @param  msg             <b>string</b>           Debug message
    774774        @param  object  <b>mixed</b>            Variable to print_r
    775775        */