fsockopen

Charles Torvalds (2013-04-28 17:06:21)

Rewrite/Update of king dot macro's DNS lookups function.
<?php

function gethostbyaddr_timeout( $ip, $dns, $timeout = 3 ) {
    // src: http://www.askapache.com/php/php-fsockopen-dns-udp.html
    
    // random transaction number (for routers etc to get the reply back)
    $data = rand( 10, 77 ) . "\1\0\0\1\0\0\0\0\0\0";
    
    // octals in the array, keys are strlen of bit
    $bitso = array("","\1","\2","\3" );
    foreach( array_reverse( explode( '.', $ip ) ) as $bit ) {
        $l=strlen($bit);
        $data.="{$bitso[$l]}".$bit;
    }
    
    // and the final bit of the request
    $data .= "\7in-addr\4arpa\0\0\x0C\0\1";
        
    // create UDP socket
    $errno = $errstr = 0;
    $fp = fsockopen( "udp://{$dns}", 53, $errno, $errstr, $timeout );
    if( ! $fp || ! is_resource( $fp ) )
        return $errno;

    if( function_exists( 'socket_set_timeout' ) ) {
        socket_set_timeout( $fp, $timeout );
    } elseif ( function_exists( 'stream_set_timeout' ) ) {
        stream_set_timeout( $fp, $timeout );
    }

    // send our request (and store request size so we can cheat later)
    $requestsize = fwrite( $fp, $data );
    $max_rx = $requestsize * 3;
    
    $start = time();
    $responsesize = 0;
    while ( $rxed < $max_rx && ( ( time() - $start ) < $timeout ) && ($b = fread( $fp, 1 ) ) !== false ) {
        $responsesize++;
        $response .= $b;
    }
    echo "[tx: $requestsize bytes]  [rx: {$responsesize} bytes]";

    // hope we get a reply
    if ( is_resource( $fp ) )
        fclose( $fp );

    // if empty response or bad response, return original ip
    if ( empty( $response ) || bin2hex( substr( $response, $requestsize + 2, 2 ) ) != '000c' )
        return $ip;
        
    // set up our variables
    $host = '';
    $len = $loops = 0;
    
    // set our pointer at the beginning of the hostname uses the request size from earlier rather than work it out
    $pos = $requestsize + 12;
    do {
        // get segment size
        $len = unpack( 'c', substr( $response, $pos, 1 ) );
        
        // null terminated string, so length 0 = finished - return the hostname, without the trailing .
        if ( $len[1] == 0 )
            return substr( $host, 0, -1 );
            
        // add segment to our host
        $host .= substr( $response, $pos + 1, $len[1] ) . '.';
        
        // move pointer on to the next segment
        $pos += $len[1] + 1;
        
        // recursion protection
        $loops++;
    }
    while ( $len[1] != 0 && $loops < 20 );
    
    // return the ip in case 
    return $ip;
}

?>

kexianbin at diyism dot com (2011-12-28 20:15:39)

My recursive unchunk function:

<?php
function unchunk($result)
         {return preg_replace('/([0-9A-F]+)\r\n(.*)/sie',
                              '($cnt=@base_convert("\1", 16, 10))
                               ?substr(($str=@strtr(\'\2\', array(\'\"\'=>\'"\', \'\\\\0\'=>"\x00"))), 0, $cnt).unchunk(substr($str, $cnt+2))
                               :""
                              ',
                              $result
                             );
         }
?>

Jeremy Saintot (2011-01-14 16:24:40)

Here is my fsockopen-based HTTP request fonction (GET and POST) :

<?php
function http_request(
    $verb = 'GET',             /* HTTP Request Method (GET and POST supported) */
    $ip,                       /* Target IP/Hostname */
    $port = 80,                /* Target TCP port */
    $uri = '/',                /* Target URI */
    $getdata = array(),        /* HTTP GET Data ie. array('var1' => 'val1', 'var2' => 'val2') */
    $postdata = array(),       /* HTTP POST Data ie. array('var1' => 'val1', 'var2' => 'val2') */
    $cookie = array(),         /* HTTP Cookie Data ie. array('var1' => 'val1', 'var2' => 'val2') */
    $custom_headers = array(), /* Custom HTTP headers ie. array('Referer: http://localhost/ */
    $timeout = 1,           /* Socket timeout in seconds */
    $req_hdr = false,          /* Include HTTP request headers */
    $res_hdr = false           /* Include HTTP response headers */
    )
{
    $ret = '';
    $verb = strtoupper($verb);
    $cookie_str = '';
    $getdata_str = count($getdata) ? '?' : '';
    $postdata_str = '';

    foreach ($getdata as $k => $v)
                $getdata_str .= urlencode($k) .'='. urlencode($v) . '&';

    foreach ($postdata as $k => $v)
        $postdata_str .= urlencode($k) .'='. urlencode($v) .'&';

    foreach ($cookie as $k => $v)
        $cookie_str .= urlencode($k) .'='. urlencode($v) .'; ';

    $crlf = "\r\n";
    $req = $verb .' '. $uri . $getdata_str .' HTTP/1.1' . $crlf;
    $req .= 'Host: '. $ip . $crlf;
    $req .= 'User-Agent: Mozilla/5.0 Firefox/3.6.12' . $crlf;
    $req .= 'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8' . $crlf;
    $req .= 'Accept-Language: en-us,en;q=0.5' . $crlf;
    $req .= 'Accept-Encoding: deflate' . $crlf;
    $req .= 'Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7' . $crlf;
    
    foreach ($custom_headers as $k => $v)
        $req .= $k .': '. $v . $crlf;
        
    if (!empty($cookie_str))
        $req .= 'Cookie: '. substr($cookie_str, 0, -2) . $crlf;
        
    if ($verb == 'POST' && !empty($postdata_str))
    {
        $postdata_str = substr($postdata_str, 0, -1);
        $req .= 'Content-Type: application/x-www-form-urlencoded' . $crlf;
        $req .= 'Content-Length: '. strlen($postdata_str) . $crlf . $crlf;
        $req .= $postdata_str;
    }
    else $req .= $crlf;
    
    if ($req_hdr)
        $ret .= $req;
    
    if (($fp = @fsockopen($ip, $port, $errno, $errstr)) == false)
        return "Error $errno: $errstr\n";
    
    stream_set_timeout($fp, 0, $timeout * 1000);
    
    fputs($fp, $req);
    while ($line = fgets($fp)) $ret .= $line;
    fclose($fp);
    
    if (!$res_hdr)
        $ret = substr($ret, strpos($ret, "\r\n\r\n") + 4);
    
    return $ret;
}
?>

Example usages :

<?php
echo http_request('GET', 'www.php.net');
echo http_request('GET', 'www.php.net', 80, '/manual/en/function.phpinfo.php');
echo http_request('GET', 'www.php.net', 80, '/manual/en/function.phpinfo.php', array('get1' => 'v_get1'), array(), array('cookie1' => 'v_cookie1'), array('X-My-Header' => 'My Value'));
?>

[EDIT BY danbrown AT php DOT net: Contains a bugfix provided by "Wrinkled Cheese" on 24-JUN-2011 to fix the $getdata foreach() loop; another bugfix provided by Suat Secmen on 12-JAN-2012 to fix a $timeout = 1000, then stream_set_timeout($fp, 0, $timeout * 1000), equaling 1,000 seconds.]

gratcypalma at gmail dot com (2010-08-30 20:56:39)

<?php
/*
this script i used for remote my PvPGN Server, to check email user.
not good, but it work.
*/

set_time_limit(0); 
$host   = 'host';
$port   = 'port';
$user   = 'user';
$pass   = 'pass';
$socket = fsockopen($host, $port) or die('Could not connect to: '.$host);
$userdota = "palma";
if($socket) 
{ 
    sendcmd("\r",$socket);
    $status = "open"; // set status open
        
    while($status=="open") //while we are connected to the server 
      {     
             $line = @fgets($socket, 1024) ;
              /////////////login////////////////    
            if (strstr($line, "there is no guest account"))
              {
                 sendcmd($user."\r\n",$socket);
                 sendcmd($pass."\r\n",$socket);
              }    
            //////////////send command ////////////////////
            if (strstr($line,"Your unique name: ".$user))
              {  sendcmd("/finger ".$userdota."\r\n",$socket);
              }
            
            //////////////get email////////////////////
            if (strstr($line,"email:")) // if respone server write "email:"
              {  
                 $pattern = '/email:(.*) ,/';
                 preg_match($pattern, $line, $matches);
                 fclose($socket); 
                 $status="close"; // status close
                 $matches=str_replace(" ","", $matches);
                 $matches=str_replace(",is_operator:0,is_admin:0,","", $matches);
                 $matches=str_replace("email:","", $matches);
                 print $matches[0];                 
                 $email=$matches[0];
              }
            if (strstr($line,"ERROR: Invalid user.")) // if respone server write "ERROR: Invalid user."
              {  
                 
                 fclose($socket); 
                 $status="close";
                 $error ="Invalid User";    // error message
              }
            
            ////////////login failed //////////////////////////             
            if (strstr($line, "Login failed")) // if respone server write "Login failed"
              {
                 $error = "Login Failed";    // error message
                 fclose($socket); 
                 $status="close";
              }
            
            flush(); // close
      
      }
          
}
function sendcmd($cmd,$socket) // send command function
{
  fputs($socket, $cmd, strlen($cmd)); 
}
?>

ken at kenmclean dot com dot au (2010-07-15 05:33:05)

Make sure you don't use a double line break ("\r\n\r\n") during the middle of your header, as it appears to end the header. 

This means a \r\n\r\n before "Connection: close\r\n\r\n" will not correctly tell fsockopen to close the request, leading to a max timeout error.

Some of the code on this page does this. It took me days to figure out. Example:

<?php
    // Wrong:
    fwrite($fp, "GET / HTTP/1.1\r\n");
    fwrite($fp, "Host: php.net\r\n");
    fwrite($fp, "User-Agent: example\r\n\r\n");
    fwrite($fp, "Connection: Close\r\n\r\n");

    // Right:
    fwrite($fp, "GET / HTTP/1.1\r\n" );
    fwrite($fp, "Host: php.net\r\n");
    fwrite($fp, "User-Agent: example\r\n");
    fwrite($fp, "Connection: Close\r\n\r\n");
?>

SoupNazi (2010-05-18 11:58:28)

I would like to save people some time.  I spent a couple hours trying to de-hunkify the response from apache2.  I found out that if you simply make a 1.0 request vs. a 1.1 request you will get no hunks and so this simple script below will get the page you want in plain text, no hunks:

<?php
$data=false;
$url='www.example.com';

$fp = @fsockopen($url, 80, $errno, $errstr, 1);
if ($fp) {
    stream_set_timeout($fp,1);          
    $out = "GET / HTTP/1.0\r\n";
    $out .= "Host: www.example.com\r\n";
    $out .= "Connection: Close\r\n\r\n";
    if (fwrite($fp, $out)) {
        $content='';
        $header = "not yet";
        while (!feof($fp)) {
            $data=true;
            $line=fgets($fp,128);
            if ($line=="\r\n" && $header=="not yet") {
                $header = "passed";
            }
            if ($header=="passed") {
                $content.=$line;
            }
        }
        fclose ($fp);
    }
}
if (!$data) {
    print "Unable to retrieve all or part of $url";
} else {
    print "$content";
}

?>

I borrowed some of the script from another poster here - the portion removing the returned header.

steve at visual77 dot com (2010-02-12 10:23:51)

A short, quick unchunk function that makes use of regular expressions:

<?php

function unchunk($result) {
    return preg_replace_callback(
        '/(?:(?:\r\n|\n)|^)([0-9A-F]+)(?:\r\n|\n){1,2}(.*?)'.
        '((?:\r\n|\n)(?:[0-9A-F]+(?:\r\n|\n))|$)/si',
        create_function(
            '$matches', 
            'return hexdec($matches[1]) == strlen($matches[2]) ? $matches[2] : $matches[0];'
        ), 
        $result
    );
}

?>

Buoysel (2010-02-10 17:50:57)

I wasn’t too happy with all the code snippets I found for unchunking chunked HTTP 1.1 replies, as most of them were either bloated with stuff I don’t need or calling several other functions and thus tricky to implement. And some didn’t even work at all for me...

I just thought I could try implementing my own function and here it is. I haven't had any problems with it, so I hope someone finds this useful.

<?php
function unchunkHttp11($data) {
    $fp = 0;
    $outData = "";
    while ($fp < strlen($data)) {
        $rawnum = substr($data, $fp, strpos(substr($data, $fp), "\r\n") + 2);
        $num = hexdec(trim($rawnum));
        $fp += strlen($rawnum);
        $chunk = substr($data, $fp, $num);
        $outData .= $chunk;
        $fp += strlen($chunk);
    }
    return $outData;
}
?>

Before calling this function you may want to check if the content is really chunked using a code snipped like this:

<?php
while (!feof($fp)) {
    $reply .= fgets($fp, 1024);
}
$data = substr($reply, (strpos($reply, "\r\n\r\n")+4));
if (strpos(strtolower($reply), "transfer-encoding: chunked") !== FALSE) {
    $data = unchunkHttp11($data);
}
?>

nytro_rst at yahoo dot com (2010-01-12 02:26:33)

A simple proxy list checker. You can check a list ip:port if that port is opened on that IP.

<?php

$fisier = file_get_contents('proxy_list.txt'); // Read the file with the proxy list
$linii = explode("\n", $fisier); // Get each proxy
$fisier = fopen("bune.txt", "a"); // Here we will write the good ones

for($i = 0; $i < count($linii) - 1; $i++) test($linii[$i]); // Test each proxy

function test($proxy)
{
  global $fisier;
  $splited = explode(':',$proxy); // Separate IP and port
  if($con = @fsockopen($splited[0], $splited[1], $eroare, $eroare_str, 3)) 
  {
    fwrite($fisier, $proxy . "\n"); // Check if we can connect to that IP and port
    print $proxy . '<br>'; // Show the proxy
    fclose($con); // Close the socket handle
  }
}

fclose($fisier); // Close the file

?>

FaTe (2009-09-13 20:02:00)

In all header aspects I can understand for 3rd party content you may not be able to apply the following but for those reading pages where content being read by fsockopen is editable then I suggest adding a simple unique tag to the beginning of any page being read such as ":THISTAG:"
Cleaning the header contents becomes simplier when you can then use a method like split to grab your data like:
list($header,$data) = explode(":THISTAG:",$data);

walter (2009-07-30 08:05:24)

For some reason the default FreeBSD 7.0 port (jailed environment) breaks fsockopen() on SSL URLs, returning a constant stream of nothing! In my case this resulted in php-cgi bringing down lighttpd completely, in rapid time! Avoid FreeBSD/jails/fsockopen + SSL. Use curl_init() instead.

webmaster at setcronjob dot com (2009-07-21 06:24:40)

Just wanna add a small note:
If your URL scheme is https, remember to change port into 443.
<?php
$fp = fsockopen("ssl://www.example.com", 443, $errno, $errstr, 30);
if (!$fp) {
    echo "$errstr ($errno)<br />\n";
} else {
    $out = "GET / HTTP/1.1\r\n";
    $out .= "Host: www.example.com\r\n";
    $out .= "Connection: Close\r\n\r\n";
    fwrite($fp, $out);
    while (!feof($fp)) {
        echo fgets($fp, 128);
    }
    fclose($fp);
}
?>
This makes me stuck for a while :(

ghzero at ghzero dot de (2009-06-22 05:20:59)

note:
the default protocol - if not given - seems to be tcp://

oliver dot christen at camptocamp dot com (2009-06-21 03:17:02)

When downloading large files, it is not really efficient to put the whole server answer in memory before parsing the data to remove the header parts. Here is a simple way to do it while writing the data as it arrive:

<?php

// $socket is a valid fsockopen handle

$out = '';
$headerendfound = false;
$fp = fopen($fileTarget, 'w');
$buffer = '';
while (!feof($socket)) {
    $out = fgets ($socket,16384);
    if ($headerendfound) {
        fwrite($fp, $out);
        print '.';
    }
    if (!$headerendfound) {
        $buffer .= $out;
        print "searching for header\n";
        $headerend = strpos($buffer, "\r\n\r\n");
        if ($headerend !== false) {
            $headerendfound = true;
            fwrite($fp, substr($buffer, $headerend+4));
            $buffer = '';
        }
    }
} 
fclose($fp);
fclose($socket);

?>

andypsv at rcdrugs dot com (2009-06-16 13:15:42)

look at this smart ssl/http fsockopen function as a good solution for dealing with things

<?php
function _get($type,$host,$port='80',$path='/',$data='') {
    $_err = 'lib sockets::'.__FUNCTION__.'(): ';
    switch($type) { case 'http': $type = ''; case 'ssl': continue; default: die($_err.'bad $type'); } if(!ctype_digit($port)) die($_err.'bad port');
    if(!empty($data)) foreach($data AS $k => $v) $str .= urlencode($k).'='.urlencode($v).'&'; $str = substr($str,0,-1);
    
    $fp = fsockopen($host,$port,$errno,$errstr,$timeout=30);
    if(!$fp) die($_err.$errstr.$errno); else {
        fputs($fp, "POST $path HTTP/1.1\r\n");
        fputs($fp, "Host: $host\r\n");
        fputs($fp, "Content-type: application/x-www-form-urlencoded\r\n");
        fputs($fp, "Content-length: ".strlen($str)."\r\n");
        fputs($fp, "Connection: close\r\n\r\n");
        fputs($fp, $str."\r\n\r\n");
        
        while(!feof($fp)) $d .= fgets($fp,4096);
        fclose($fp);
    } return $d;
}
?>

givrix at free dot fr (2009-04-29 06:45:58)

I've been searching a big while before considering that it was impossible to use context with fsockopen, as it was in PHP4.
If you want to use sockets with tls or ssl encryption and certificates and so on, you'd better have a look to stream_socket_client.

Hyan Christian (2008-11-20 22:42:02)

To just take the HTTP content from fsockopen, better wait until feof finish to read the \r\n separator

<?php
//fsockopen, fputs..

$content = "";
$header = "not yet";

while( !feof( $pointer ) ) {
    $line = fgets( $pointer, 128 );
    if( $line == "\r\n" && $header == "not yet" ) {
        $header = "passed";
    }
    if( $header == "passed" ) {
        $content .= $line;
    }
}

//fclose..

echo( substr( $content, 2 ) );
?>

Doug (2008-11-06 15:17:06)

[NOTE BY danbrown AT php DOT net: Updated version.  Contains author-submitted bug fixes.]

Here is a way to get an array of cities / states for any zip code anywhere in the US.  This example uses a $_GET variable to specify which zip code, but you can get it from any source you wish.  This will return actual and acceptable zip code cities (according to USPS), but can be easily modified to include just the actual city.

<?php

if($_GET['zip'])
{
    if(!($fp = fsockopen('zip4.usps.com', 80, $errno, $errstr)))
        echo 'Could not connect to USPS! Error number: ' . $errno . '(' . $errstr . ')';

    else
    {
        $poststring =

            "GET /zip4/zcl_3_results.jsp?zip5=" . $_GET['zip'] . " HTTP/1.0\r\n" .
            "Connection: close\r\n\r\n";

        fputs($fp, $poststring);

        $buffer = '';

        while(!feof($fp))
            $buffer .= fgets($fp, 128);

        fclose($fp);

        preg_match('/Actual City name(.*)/s', $buffer, $match);

        $temp = explode('Not Acceptable', $match[1]);

        // Capture city/state combination for all valid cities

        preg_match_all('/headers="pre">(?:<b>)?([\w|\s]+), (\w+)/', $temp[0], $acceptable, PREG_SET_ORDER);

        $values = array();

        foreach($acceptable as $value)

            $values[] =

                array
                (
                    'city' => $value[1],
                    'state' => $value[2]
                );

        if(count($values) == 0)
            echo 'Zip could not be found in the database!';
    }
}
else
    echo 'Please specify a zip!';

?>

nicholas at nicholaswilliams dot net (2008-10-28 17:04:50)

For those wanting to use fsockopen() to connect to a local UNIX socket who can't find documentation on how to do it, here's a (rough) example:

<?php

$sock = fsockopen('unix:///full/path/to/my/socket.sock', NULL, $errno, $errstr);

fwrite($sock, 'SOME COMMAND'."\r\n");

echo fread($sock, 4096)."\n";

fclose($sock);

?>

laisebrown at gmail dot com (2008-10-26 15:30:28)

When you're connecting through a proxy server you can't rely on fsockopen returning false to indicate that the connection has failed. (This also applies to fgets and fwrite.)
To check whether the proxy succeeded in contacting the real target host, you need to look for the http response code in the headers that get returned. Typically, if the proxy was unable to reach the host, you'll find a line containing something like:
HTTP/1.0 503 Service Unavailable

Anonymous (2008-10-12 05:26:46)

"system level connect()" is not further documented inside the php documentation so it is hard to find out more about error numbers.
someone suggest a more system-close way to find out more about error numbers here: http://www.askapache.com/php/fsockopen-socket.html (an interesting read about fsockopen anyway).
in my case i could debug to the fact that fsocketopen error number 16 was resulted in the inpossibility to resolve a hostname.

andrew at enigma-pro dot com (2008-09-09 08:28:49)

Notice using "tcp" insted of "http"
<?php
fsockopen("tcp://example.net",80 , $errno, $errstr, 30);
?>

mikey at badpenguins dot com (2008-09-06 09:00:09)

My $0.02 on handling chunked transfer encoded output...  Has rudimentary error handling.

<?php
//
// Example usage...
//
$server  = '127.0.0.1';
$port    = '80';
$uri     = '/cgi-bin/random-cgi';
$content = 'Your post content...';

$post_results = httpPost($server,$port,$uri,$content);
if (!is_string($post_results)) {
    die('uh oh, something went wrong');
    } else {
    die('Here are your results: ' . $post_results);
    }

//
// Post provided content to an http server and optionally
// convert chunk encoded results.  Returns false on errors,
// result of post on success.  This example only handles http,
// not https.
//
function httpPost($ip=null,$port=80,$uri=null,$content=null) {
    if (empty($ip))         { return false; }
    if (!is_numeric($port)) { return false; }
    if (empty($uri))        { return false; }
    if (empty($content))    { return false; }
    // generate headers in array.
    $t   = array();
    $t[] = 'POST ' . $uri . ' HTTP/1.1';
    $t[] = 'Content-Type: text/html';
    $t[] = 'Host: ' . $ip . ':' . $port;
    $t[] = 'Content-Length: ' . strlen($content);
    $t[] = 'Connection: close';
    $t   = implode("\r\n",$t) . "\r\n\r\n" . $content;
    //
    // Open socket, provide error report vars and timeout of 10
    // seconds.
    //
    $fp  = @fsockopen($ip,$port,$errno,$errstr,10);
    // If we don't have a stream resource, abort.
    if (!(get_resource_type($fp) == 'stream')) { return false; }
    //
    // Send headers and content.
    //
    if (!fwrite($fp,$t)) {
        fclose($fp);
        return false;
        }
    //
    // Read all of response into $rsp and close the socket.
    //
    $rsp = '';
    while(!feof($fp)) { $rsp .= fgets($fp,8192); }
    fclose($fp);
    //
    // Call parseHttpResponse() to return the results.
    //
    return parseHttpResponse($rsp);
    }

//
// Accepts provided http content, checks for a valid http response,
// unchunks if needed, returns http content without headers on
// success, false on any errors.
//
function parseHttpResponse($content=null) {
    if (empty($content)) { return false; }
    // split into array, headers and content.
    $hunks = explode("\r\n\r\n",trim($content));
    if (!is_array($hunks) or count($hunks) < 2) {
        return false;
        }
    $header  = $hunks[count($hunks) - 2];
    $body    = $hunks[count($hunks) - 1];
    $headers = explode("\n",$header);
    unset($hunks);
    unset($header);
    if (!verifyHttpResponse($headers)) { return false; }
    if (in_array('Transfer-Encoding: chunked',$headers)) {
        return trim(unchunkHttpResponse($body));
        } else {
        return trim($body);
        }
    }

//
// Validate http responses by checking header.  Expects array of
// headers as argument.  Returns boolean.
//
function validateHttpResponse($headers=null) {
    if (!is_array($headers) or count($headers) < 1) { return false; }
    switch(trim(strtolower($headers[0]))) {
        case 'http/1.0 100 ok':
        case 'http/1.0 200 ok':
        case 'http/1.1 100 ok':
        case 'http/1.1 200 ok':
            return true;
        break;
        }
    return false;
    }

//
// Unchunk http content.  Returns unchunked content on success,
// false on any errors...  Borrows from code posted above by
// jbr at ya-right dot com.
//
function unchunkHttpResponse($str=null) {
    if (!is_string($str) or strlen($str) < 1) { return false; }
    $eol = "\r\n";
    $add = strlen($eol);
    $tmp = $str;
    $str = '';
    do {
        $tmp = ltrim($tmp);
        $pos = strpos($tmp, $eol);
        if ($pos === false) { return false; }
        $len = hexdec(substr($tmp,0,$pos));
        if (!is_numeric($len) or $len < 0) { return false; }
        $str .= substr($tmp, ($pos + $add), $len);
        $tmp  = substr($tmp, ($len + $pos + $add));
        $check = trim($tmp);
        } while(!empty($check));
    unset($tmp);
    return $str;
    }

?>

admin at lab-9 dot com (2008-07-21 05:32:01)

When you try to POST/GET requests via HTTPS over SSL/TLS you should notice this:

<?php
// preconditions
$port = 80 | 443
$host = "www.example.com";
$method = "POST" | "GET";
$contenttype = "text/html" | "text/plain" | "text/xml" | ...;
$data = "<something>";

// script
if($port == 443)
      $sslhost = "ssl://".$host;
else
      $sslhost = $host;
$fp = fsockopen($sslhost, $port);
fputs($fp, "$method $path HTTP/1.1\r\n");
fputs($fp, "Host: $host\r\n");
fputs($fp, "Content-type: $contenttype\r\n");
fputs($fp, "Content-length: ".strlen($data)."\r\n");
fputs($fp, "Connection: close\r\n");
fputs($fp, "\r\n");
?>

The server usually does not understand the HTTP-header "Host: XXX" if you provide it with the trailing "ssl://" used by fsockopen(); If you do it anyway you probably get a HTTP 400 back as response. :-)

jabeba at web dot de (2008-04-17 06:21:39)

If you have to use a proxy to make requests outside of your local network, you may use this class:

<?php
/*
 * 
 * No Proxy Authentification Implemented; PHP 5
 * 
 */

class RemoteFopenViaProxy {

    private $result;
    private $proxy_name;
    private $proxy_port;
    private $request_url;

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

    public function set_proxy_name($n) {
        $this->proxy_name = $n;
    }

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

    public function set_proxy_port($p) {
        $this->proxy_port = $p;
    }

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

    public function set_request_url($u) {
        $this->request_url = $u;
    }

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

    public function set_result($r) {
        $this->result = $r;
    }

    private function get_url_via_proxy() {

        $proxy_fp = fsockopen($this->get_proxy_name(), $this->get_proxy_port());

        if (!$proxy_fp) {
            return false;
        }
        fputs($proxy_fp, "GET " . $this->get_request_url() . " HTTP/1.0\r\nHost: " . $this->get_proxy_name() . "\r\n\r\n");
        while (!feof($proxy_fp)) {
            $proxy_cont .= fread($proxy_fp, 4096);
        }
        fclose($proxy_fp);
        $proxy_cont = substr($proxy_cont, strpos($proxy_cont, "\r\n\r\n") + 4);
        return $proxy_cont;

    }

    private function get_url($url) {
        $fd = @ file($url);
        if ($fd) {
            return $fd;
        } else {
            return false;
        }
    }

    private function logger($line, $file) {
        $fd = fopen($file . ".log", "a+");
        fwrite($fd, date("Ymd G:i:s") . " - " . $file . " - " . $line . "\n");
        fclose($fd);
    }

    function __construct($url, $proxy_name = "", $proxy_port = "") {

        $this->set_request_url($url);
        $this->set_proxy_name($proxy_name);
        $this->set_proxy_port($proxy_port);

    }

    public function request_via_proxy() {

        $this->set_result($this->get_url_via_proxy());
        if (!$this->get_result()) {
            $this->logger("FAILED: get_url_via_proxy(" . $this->get_proxy_name() . "," . $this->get_proxy_port() . "," . $this->get_request_url() . ")", "RemoteFopenViaProxyClass.log");
        }
    }

    public function request_without_proxy() {

        $this->set_result($this->get_url($this->get_request_url()));
        if (!$this->get_result()) {
            $this->logger("FAILED: get_url(" . $url . ")", "RemoteFopenViaProxyClass.log");
        }
    }
}
?>

Use it this way:

<?php
// call constructor
$obj = new RemoteFopenViaProxy($insert_request_url, $insert_proxy_name, $insert_proxy_port);
// change settings after object generation
$obj->set_proxy_name($insert_proxy_name);
$obj->set_proxy_port($insert_proxy_port);
$obj->set_request_url($insert_request_url);
$obj->request_via_proxy();
echo $obj->get_result();
?>

If there are errors during execution, the script tries to write some useful information into a log file.

dot dot dot dot dot alexander at gmail dot com (2008-03-08 07:15:37)

An edit to my below function for extra headers support and a bit of debugging
( array("key" => "value")  type)
 <?php

if(!function_exists("download")){
    function download($uri, $port = 80, $extra_headers = NULL){
if(!function_exists("stripos")){
    function stripos($str, $needle, $offset=0){
        return strpos(strtolower($str),strtolower($needle),$offset);
    }/* endfunction stripos */
}/* endfunction exists stripos*/
        if(!is_int($port))$port = 80;
        if(!is_array($extra_headers))$extra_headers = array();
        $uri = strtr( strval($uri), array("http://" => "", "https://" => "ssl://", "ssl://" => "ssl://", "\\" => "/", "//" => "/") );
        
        if(  ( $protocol = stripos($uri, "://") ) !== FALSE  ){
            if(  ( $domain_pos = stripos($uri, "/", ($protocol + 3)) ) !== FALSE  ){
                $domain = substr($uri, 0, $domain_pos);
                $file = substr($uri, $domain_pos);
            }
            else{
                $domain = $uri;
                $file = "/";
            }
        }
        else{
            if(  ( $domain_pos = stripos($uri, "/") ) !== FALSE  ){
                $domain = substr($uri, 0, $domain_pos);
                $file = substr($uri, $domain_pos);
            }
            else{
                $domain = $uri;
                $file = "/";
            }
        }
        
        $fp = fsockopen($domain, $port, $errno, $errstr, 30);
        if(!$fp){
            return FALSE;
        }
        else{
            $out = "GET " . $file . " HTTP/1.1\r\n";
            $out .= "Host: " . $domain . "\r\n";
            foreach( $extra_headers as $nm => $vl ){
    $out .= strtr( strval($nm), array( "\r" => "", "\n" => "", ": " => "", ":" => "") ) . ": " . strtr( strval($vl), array( "\r" => "", "\n" => "", ": " => "", ":" => "") ) . "\r\n";
            }
            $out .= "Connection: Close\r\n\r\n";
            
            $response = "";
            fwrite($fp, $out);
            while (!feof($fp)) {
                $response .= fgets($fp, 128);
            }
            fclose($fp);
            
            global $http_response_header;
            $http_response_header = array();
            if(  stripos($response, "\r\n\r\n") !== FALSE  ){
                $hc = explode("\r\n\r\n",  $response);
                $headers = explode("\r\n",  $hc[0]);
                
                if(!is_array($headers))$headers = array();
                foreach($headers as $key => $header){
                    $a = "";
                    $b = "";
                    if(  stripos($header, ":") !== FALSE  ){
                        list($a, $b) = explode(":", $header);
                        $http_response_header[trim($a)] = trim($b);
                    }
                }
                return end($hc);
            }
            else if(  stripos($response, "\r\n") !== FALSE  ){
                $headers = explode("\r\n",  $response);
                
                if(!is_array($headers))$headers = array();
                foreach($headers as $key => $header){
                    if(  $key < ( count($headers) - 1 )  ){
                        $a = "";
                        $b = "";
                        if(  stripos($header, ":") !== FALSE  ){
                            list($a, $b) = explode(":", $header);
                            $http_response_header[trim($a)] = trim($b);
                        }
                    }
                }
                return end($headers);
            }
            else{
                return $response;
            }
        }
    }/*endfunction download*/
}/*endif no function download*/
?>

huli0401 at gmail dot com (2007-12-27 09:12:20)

<?php
// Check for new version
    $current_version = explode('.', '1.0.00');
    $minor_revision = (int) $current_version[2];

    $errno = 0;
    $errstr = $version_info = '';

    if ($fsock = fsockopen("www.exanmple.eu", 80, $errno, $errstr, 30))
    {
        @fputs($fsock, "GET /ver.txt HTTP/1.1\r\n");
        @fputs($fsock, "HOST: www.example.eu\r\n");
        @fputs($fsock, "Connection: close\r\n\r\n");

        $get_info = false;
        while (!@feof($fsock))
        {
            if ($get_info)
            {
                $version_info .= @fread($fsock, 1024);
            }
            else
            {
                if (@fgets($fsock, 1024) == "\r\n")
                {
                    $get_info = true;
                }
            }
        }
        @fclose($fsock);

        $version_info = explode("\n", $version_info);
        $latest_head_revision = (int) $version_info[0];
        $latest_minor_revision = (int) $version_info[2];
        $latest_version = (int) $version_info[0] . '.' . (int) $version_info[1] . '.' . (int) $version_info[2];

        if ($latest_head_revision == 2 && $minor_revision == $latest_minor_revision)
        {
            $version_info = '<p style="color:green">OK</p>';
        }
        else
        {
            $version_info = '<p style="color:red">neaktualne';
            $version_info .= '<br />'Latest_version_info' . $latest_version) . ' ' . sprintf(Current_version_info'. '1.0.00') . '</p>';
        }
    }
    else
    {
        if ($errstr)
        {
            $version_info = '<p style="color:red">' . sprintf(Connect_socket_error) . '</p>';
        }
        else
        {
            $version_info = '<p>'Socket_functions_disabled'</p>';
        }
    }
    
    $version_info .= '<p>'Mailing_list_subscribe_reminder'</p>';

echo $version_info;
?>

anarchy (2007-09-04 18:34:49)

The DEFAULT stream timeout is set according to default_socket_timeout in your php.ini file. Took forever for me to dig that up....

Adlez (2007-08-04 01:32:52)

For those of you who do not have cURL, you might want to try this. 
It doesn't have all the functions that cURL has, but it has the basics. 
Please let me know of any bugs or problems.

<?php
function open_page($url,$f=1,$c=2,$r=0,$a=0,$cf=0,$pd=""){
 global $oldheader;
 $url = str_replace("http://","",$url);
 if (preg_match("#/#","$url")){
  $page = $url;
  $url = @explode("/",$url);
  $url = $url[0];
  $page = str_replace($url,"",$page);
  if (!$page || $page == ""){
   $page = "/";
  }
  $ip = gethostbyname($url);
 }else{
  $ip = gethostbyname($url);
  $page = "/";
 }
 $open = fsockopen($ip, 80, $errno, $errstr, 60);
 if ($pd){
  $send = "POST $page HTTP/1.0\r\n";
 }else{
  $send = "GET $page HTTP/1.0\r\n";
 }
 $send .= "Host: $url\r\n";
 if ($r){
  $send .= "Referer: $r\r\n";
 }else{
  if ($_SERVER['HTTP_REFERER']){
   $send .= "Referer: {$_SERVER['HTTP_REFERER']}\r\n";
  }
 }
 if ($cf){
  if (@file_exists($cf)){
   $cookie = urldecode(@file_get_contents($cf));
   if ($cookie){
    $send .= "Cookie: $cookie\r\n";
    $add = @fopen($cf,'w');
    fwrite($add,"");
    fclose($add);
   }
  }
 }
 $send .= "Accept-Language: en-us, en;q=0.50\r\n";
 if ($a){
  $send .= "User-Agent: $a\r\n";
 }else{
  $send .= "User-Agent: {$_SERVER['HTTP_USER_AGENT']}\r\n";
 }
 if ($pd){
  $send .= "Content-Type: application/x-www-form-urlencoded\r\n";  
  $send .= "Content-Length: " .strlen($pd) ."\r\n\r\n";
  $send .= $pd;
 }else{
  $send .= "Connection: Close\r\n\r\n";
 }
 fputs($open, $send);
 while (!feof($open)) {
  $return .= fgets($open, 4096);
 }
 fclose($open);
 $return = @explode("\r\n\r\n",$return,2);
 $header = $return[0];
 if ($cf){
  if (preg_match("/Set\-Cookie\: /i","$header")){
   $cookie = @explode("Set-Cookie: ",$header,2);
   $cookie = $cookie[1];
   $cookie = explode("\r",$cookie);
   $cookie = $cookie[0];
   $cookie = str_replace("path=/","",$cookie[0]);
   $add = @fopen($cf,'a');
   fwrite($add,$cookie,strlen($read));
   fclose($add);
  }
 }
 if ($oldheader){
  $header = "$oldheader<br /><br />\n$header";
 }
 $header = str_replace("\n","<br />",$header);
 if ($return[1]){
  $body = $return[1];
 }else{
  $body = "";
 }
 if ($c === 2){
  if ($body){
   $return = $body;
  }else{
   $return = $header;
  }
 }
 if ($c === 1){
  $return = $header;
 }
 if ($c === 3){
  $return = "$header$body";
 }
 if ($f){
  if (preg_match("/Location\:/","$header")){
   $url = @explode("Location: ",$header);
   $url = $url[1];
   $url = @explode("\r",$url);
   $url = $url[0];
   $oldheader = str_replace("\r\n\r\n","",$header);
   $l = "&#76&#111&#99&#97&#116&#105&#111&#110&#58";
   $oldheader = str_replace("Location:",$l,$oldheader);
   return open_page($url,$f,$c,$r,$a,$cf,$pd);
  }else{
   return $return;
  }
 }else{
  return $return;
 }
}
/////////////
////Usage////
/////////////
$url = "http://www.php.net";
$f = 1;
$c = 2;//1 for header, 2 for body, 3 for both
$r = NULL;
$a = NULL;
$cf = NULL;
$pd = NULL;
$page = open_page($url,$f,$c,$r,$a,$cf,$pd);
print $page;
?>

bradland at umich dot edu (2007-07-23 09:32:08)

I was having trouble doing an https in fopen and with fsockopen where the address had ssl://. I was getting error code 114 in the log. After much research i found that there was some ssl conflict trouble with MySQL 5.0.20-5.0.33. It had some functions that were interfering with openssl that showed up in the php install.
http://bugs.mysql.com/bug.php?id=21930
http://bugs.mysql.com/bug.php?id=19289

warezthebeef at gmail dot com (2007-07-17 04:37:59)

I ran into a problem where I needed to make an fsockopen() style connection from one specific ip address on a server with multiple ip aliases. Unfortunately fsockopen() does not allow the specification of a source address making it unsuitable. I could not find any other solutions elsewhere so here is mine for those with php 5.1.0 or greater.

<?php
// connect to the internet using the '192.168.0.100' IP
$opts = array('socket' => array('bindto' => '192.168.0.100:0'));

$context = stream_context_create($opts);

$fp = stream_socket_client("tcp://www.example.com:80", $errno, $errstr, 30, STREAM_CLIENT_CONNECT, $context);
?>

Now $fp can be used like a resource handle returned by a vanilla fsockopen() call!

aska at unit-mse dot jp (2007-07-03 06:58:58)

easy get UIDL.
A code is better than the feof.

<?php

$fp = fsockopen($host, 110, $errno, $errstr, 5);
if ($fp > 0) {
    fread($fp,1024);
    fputs($fp, "USER $user\r\n"); 
    fread($fp,1024);
    fputs($fp, "PASS $pass\r\n"); 
    fread($fp,1024);
    fputs($fp, "UIDL\r\n");
    fgets($fp,1024);
    do {
        $line = rtrim(fgets($fp, 1024));
        if ($line == '.') break;
        list(, $UIDL) = split(' ', $line, 2);
        echo $UIDL;
    } while ($line != '.');
    
    fputs($fp, "QUIT\r\n");
}
fclose($fp);

?>

Alexander Wegener (2007-05-26 07:29:17)

To check if a Url is Online (with http and https)
Using @fgets to hide Warning when using SSL
(Bug: "Warning: function.fgets SSL: fatal protocol error", http://bugs.php.net/bug.php?id=23220)

<?php

    function isOnline($url) {
        if (!$url_info = parse_url($url)) {
            return false;    
        }
        
        switch ($url_info['scheme']) {
            case 'https':
                $scheme = 'ssl://';
                $port = 443;
                break;
            case 'http':
            default:
                $scheme = '';
                $port = 80;    
        }
        
        $data = "";
        $fid = @fsockopen($scheme . $url_info['host'], $port, $errno, $errstr, 30);
        if ($fid) {
            fputs($fid, 'HEAD ' . (isset($url_info['path'])? $url_info['path']: '/') . (isset($url_info['query'])? '?' . $url_info['query']: '') . " HTTP/1.0\r\n" . 
                        "Connection: close\r\n" . 
                        'Host: ' . $url_info['host'] . "\r\n\r\n");    
            while (!feof($fid)) {
                $data .= @fgets($fid, 128);
            }
            fclose($fid);
            return !empty($data);
        } else {
            return false;
        }
    } 

?>

jbr at ya-right dot com (2007-03-01 20:17:48)

[EDIT by danbrown AT php DOT net: This note contains a big-fixed version of the user function decode_body().  Fix by (martjean77 at hot dot sapm dot mail dot com) [sic].]

Handling chunked data needs careful handling, because the data can also be compressed inside the chunked data, and chunked data can have many parts, so you need to watch for that. Here a simple example that uses one function decode_header(); to build the header into a key => value array, so it makes it easy to test for the content and transfer types inside the decode_body(); function!

<?php

function decode_header ( $str )
{
    $part = preg_split ( "/\r?\n/", $str, -1, PREG_SPLIT_NO_EMPTY );

    $out = array ();

    for ( $h = 0; $h < sizeof ( $part ); $h++ )
    {
        if ( $h != 0 )
        {
            $pos = strpos ( $part[$h], ':' );

            $k = strtolower ( str_replace ( ' ', '', substr ( $part[$h], 0, $pos ) ) );

            $v = trim ( substr ( $part[$h], ( $pos + 1 ) ) );
        }
        else
        {
            $k = 'status';

            $v = explode ( ' ', $part[$h] );

            $v = $v[1];
        }

        if ( $k == 'set-cookie' )
        {
                $out['cookies'][] = $v;
        }
        else if ( $k == 'content-type' )
        {
            if ( ( $cs = strpos ( $v, ';' ) ) !== false )
            {
                $out[$k] = substr ( $v, 0, $cs );
            }
            else
            {
                $out[$k] = $v;
            }
        }
        else
        {
            $out[$k] = $v;
        }
    }

    return $out;
}

function decode_body ( $info, $str, $eol = "\r\n" )
{
  $tmp = $str;
  $add = strlen ( $eol );
  $str = '';
  if ( isset ( $info['transfer-encoding'] ) && $info['transfer-encoding'] == 'chunked' )
  {
    do
    {
      $tmp = ltrim ( $tmp );
      $pos = strpos ( $tmp, $eol );
      $len = hexdec ( substr ( $tmp, 0, $pos ) );
      if ( isset ( $info['content-encoding'] ) )
      {
        $str .= gzinflate ( substr ( $tmp, ( $pos + $add + 10 ), $len ) );
      }
      else
      {
        $str .= substr ( $tmp, ( $pos + $add ), $len );
      }
     
      $tmp = substr ( $tmp, ( $len + $pos + $add ) );
      $check = trim ( $tmp );
    }
    while ( ! empty ( $check ) );
  }
  else if ( isset ( $info['content-encoding'] ) )
  {
    $str = gzinflate ( substr ( $tmp, 10 ) );
  }
  else {
    $str = $tmp;
  }
  return $str;
}

if ( ( $io = fsockopen( "www.yahoo.com", 80, $errno, $errstr, 5 ) ) !== false )
{
    $send  = "GET / HTTP/1.1\r\n";
    $send .= "Host: www.yahoo.com\r\n";
    $send .= "User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.2.1) Gecko/20021204\r\n";
    $send .= "Referer: http://www.yahoo.com/\r\n";
    $send .= "Accept: text/xml,application/xml,application/xhtml+xml,";
    $send .= "text/html;q=0.9,text/plain;q=0.8,video/x-mng,image/png,";
    $send .= "image/jpeg,image/gif;q=0.2,text/css,*/*;q=0.1\r\n";
    $send .= "Accept-Language: en-us, en;q=0.50\r\n";
    $send .= "Accept-Encoding: gzip, deflate, compress;q=0.9\r\n";
    $send .= "Connection: Close\r\n\r\n";

    fputs ( $io, $send );

    $send = '';

    do
    {
        $send .= fgets ( $io, 4096 );

    } while ( strpos ( $send, "\r\n\r\n" ) === false );

    $info = decode_header ( $send );

    $send = '';

    while ( ! feof ( $io ) )
    {
        $send .= fread ( $io, 8192 );
    }

    fclose ( $io );

    $send = decode_body ( $info, $send );

    echo '<h3>Header Array</h3>';
    echo '<pre>';
    print_r ( $info );
    echo '</pre>';
    echo '<h3>Document Body</h3>';
    echo $send;

}

?>

ryan1_00 at hotmail dot com (2007-01-29 07:52:10)

This script checks specific ports so you need to have the correct port open on the server for this to work.

E.g if i have a windows domain controller and it is servering LDAP then the following would be used to check it is online:
<?php
chkServer("MyDC", "389");
?>

for a webserver:
<?php
chkServer("MyWebSvr", "80");
?>

etc etc
--------------------------------------------------------

<?php
// check if a server is up by connecting to a port
function chkServer($host, $port)
{   
    $hostip = @gethostbyname($host); // resloves IP from Hostname returns hostname on failure
    
    if ($hostip == $host) // if the IP is not resloved
    {
        echo "Server is down or does not exist";
    }
    else
    {
        if (!$x = @fsockopen($hostip, $port, $errno, $errstr, 5)) // attempt to connect
        {
            echo "Server is down";
        }
        else 
        {
            echo "Server is up";
            if ($x)
            {
                @fclose($x); //close connection
            }
        }  
    }
}
?>

v13+phpnet at it dot teithe dot gr (2007-01-24 15:01:38)

The following function performs pop3 authentication. Returns NULL on error, or true/false to indicate username/password matching:

$address is the hostname of the server and $ssl is a boolean that indicates whether an SSL connection is requested.

<?php
function pop3authCheck($username, $password, $address, $ssl)
{
    if ($ssl)
        $uri="ssl://$address:995";
    else
        $uri="tcp://$address:110";

    $fp=fsockopen($uri);

    if (!$fp)
        return(NULL);

    $st=fgets($fp, 512);
    if (substr($st, 0, 3)!="+OK")
    {
        fclose($fp);
        return(NULL);
    }

    $st="USER $username\n";
    if (fwrite($fp, $st)!=strlen($st))
    {
        fclose($fp);
        return(NULL);
    }

    $st=fgets($fp, 512);
    if (substr($st, 0, 3)!="+OK")
    {
        fclose($fp);
        return(NULL);
    }

    $st="PASS $password\n";
    if (fwrite($fp, $st)!=strlen($st))
    {
        fclose($fp);
        return(NULL);
    }

    $st=fgets($fp, 512);
    fclose($fp);
    if (substr($st, 0, 3)=="+OK")
        return(true);
    else if (substr($st, 0, 4)=="+ERR")
        return(false);
    else
        return(NULL);
}
?>

(2006-12-04 08:34:58)

I've had issues with some of the handlers for chunked http 1.1 responses.  Here's a method that worked for me, if it works for you as well, then cheers :P

<?php

    function httpSocketConnection($host, $method, $path, $data)
    {
        $method = strtoupper($method);        
        
        if ($method == "GET")
        {
            $path.= '?'.$data;
        }    
        
        $filePointer = fsockopen($host, 80, $errorNumber, $errorString);
        
        if (!$filePointer) 
        {
            logEvent('debug', 'Failed opening http socket connection: '.$errorString.' ('.$errorNumber.')<br/>\n');
            return false;
        }

        $requestHeader = $method." ".$path."  HTTP/1.1\r\n";
        $requestHeader.= "Host: ".$host."\r\n";
        $requestHeader.= "User-Agent:      Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.1) Gecko/20061010 Firefox/2.0\r\n";
        $requestHeader.= "Content-Type: application/x-www-form-urlencoded\r\n";

        if ($method == "POST")
        {
            $requestHeader.= "Content-Length: ".strlen($data)."\r\n";
        }
        
        $requestHeader.= "Connection: close\r\n\r\n";
        
        if ($method == "POST")
        {
            $requestHeader.= $data;
        }            

        fwrite($filePointer, $requestHeader);
        
        $responseHeader = '';
        $responseContent = '';

        do 
        {
            $responseHeader.= fread($filePointer, 1); 
        }
        while (!preg_match('/\\r\\n\\r\\n$/', $responseHeader));
        
        
        if (!strstr($responseHeader, "Transfer-Encoding: chunked"))
        {
            while (!feof($filePointer))
            {
                $responseContent.= fgets($filePointer, 128);
            }
        }
        else 
        {

            while ($chunk_length = hexdec(fgets($filePointer))) 
            {
                $responseContentChunk = '';
            
                logEventToTextFile('debug', $chunk_length);
                $read_length = 0;
                
                while ($read_length < $chunk_length) 
                {
                    $responseContentChunk .= fread($filePointer, $chunk_length - $read_length);
                    $read_length = strlen($responseContentChunk);
                }

                $responseContent.= $responseContentChunk;
                
                fgets($filePointer);
                
            }
            
        }

        logEventToTextFile('debug', $responseContent);
        
        
        return chop($responseContent);
    }

?>

albertohf at hotmail dot com (2006-08-03 09:01:13)

I had a problem receving a "Content-Transfer: chunked" response i tried some prior codes but i had some problems too and i decided to code my own (it post something and receive the response although it's chunked). I hope you enjoy...

<?php
    function doPost($uri,$postdata,$host){
        $da = fsockopen($host, 80, $errno, $errstr);
        if (!$da) {
            echo "$errstr ($errno)<br/>\n";
            echo $da;
        }
        else {
            $salida ="POST $uri  HTTP/1.1\r\n";
            $salida.="Host: $host\r\n";
            $salida.="User-Agent: PHP Script\r\n";
            $salida.="Content-Type: application/x-www-form-urlencoded\r\n";
            $salida.="Content-Length: ".strlen($postdata)."\r\n";
            $salida.="Connection: close\r\n\r\n";
            $salida.=$postdata;
            fwrite($da, $salida);
                     while (!feof($da))
                $response.=fgets($da, 128);
            $response=split("\r\n\r\n",$response);
            $header=$response[0];
            $responsecontent=$response[1];
            if(!(strpos($header,"Transfer-Encoding: chunked")===false)){
                $aux=split("\r\n",$responsecontent);
                for($i=0;$i<count($aux);$i++)
                    if($i==0 || ($i%2==0))
                        $aux[$i]="";
                $responsecontent=implode("",$aux);
            }//if
            return chop($responsecontent);
        }//else
    }//function-doPost
?>

dmitry dot polushkin at gmail dot com (2006-05-22 05:45:17)

If you want to GET/POST some page through the HTTP protocol and if you want to keep-alive your connection, you may have a problem with a loop-stuck. Here is hint how to solve it:
<?php
$fp = fsockopen ("www.php.net", 80, $errno, $errstr, 30);
if(!$fp) {
    echo $errstr;
} else {
    fwrite($fp, "GET / HTTP/1.1\r\nHost: www.php.net\r\nConnection: Keep-Alive\r\n\r\n");
    $data = '';
    while(!feof($fp)) {
        $data .= fread($fp, 4096);
        if(substr($data, -9)=="\r\n\r\n0\r\n\r\n") {
            exit;
        }
    }
}
echo $data;
?>

yourpicture at hotpop dot com (2006-05-04 11:30:32)

When your connection times out the server may issue Fatal error: Maximum execution time of 30 seconds exceeded in ...
To get around this try this method used with error handling and copied method for ping operation.

<?php
    function Ping(){
        // false proxy used to generate connection error
        $ProxyServer = "116.155.95.163";
        $ProxyPort = 8080;
        $timeout=10;
        echo "Opening ProxyServer $ProxyServer<br>";
        // must use next two statements
        Set_Time_Limit(0);  //Time for script to run .. not sure how it works with 0 but you need it
        Ignore_User_Abort(True); //this will force the script running at the end
        
        $handle = fsockopen($ProxyServer, $ProxyPort,$errno,$errstr,$timeout);        
        if (!$handle){
            echo "Failed to open ProxyServer $ProxyServer errno=$errno,errstr=$errstr<br>";
            return 0;
        }
        else {
            // copied method for PING like time operation
            $status = socket_get_status($handle);
            echo "Opened ProxyServer $ProxyServer<br>";
            
            //Time the responce
            list($usec, $sec) = explode(" ", microtime(true));
            $start=(float)$usec + (float)$sec;
            
            
            $timeout=120;
            stream_set_timeout($handle,$timeout);      
            //send somthing
            ini_set('display_errors','0');
            $write=fwrite($handle,"echo this\n");
            if(!$write){
                return 0;
            }
            
            echo "Try To Read<br>";
            stream_set_blocking($handle,0);   
            //Try to read. the server will most likely respond with a "ICMP Destination Unreachable" and end the read. But that is a responce!
            fread($handle,1024);
            fclose($handle);
            echo "Read<br>";
            ini_set('display_errors','1');
                  
            //Work out if we got a responce and time it           
            list($usec, $sec) = explode(" ", microtime(true));
            $laptime=((float)$usec + (float)$sec)-$start;
            if($laptime>$timeout)
                return 0;
            //else   
            //    $laptime = round($laptime,3);
            return $laptime;
        }
    }

    // must use ErrorHandler to avoid php error being printed to screen
    function userErrorHandler($errno, $errmsg, $filename, $linenum, $vars)
    {
       // you can set this to what ever you like.
       echo "In Error Handler<br>";
       return 0;
    }

    $old_error_handler = set_error_handler("userErrorHandler");

    $time = Ping();
    echo "Time=$time<br>";
    echo "Done Checking<br>";
?>

Response Will be:
Opening ProxyServer 116.155.95.163
In Error Handler
Failed to open ProxyServer 116.155.95.163 errno=10060,errstr=A connection attempt failed 
because the connected party did not properly respond after a period of time, or 
established connection failed because connected host has failed to respond. 
Time=0
Done Checking

Thanks to everyone for your source code examples.
AndE

yadiutama_skom at yahoo dot com (2006-04-07 02:09:25)

This is a simple example for sending and retrieve SOAP message by using fsockopen:

<?php
$fp = @fsockopen("www.example.com", 80, $errno, $errstr);
if (!$fp) {
    echo "$errstr ($errno)<br />\n";
} else {

$soap_out  = "POST /example/exampleServer.php HTTP/1.0\r\n";
$soap_out .= "Host: www.example.com\r\n";
$soap_out .= "User-Agent: MySOAPisOKGuys \r\n";
$soap_out .= "Content-Type: text/xml; charset=ISO-8859-1\r\n";
$soap_out .= "Content-Length: 512\r\n\r\n";
$soap_out .= '<?xml version="1.0" encoding="ISO-8859-1"?>
<SOAP-ENV:Envelope SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/">
<SOAP-ENV:Body>
<ns5973:contact xmlns:ns5973="http://tempuri.org">
<__numeric_0><id  xsi:nil="true"/></__numeric_0>
</ns5973:contact>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>';

    fputs($fp, $soap_out, strlen($soap_out));  // send request SOAP

    echo "<xmp>".$out."</xmp>";

    while (!feof($fp)) {
        $soap_in . = fgets($fp, 100);
    }

    echo "<xmp>$soap_in</xmp>";   //display response SOAP

    fclose($fp);
}
?> 

And this is an example result:

POST /soap/example/contactServer.php HTTP/1.0
Host: www.example.com
User-Agent: MySOAPisOKGuys
Content-Type: text/xml; charset=ISO-8859-1
Content-Length: 512
<?xml version="1.0" encoding="ISO-8859-1"?>
<SOAP-ENV:Envelope
SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/">
<SOAP-ENV:Body><ns5973:contact
xmlns:ns5973="http://tempuri.org"><__numeric_0><id
xsi:nil="true"/></__numeric_0></ns5973:contact>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>

HTTP/1.1 200 OK
Date: Thu, 06 Apr 2006 07:03:26 GMT
Server: Apache/1.3.23 (Win32)
X-Powered-By: PHP/4.1.1
X-SOAP-Server: MySOAPisOKGuys
Content-Length: 625
Connection: close
Content-Type: text/xml; charset=ISO-8859-1
<?xml version="1.0" encoding="ISO-8859-1"?>
<SOAP-ENV:Envelope
SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/">
<SOAP-ENV:Body><ns1:contactResponse
xmlns:ns1="http://tempuri.org">
<return xsi:type="xsd:string">
</return>
</ns1:contactResponse>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>