system/classes/remoterequest.php

<?php
namespace Habari;
abstract class RequestProcessor
{
  
  protected $response_body = '';
  protected $response_headers = array();
  
  protected $executed = false;
  
  protected $can_followlocation = true;
  
  abstract public function execute( $method, $url, $headers, $body, $config );

  public function get_response_body ( ) {
    
    if ( !$this->executed ) {
      throw new \Exception( _t( 'Unable to get response body. Request did not yet execute.' ) );
    }
    
    return $this->response_body;
    
  }
  public function get_response_headers ( ) {
    
    if ( !$this->executed ) {
      throw new \Exception( _t( 'Unable to get response headers. Request did not yet execute.' ) );
    }
    
    return $this->response_headers;
    
  }
}

class RemoteRequest
{
  private $method = 'GET';
  private $url;
  private $params = array();
  private $headers = array(
    'Accept' => '*/*',
  );
  private $postdata = array();
  private $files = array();
  private $body = '';
  private $processor = null;
  private $executed = false;

  private $response_body = '';
  private $response_headers = '';

  private $user_agent = 'Habari';
  
  // Array of adapter configuration options
  private $config = array(
    'connect_timeout'   => 30,
    'timeout'           => 180,
    'buffer_size'       => 16384,
    'follow_redirects'  => true,
    'max_redirects'     => 5,

    // These are configured in the main config file
    'proxy' => array(
      'server' => null,
      'port' => null,
      'username' => null,
      'password' => null,
      'auth_type' => 'basic',
      'exceptions' => array(),
      'type' => 'http',   // http is the default, 'socks' for a SOCKS5 proxy
    ),

    // TODO: These don't apply to SocketRequestProcessor yet
    'ssl' => array(
      'verify_peer' => true,
      'verify_host' => 2,   // 1 = check CN of ssl cert, 2 = check and verify @see http://php.net/curl_setopt
      'cafile' => null,
      'capath' => null,
      'local_cert' => null,
      'passphrase' => null,
      
    ),
  );

  public function __construct( $url, $method = 'GET', $timeout = 180 )
  {
    $this->method = strtoupper( $method );
    $this->url = $url;
    $this->set_timeout( $timeout );
    
    // load the proxy configuration, if it exists
    $default = new \stdClass();
    $proxy = Config::get( 'proxy', $default );
    if ( isset( $proxy->server ) ) {
      $this->set_config( array( 'proxy' => (array)$proxy ) );
    }

    // populate the default proxy exceptions list, since we can't up there
    $this->config['proxy']['exceptions'] = array_merge( $this->config['proxy']['exceptions'], array(
      'localhost',
      '127.0.0.1',
      '::1',    // ipv6 localhost
    ) );
    
    // these next two could be duplicates of 'localhost' and 127.0.0.1 / ::1 if you're on localhost - that's ok
    if ( isset( $_SERVER['SERVER_NAME'] ) ) {
      $this->config['proxy']['exceptions'][] = $_SERVER['SERVER_NAME'];
    }
    
    if ( isset( $_SERVER['SERVER_ADDR'] ) ) {
      $this->config['proxy']['exceptions'][] = $_SERVER['SERVER_ADDR'];
    }

    $this->user_agent .= '/' . Version::get_habariversion();
    $this->add_header( array( 'User-Agent' => $this->user_agent ) );

    // if they've manually specified that we should not use curl, use sockets instead
    if ( Config::get( 'remote_request_processor' ) == 'socket' ) {
      $this->processor = new SocketRequestProcessor();
    }
    else {
      // otherwise, see if we can use curl and fall back to sockets if not
      if ( function_exists( 'curl_init' )
        && ! ( ini_get( 'safe_mode' ) || ini_get( 'open_basedir' ) ) ) {
        $this->processor = new CURLRequestProcessor;
      }
      else {
        $this->processor = new SocketRequestProcessor;
      }
      
    }
  }

  public function __set_processor( $processor )
  {
    $this->processor = $processor;
  }

  public function set_config( $config, $value = null )
  {
    if ( is_array( $config ) ) {
      foreach ( $config as $name => $value ) {
        $this->set_config( $name, $value );
      }
    }
    else {
      if ( is_array( $value ) ) {
        $this->config[ $config ] = array_merge( $this->config[ $config ], $value );
      }
      else {
        $this->config[ $config ] = $value;
      }
    }
  }
  
  public function add_header( $header )
  {
    if ( is_array( $header ) ) {
      $this->headers = array_merge( $this->headers, $header );
    }
    else {
      list( $k, $v )= explode( ': ', $header );
      $this->headers[$k] = $v;
    }
  }

  public function add_headers( $headers )
  {
    foreach ( $headers as $header ) {
      $this->add_header( $header );
    }
  }

  public function set_body( $body )
  {
    if ( $this->method == 'GET' ) {
      throw new \Exception( _t( 'Trying to add a request body to a GET request.' ) );
    }

    $this->body = $body;
  }

  public function set_params( $params )
  {
    if ( ! is_array( $params ) ) {
      parse_str( $params, $params );
    }

    $this->params = $params;
  }

  public function set_timeout( $timeout )
  {
    $this->config['timeout'] = $timeout;
    return $this->config['timeout'];
  }

  public function set_postdata( $name, $value = null )
  {
    if ( is_array( $name ) ) {
      $this->postdata = array_merge( $this->postdata, $name );
    }
    else {
      $this->postdata[$name] = $value;
    }
  }

  public function set_file( $name, $filename, $content_type = null, $override_filename = null )
  {
    if ( !file_exists( $filename ) ) {
      throw new \Exception( _t( 'File %s not found.', array( $filename ) ) );
    }
    if ( empty( $content_type ) ) $content_type = 'application/octet-stream';
    $this->files[$name] = array( 'filename' => $filename, 'content_type' => $content_type, 'override_filename' => $override_filename );
    $this->headers['Content-Type'] = 'multipart/form-data';
  }

  private function prepare()
  {
    // remove anchors (#foo) from the URL
    $this->url = $this->strip_anchors( $this->url );
    // merge query params from the URL with params given
    $this->url = $this->merge_query_params( $this->url, $this->params );

    if ( $this->method === 'POST' ) {
      if ( !isset( $this->headers['Content-Type'] ) || ( $this->headers['Content-Type'] == 'application/x-www-form-urlencoded' ) ) {
        // TODO should raise a warning
        $this->add_header( array( 'Content-Type' => 'application/x-www-form-urlencoded' ) );

        if ( $this->body != '' && count( $this->postdata ) > 0 ) {
          $this->body .= '&';
        }
        $this->body .= http_build_query( $this->postdata, '', '&' );
      }
      elseif ( $this->headers['Content-Type'] == 'multipart/form-data' ) {
        $boundary = md5( Utils::nonce() );
        $this->headers['Content-Type'] .= '; boundary=' . $boundary;

        $parts = array();
        if ( $this->postdata && is_array( $this->postdata ) ) {
          reset( $this->postdata );
          while ( list( $name, $value ) = each( $this->postdata ) ) {
            $parts[] = "Content-Disposition: form-data; name=\"{$name}\"\r\n\r\n{$value}\r\n";
          }
        }

        if ( $this->files && is_array( $this->files ) ) {
          reset( $this->files );
          while ( list( $name, $fileinfo ) = each( $this->files ) ) {
            $filename = basename( $fileinfo['filename'] );
            if ( !empty( $fileinfo['override_filename'] ) ) {
              $filename = $fileinfo['override_filename'];
            }
            $part = "Content-Disposition: form-data; name=\"{$name}\"; filename=\"{$filename}\"\r\n";
            $part .= "Content-Type: {$fileinfo['content_type']}\r\n\r\n";
            $part .= file_get_contents( $fileinfo['filename'] ) . "\r\n";
            $parts[] = $part;
          }
        }

        if ( !empty( $parts ) ) {
          $this->body = "--{$boundary}\r\n" . join( "--{$boundary}\r\n", $parts ) . "--{$boundary}--\r\n";
        }
      }
      $this->add_header( array( 'Content-Length' => strlen( $this->body ) ) );
    }
  }

  public function execute()
  {
    $this->prepare();
    $result = $this->processor->execute( $this->method, $this->url, $this->headers, $this->body, $this->config );

    if ( $result ) { // XXX exceptions?
      $this->response_headers = $this->processor->get_response_headers();
      $this->response_body = $this->processor->get_response_body();
      $this->executed = true;

      return true;
    }
    else {
      // processor->execute should throw an Exception which would bubble up
      $this->executed = false;

      return $result;
    }
  }

  public function executed()
  {
    return $this->executed;
  }

  public function get_response_headers()
  {
    if ( !$this->executed ) {
      throw new \Exception( _t( 'Unable to fetch response headers for a pending request.' ) );
    }

    return $this->response_headers;
  }

  public function get_response_body()
  {
    if ( !$this->executed ) {
      throw new \Exception( _t( 'Unable to fetch response body for a pending request.' ) );
    }

    return $this->response_body;
  }

  private function strip_anchors( $url )
  {
    return preg_replace( '/(#.*?)?$/', '', $url );
  }

  private function __filter( $data, $url )
  {
    return Plugins::filter( 'remoterequest', $data, $url );
  }

  private function merge_query_params( $url, $params )
  {
    $urlparts = InputFilter::parse_url( $url );

    if ( ! isset( $urlparts['query'] ) ) {
      $urlparts['query'] = '';
    }

    if ( ! is_array( $params ) ) {
      parse_str( $params, $params );
    }

    $urlparts['query'] = http_build_query( array_merge( Utils::get_params( $urlparts['query'] ), $params ), '', '&' );

    return InputFilter::glue_url( $urlparts );
  }

  public static function get_contents( $url, $use_include_path = false, $context = null, $offset = 0, $maxlen = -1 )
  {
    try {
      $rr = new RemoteRequest( $url );
      if ( $rr->execute() === true ) {
        return ( $maxlen != -1
          ? MultiByte::substr( $rr->get_response_body(), $offset, $maxlen )
          : MultiByte::substr( $rr->get_response_body(), $offset ) );
      }
      else {
        return false;
      }
    }
    catch ( \Exception $e ) {
      // catch any exceptions to try and emulate file_get_contents() as closely as possible.
      // if you want more control over the errors, instantiate RemoteRequest manually
      return false;
    }
  }

}

class RemoteRequest_Timeout extends \Exception { }

?>