<?php

$postfields = array(
    'upload_file' => '@file_to_upload.png',
    'upload_text' => '@text_to_upload'
);

$curl = curl_init();
curl_setopt($curl, CURLOPT_URL, 'http://example.com/upload-test');
curl_setopt($curl, CURLOPT_POSTFIELDS, $postfields);
curl_exec($curl);
curl_close($curl);

?>

To get around this, prepend the text string with the NULL character like so:

- 'Server-side' cookies exists as information even before they were set on browser agent(HTTP COOKIE HEADER),
- javascript cookies does NOT exists as information before they were set on browser agent,

<?php 
session_start(); 
$strCookie = 'PHPSESSID=' . $_COOKIE['PHPSESSID'] . '; path=/'; 
session_write_close(); 

$curl_handle = curl_init('enter_external_url_here'); 
curl_setopt( $curl_handle, CURLOPT_COOKIE, $strCookie ); 
curl_exec($curl_handle); 
curl_close($curl_handle); 
?> 

This worked great for me.  I was calling pages from the same server and needed to keep the $_SESSION variables.  This passes them over.  If you want to test, just print_r($_SESSION); 

I got this error: Warning: curl_setopt() expects parameter 2 to be long, string given

If you are experiencing simular problems, you can replace the constant with the actual number or (re)define the constant.

CURLOPT_TIMEOUT_MS should be 155
CURLOPT_CONNECTTIMEOUT_MS should be 156

<?php

function callback($download_size, $downloaded, $upload_size, $uploaded)
{

    // do your progress stuff here
}

$ch = curl_init('http://www.example.com');

// This is required to curl give us some progress
// if this is not set to false the progress function never
// gets called
curl_setopt($ch, CURLOPT_NOPROGRESS, false);

// Set up the callback
curl_setopt($ch, CURLOPT_PROGRESSFUNCTION, 'callback');

// Big buffer less progress info/callbacks
// Small buffer more progress info/callbacks
curl_setopt($ch, CURLOPT_BUFFERSIZE, 128);

$data = curl_exec($ch);

Firstly, the HTML form used input names like these:
<input type="text" name="product[name]" />
<input type="text" name="product[cost]" />
<input type="file" name="product[thumbnail]" />
in conjunction with two other form inputs not part of the product array
<input type="text" name="method" value="put" />
<input type="text" name="mode" />

I used several cURL options, but the only two (other than URL) that mattered were:
curl_setopt($handle, CURLOPT_POST, true);
curl_setopt($handle, CURLOPT_POSTFIELDS, $postfields);
Pretty standard so far.
Note: headers didn't need to be set, cURL automatically sets headers (like content-type: multipart/form-data; content-length...) when you pass an array into CURLOPT_POSTFIELDS.
Note: even though this is supposed to be a PUT command through an HTTP POST form, no special PUT options needed to be passed natively through cURL. Options such as
curl_setopt($handle, CURLOPT_HTTPHEADER, array('X-HTTP-Method-Override: PUT', 'Content-Length: ' . strlen($fields)));
or
curl_setopt($handle, CURLOPT_PUT, true);
or
curl_setopt($handle, CURLOPT_CUSTOMREQUEST, "PUT);
were not needed to make the code work.

The fields I wanted to pass through cURL were arranged into an array something like this:
$postfields = array("method" => $_POST["method"],
                    "mode" => $_POST["mode"],
                    "product" => array("name" => $_POST["product"], 
                                        "cost" => $_POST["product"]["cost"], 
                                        "thumbnail" => "@{$_FILES["thumbnail"]["tmp_name"]};type={$_FILES["thumbnail"]["type"]}")
                    );

-Notice how the @ precedes the temporary filename, this creates a link so PHP will upload/transfer an actual file instead of just the file name, which would happen if the @ isn't included.
-Notice how I forcefully set the mime-type of the file to upload. I was having issues where images filetypes were defaulting to octet-stream instead of image/png or image/jpeg or whatever the type of the selected image.

I then tried passing $postfields straight into curl_setopt($this->handle, CURLOPT_POSTFIELDS, $postfields); but it didn't work.
I tried using http_build_query($postfields); but that didn't work properly either.
In both cases either the file wouldn't be treated as an actual file and the form data wasn't being sent properly. The problem was HTTP's methods of transmitting arrays. While PHP and other languages can figure out how to handle arrays passed via forms, HTTP isn't quite as sofisticated. I had to rewrite the $postfields array like so:
$postfields = array("method" => $_POST["method"],
                    "mode" => $_POST["mode"],
                    "product[name]" => $_POST["product"], 
                    "product[cost]" => $_POST["product"]["cost"], 
                    "product[thumbnail]" => "@{$_FILES["thumbnail"]["tmp_name"]}");
curl_setopt($handle, CURLOPT_POSTFIELDS, $postfields);

<?php 
$submit_url = "https://sitename/process.php"; 

$curl = curl_init(); 

curl_setopt($curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC ) ; 
curl_setopt($curl, CURLOPT_USERPWD, "username:password"); 
curl_setopt($curl, CURLOPT_SSLVERSION,3); 
curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, FALSE); 
curl_setopt($curl, CURLOPT_SSL_VERIFYHOST, 2); 
curl_setopt($curl, CURLOPT_HEADER, true); 
curl_setopt($curl, CURLOPT_POST, true); 
curl_setopt($curl, CURLOPT_POSTFIELDS, $params ); 
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true); 
curl_setopt($curl, CURLOPT_USERAGENT, "Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)"); 
curl_setopt($curl, CURLOPT_URL, $submit_url); 

$data = split("text/html", curl_exec($curl) ); 
$temp = split("\r\n", $data[1]) ; 

$result = unserialize( $temp[2] ) ; 

<?php
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT");
curl_setopt($ch, CURLOPT_PUT, 1);
?>

are "useless" without;

<?php
curl_setopt($ch, CURLOPT_HTTPHEADER, array('X-HTTP-Method-Override: PUT'));
?>

Example;

Updating a book data in database identified by "id 1";

--cURL Part--
<?php
$data = http_build_query($_POST);
// or
$data = http_build_query(array(
   'name'  => 'PHP in Action',
   'price' => 10.9
));

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "http://api.localhost/rest/books/1");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
// curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT"); // no need anymore
// or
// curl_setopt($ch, CURLOPT_PUT, 1); // no need anymore
curl_setopt($ch, CURLOPT_HTTPHEADER, array('X-HTTP-Method-Override: PUT'));
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
$ce = curl_exec($ch);
curl_close($ch);
print_r($ce);
?>

--API class--
<?php
public function putAction() {

    echo "putAction() -> id: ". $this->_getParam('id') ."\n";
    print_r($_POST);
    // do stuff with post data
    ...
?>

--Output--
putAction() -> id: 15
Array
(
    [name] => PHP in Action
    [price] => 10.9
)

curl -XGET 'http://example.org?foo=bar' -d '<baz>some additional data</baz>'

in PHP you'll do, besides your other necessary stuff,

- CURLOPT_COOKIEJAR is used when cURL is reading cookie data from disk. 

- CURLOPT_COOKIEFILE is used when cURL is writing the cookie data to disk. 

"If libcurl is built to use the standard system name resolver, that portion of the transfer will still use full-second resolution for timeouts with a minimum timeout allowed of one second."

What this means to PHP developers is "You can use this function without testing it first, because you can't tell if libcurl is using the standard system name resolver (but you can be pretty sure it is)"

The problem is that on (Li|U)nix, when libcurl uses the standard name resolver, a SIGALRM is raised during name resolution which libcurl thinks is the timeout alarm.

The solution is to disable signals using CURLOPT_NOSIGNAL.  Here's an example script that requests itself causing a 10-second delay so you can test timeouts:

<?php
if (!isset($_GET['foo'])) {

        // Client
        $ch = curl_init('http://localhost/test/test_timeout.php?foo=bar');
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_NOSIGNAL, 1);
        curl_setopt($ch, CURLOPT_TIMEOUT_MS, 200);
        $data = curl_exec($ch);
        $curl_errno = curl_errno($ch);
        $curl_error = curl_error($ch);
        curl_close($ch);

<?php 

function write_function($curl_resource, $string) 
{ 
    if(curl_getinfo($curl_resource, CURLINFO_SIZE_DOWNLOAD) <= 2000) 
    { 
        header('Expires: 0'); 
        header('Cache-Control: must-revalidate, post-check=0, pre-check=0'); 
        header('Pragma: public'); 
        header('Content-Description: File Transfer'); 
        header("Content-Transfer-Encoding: binary"); 
        header("Content-Type: ".curl_getinfo($curl_resource, CURLINFO_CONTENT_TYPE).""); 
        header("Content-Length: ".curl_getinfo($curl_resource,CURLINFO_CONTENT_LENGTH_DOWNLOAD).""); 
    } 
    
    print $string; 

    return mb_strlen($string, '8bit'); 
} 

?> 

1440 is the the default number of bytes curl will call the write function (BUFFERSIZE does not affect this, i actually think you can not change this value), so it means the headers are going to be set only one time. 

then you will want to read http://www.php.net/ChangeLog-4.php which says "Disabled CURLOPT_FOLLOWLOCATION in curl when open_basedir or safe_mode are enabled." as of PHP 4.4.4/5.1.5.  This is due to the fact that curl is not part of PHP and doesn't know the values of open_basedir or safe_mode, so you could comprimise your webserver operating in safe_mode by redirecting (using header('Location: ...')) to "file://" urls, which curl would have gladly retrieved.

Until the curl extension is changed in PHP or curl (if it ever will) to deal with "Location:" headers, here is a far from perfect remake of the curl_exec function that I am using.

Since there's no curl_getopt function equivalent, you'll have to tweak the function to make it work for your specific use.  As it is here, it returns the body of the response and not the header.  It also doesn't deal with redirection urls with username and passwords in them.

http://curl.haxx.se/docs/caextract.html

Then set a path to it in your php.ini file, e.g. on Windows:

curl.cainfo=c:\php\cacert.pem

<?php 
function curl_exec_follow(/*resource*/ $ch, /*int*/ &$maxredirect = null) { 
    $mr = $maxredirect === null ? 5 : intval($maxredirect); 
    if (ini_get('open_basedir') == '' && ini_get('safe_mode' == 'Off')) { 
        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, $mr > 0); 
        curl_setopt($ch, CURLOPT_MAXREDIRS, $mr); 
    } else { 
        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, false); 
        if ($mr > 0) { 
            $newurl = curl_getinfo($ch, CURLINFO_EFFECTIVE_URL); 

<?php

/**
 * test.php:
 */
$ch = curl_init('http://example.com');

curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, array(
    'foo' => $_GET['bar']
));

curl_exec($ch);

<?php 
$ch = curl_init(); 
curl_setopt($ch, CURLOPT_URL, XML_POST_URL); 
curl_setopt ($ch, CURLOPT_HTTPHEADER, array('SOAPAction: ""'));    
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); 
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE); 
curl_setopt($ch, CURLOPT_POSTFIELDS, XML_PAYLOAD); 
curl_setopt($ch, CURLOPT_HEADER, 0); 

$output = curl_exec($ch); 
?> 

Note : Having based my snipet on Chemo demonstration (oscommerce user know who he is), XML_POST_URL and XML_PAYLOAD where defined as constant with define(). 

default - callbacks will be called as expected.
true - content will be returned but callback function will not be called.
false - content will be output and callback function will not be called.

Then you might want to use CURLOPT_REFERER.

<?php

// $url = page to POST data
// $ref_url = tell the server which page you came from (spoofing)
// $login = true will make a clean cookie-file.
// $proxy = proxy data
// $proxystatus = do you use a proxy ? true/false

function 
curl_grab_page($url,$ref_url,$data,$login,$proxy,$proxystatus){

    if($login == 'true') {

        $fp = fopen("cookie.txt", "w");
        fclose($fp);
    }
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_COOKIEJAR, "cookie.txt");
    curl_setopt($ch, CURLOPT_COOKIEFILE, "cookie.txt");
    curl_setopt($ch, CURLOPT_USERAGENT, "Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)");
    curl_setopt($ch, CURLOPT_TIMEOUT, 40);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);
    if ($proxystatus == 'true') {

        curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, TRUE);
        curl_setopt($ch, CURLOPT_PROXY, $proxy);
    }
    curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);

    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    curl_setopt($ch, CURLOPT_REFERER, $ref_url);

    curl_setopt($ch, CURLOPT_HEADER, TRUE);
    curl_setopt($ch, CURLOPT_USERAGENT, $_SERVER['HTTP_USER_AGENT']);
    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, TRUE);
    curl_setopt($ch, CURLOPT_POST, TRUE);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
    ob_start();
    return curl_exec ($ch); // execute the curl command
    ob_end_clean();
    curl_close ($ch);
    unset($ch);
}

echo curl_grab_page("https://www.example.net/login.php", "https://www.example.net/","username=foo&password=bar", "true",  "null", "false");

<?php 

$fh = fopen('/tmp/foo', 'w'); 
$ch = curl_init('http://example.com/foo'); 
curl_setopt($ch, CURLOPT_FILE, $fh); 
curl_exec($ch); 
curl_close($ch); 

# at this point your file is not complete and corrupted 

fclose($fh); 

# now you can use your file; 

read_file('/tmp/foo'); 

Anyone trying to connect to .NET with CURL to send a simple XML post, pay attention to the following. This will save you hours! There is a previous note that I saw either on this page, or somewhere else on this site that explains the correct way to specify the header option is to create an array, then reference the array from the CURLOPT. 

ie.  Do something like this: 

<?php 
// Req. HTTP Header Values 
 $header[] = "Content-type: text/xml"; 

// Target URL 
 $sendTo = "http://www.example.com"; 

// Post Data 
 $post = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<root>\n....etc, etc,"; 

// Create CURL Connection 
 $ch = curl_init(); 
 curl_setopt($ch, CURLOPT_USERAGENT, 'XtraDoh xAgent'); 
 curl_setopt($ch, CURLOPT_URL, $sendTo); 
 curl_setopt($ch, CURLOPT_TIMEOUT, 900); 
 curl_setopt($ch, CURLOPT_CONNECTIONTIMEOUT, 30); 
 curl_setopt($ch, CURLOPT_FAILONERROR, false); 
 curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0); 
 curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0); 
 curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true); 
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); 
 curl_setopt($ch, CURLOPT_HTTPHEADER, $header); 
 curl_setopt($ch, CURLOPT_POST, true); 
 curl_setopt($ch, CURLOPT_POSTFIELDS, $post); 
?> 

Notice the HTTPHEADER, $header above. I have not been able to get .NET to properly read the HTTP header as specified (in this case as text/xml) when using the following: 

<?php 
$curl = curl_init(); 
curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, FALSE); 
curl_setopt($curl, CURLOPT_HEADER, 0); 
curl_setopt($curl, CURLOPT_POST, true); 
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true); 
curl_setopt($curl, CURLOPT_USERAGENT, "Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)"); 
curl_setopt($curl, CURLOPT_FOLLOWLOCATION, true); 
curl_setopt($curl, CURLOPT_COOKIEFILE, "cookiefile"); 
curl_setopt($curl, CURLOPT_COOKIEJAR, "cookiefile"); # SAME cookiefile 
curl_setopt($curl, CURLOPT_URL, "url1"); # this is where you first time connect - GET method authorization in my case, if you have POST - need to edit code a bit 
$xxx = curl_exec($curl); 

curl_setopt($curl, CURLOPT_URL, "url2"); # this is where you are requesting POST-method form results (working with secure connection using cookies after auth) 
curl_setopt($curl, CURLOPT_POSTFIELDS, "var1=value&var2=value&var3=value&"); # form params that'll be used to get form results 
$xxx = curl_exec($curl); 

The problem I ran into was the filename had an '@' in the middle of it.  It turned out that at least on my system if I encoded the file path using the quoted_printable_encode() function the upload works. 

I'm posting this in the hopes that it will help someone else, and for my own future reference. 

Code: 
<?php 

$filepath = '/tmp/test@example.txt'; 
$postdata['file'] = '@' . quoted_printable_encode($filepath); 

//... supporting code. 

$result = curl_exec($ch); 

?> 
I'm not exactly sure why this works when escaping the '@' doesn't work but it does for me. 

If anyone can offer insight into why this works or a better way to handle the '@' symbol in a filename when using curl to upload I would love to hear it. 

Warning: curl_setopt() [function.curl-setopt]: CURLOPT_FOLLOWLOCATION cannot be activated when safe_mode is enabled or an open_basedir is set

After looking through the notes, most of the proposed manual implementations were kind of clunky and in some cases just didn't work at all. Most importantly (in my case), was the behaviour of the 302 Header. Anyway, here's the code I ended up using which has worked well for me in all cases so far, it even addresses the issue that caused FOLLOWLOCATION to be turned off in some cases :)

EDIT: Unfortunately the code itself is deemed "too long" for PHP's note system. I've uploaded it to a few paste sites below so hopefully the links will live for a while at least.

http://pastebin.com/aaJtPy1j
http://pastie.org/7646116

Use it as a replacement for curl_exec. For example:

This is because boolean true casts into integer 1, and CURLOPT_SSL_VERIFYHOST = 1 is not secure behavior.

<?php 
$ch = curl_init(); 
$timeout = 5; // set to zero for no timeout 
curl_setopt ($ch, CURLOPT_URL, $url); 
curl_setopt ($ch, CURLOPT_RETURNTRANSFER, 1); 
curl_setopt ($ch, CURLOPT_CONNECTTIMEOUT, $timeout); 
$file_contents = curl_exec($ch); 
curl_close($ch); 

curl_setopt($ch, CURLOPT_POSTFIELDS, $data);

is synonym to:

curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);

Even if you set the options like this (in this order):

curl_setopt($ch, CURLOPT_POST, 0);
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);

To disable this behavior one must disable the use of the "Expect:" header with

<?php 
$ch = curl_init(); 
$fh = fopen('/path/to/stored/file/example_file.dat', 'w'); 
curl_setopt($ch, CURLOPT_FILE, $fh); 
curl_setopt($ch, CURLOPT_URL, 'http://example.com/example_file.dat'); 
curl_exec($ch); 
fflush($fh); 
fclose($fh); 

You may supply an array, but there may not be any sub-arrays in this array, as this will give Array-to-string-conversion notice. 

Example: 

<?php 
$ch = curl_init(); 

# this works 
$data = array('name' => 'value'); 

# this gives "Notice: Array to string conversion..." 
$data = array('name' => array('subname' => 'subvalue')); 

curl_setopt($ch, CURLOPT_URL, 'http://localhost/test.php'); 
curl_setopt($ch, CURLOPT_POST, 1); 
curl_setopt($ch, CURLOPT_POSTFIELDS, $data); 

<?php
//This can cause errors
$data = array('bar');

//Use this instead
$data = array('foo' => 'bar');

<?php
  curl_setopt($ch, CURLOPT_POSTFIELDS, array('file' => '@/path/to/file.ext');
?>

will post the FULL PATH of the file in the filename field:

Content-Disposition: form-data; name="file"; filename="/path/to/file.ext"

Whereas typical browser behavior only sends the filename:

Content-Disposition: form-data; name="file"; filename="file.ext"

If there is a need to send non-scalar values using a POST request, consider serializing them before transmission. 

<?php 
$ch = curl_init('http://host.example.com'); 

// Data to post 
$multiDimensional = array( 
   'name' = 'foo', 
   'data' = array(1,2,3,4), 
   'value' = 'bar' 
); 

// Will error 
curl_setopt($ch, CURLOPT_POSTFIELDS, $multiDimensional); 

// Data to post 
$postData = array( 
  'name' = 'foo', 
  'data' = serialize(array(1,2,3,4)), 
  'value' = 'bar' 
); 

So do this: 

<?php 
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); 
curl_setopt($ch, CURLOPT_FILE, $fp); 
?> 

not this: 

When you write a callback function and use it with curlopt_writefunction it will be called MULTIPLE times. Your function MUST return the ammount of data written to it each time. It is very picky about this. Here is a snippet from my code that may help you

<?php
curl_setopt($this->curl_handle, CURLOPT_WRITEFUNCTION, array($this, "receiveResponse"));

// later on in the class I wrote my receive Response method

private function receiveResponse($curlHandle,$xmldata)
                {

                        $this->responseString = $xmldata;
                        $this->responseXML .=  $this->responseString;
                        $this->length = strlen($xmldata);
                        $this->size += $this->length;
                        return $this->length;

                }
?>

Now I did this for a class. If you aren't doing OOP then you will obviously need to modify this for your own use.

<?php

$data = array('file' => '@/home/user/test.png;type=image/png');

?>

Simply adding a semicolon with the type= at the end.
Note that this has been reported not to work in all versions of PHP and I have done the following tests:

5.2.6 (libcurl 7.18.2) : Does not work
5.2.13 (libcurl 7.20.0) : Works just fine

<?php

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $foo);
curl_setopt($ch, CURLOPT_TIMEVALUE, filemtime($foo_path));
curl_setopt($ch, CURLOPT_TIMECONDITION, CURLOPT_TIMECOND_IFMODIFIEDSINCE);
curl_exec($ch);
// Reuse same curl handle
curl_setopt($ch, CURLOPT_URL, $bar);
curl_setopt($ch, CURLOPT_TIMEVALUE, null); // don't know mtime
curl_setopt($ch, CURLOPT_TIMECONDITION, 0); // set it to 0, turns it off
curl_exec($ch);

For example: 

<?php 
class downloader { 
    private $curl; 

    function __construct() { 
        $this->curl = curl_init(); 
        curl_setopt($this->curl, CURLOPT_WRITEFUNCTION, array($this, "curl_handler_recv")); 
    } 

Example: 

<?php 
function doPut($url, $fields) 
{ 
   $fields = (is_array($fields)) ? http_build_query($fields) : $fields; 

   if($ch = curl_init($url)) 
   { 
      curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT'); 
      curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); 
      curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Length: ' . strlen($fields))); 
      curl_setopt($ch, CURLOPT_POSTFIELDS, $fields); 
      curl_exec($ch); 

      $status = curl_getinfo($ch, CURLINFO_HTTP_CODE); 

      curl_close($ch); 

      return (int) $status; 
   } 
   else 
   { 
      return false; 
   } 
} 

if(doPut('http://example.com/api/a/b/c', array('foo' => 'bar')) == 200) 
   // do something 
else 
   // do something else. 
?> 

You can grab the request data on the other side with: 

<?php 
if($_SERVER['REQUEST_METHOD'] == 'PUT') 
{ 
   parse_str(file_get_contents('php://input'), $requestData); 

   // Array ( [foo] => bar ) 
   print_r($requestData); 

Consider the following:
<?php
    # ...

    curl_setopt($cURL,CURLOPT_HTTPHEADER,array (
        "Content-Type: text/xml; charset=utf-8",
        "Expect: 100-continue"
    ));

    # ... do some other stuff ...

    curl_setopt($cURL,CURLOPT_HTTPHEADER,array (
        "Accept: application/json"
    ));

$post must be an array 
$page is the page where POST datas will be send. 
$n must be true to continue if they are php redirection (Location: ) 
$session must be define true if you want to use cookies 
$referer must be a link to get a wrong referer or only to have a referer. 

<?php 
#call it normally 
$ch = curl_init(); 
curl_setopt($ch, CURLOPT_HEADER, 0); 
curl_setopt($ch, CURLOPT_COOKIEFILE, "cookiefile"); 
curl_setopt($ch, CURLOPT_COOKIEJAR, "cookiefile"); 
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); 
curl_setopt($ch, CURLOPT_URL, 'http://www.example.com/'); 
$result1 = curl_exec($ch); 

<?php 
    $username = 'username'; 
    $password = 'password'; 
    $url = 'example.com'; 
    $ftp_server = "ftp://" . $username . ":" . $password . "@" . $url; 
    
    echo "Starting CURL.\n"; 
    $ch = curl_init(); 
    echo "Set CURL URL.\n"; 
    
    //curl FTP 
    curl_setopt($ch, CURLOPT_URL, $ftp_server); 
    
    //For Debugging 
    //curl_setopt($ch, CURLOPT_VERBOSE, TRUE);    
    
    //SSL Settings 
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE); 
    curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, FALSE); 
    curl_setopt($ch, CURLOPT_FTP_SSL, CURLFTPSSL_TRY); 
    
    //List FTP files and directories 
    curl_setopt($ch, CURLOPT_FTPLISTONLY, TRUE); 
    
    //Output to curl_exec 
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); 

    echo "Executing CURL.\n"; 
    $output = curl_exec($ch); 
    curl_close($ch); 
    echo "Closing CURL.\n"; 
    echo $output . "\n"; 

PHP NTLM AUTH 

Make sure you have the 'curl' extension loaded 
now just do... 

<?php 
$ch = curl_init(); 
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE); 
curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE); 
curl_setopt($ch, CURLOPT_COOKIESESSION, TRUE); 
curl_setopt($ch, CURLOPT_HEADER, 0); 
curl_setopt($ch, CURLOPT_COOKIEFILE, "cookiefile"); 
curl_setopt($ch, CURLOPT_COOKIEJAR, "cookiefile"); 
curl_setopt($ch, CURLOPT_COOKIE, session_name() . '=' . session_id()); 
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); 

curl_setopt($ch, CURLOPT_URL, 'http://example.com/page1.php'); 
$result1 = curl_exec($ch); 

curl_setopt($ch, CURLOPT_URL, 'http://example.com/page2.php'); 
$result2 = curl_exec($ch); 

<?php 
curl_setopt(CURLOPT_POSTFIELDS, array('field1' => 'value')); 
?> 

Passing a URL-encoded string will result in application/x-www-form-urlencoded: 

ifconfig command will output something like:

rl0: flags=8843<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> mtu 1500
    options=8<VLAN_MTU>
    inet 82.146.XXX.XXX netmask 0xffffffff broadcast 82.146.XXX.XXX
    inet 78.24.XXX.XXX netmask 0xffffffff broadcast 78.24.XXX.XXX
    inet 82.146.XXX.XXX netmask 0xffffffff broadcast 82.146.XXX.XXX
    inet 82.146.XXX.XXX netmask 0xffffffff broadcast 82.146.XXX.XXX
    inet 82.146.XXX.XXX netmask 0xffffffff broadcast 82.146.XXX.XXX
    inet 78.24.XXX.XXX netmask 0xffffffff broadcast 78.24.XXX.XXX
    inet 78.24.XXX.XXX netmask 0xffffffff broadcast 78.24.XXX.XXX
    ether XX:XX:XX:XX:XX:XX
    media: Ethernet autoselect (100baseTX <full-duplex>)
    status: active
lo0: flags=8049<UP,LOOPBACK,RUNNING,MULTICAST> mtu 16384
tun0: flags=8051<UP,POINTOPOINT,RUNNING,MULTICAST> mtu 1500
    Opened by PID 564
tun1: flags=8051<UP,POINTOPOINT,RUNNING,MULTICAST> mtu 1500
    Opened by PID 565
    Opened by PID 565

See http://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html#sec8.2.3

* it adds a header, "Expect: 100-continue".  
* it then sends the request head, waits for a 100 response code, then sends the content 

Not all web servers support this though.  Various errors are returned depending on the server.  If this happens to you, suppress the "Expect" header with this command:

Example: 

<?php 
function check_url($url) { 
    $c = curl_init(); 
    curl_setopt($c, CURLOPT_URL, $url); 
    curl_setopt($c, CURLOPT_HEADER, 1); // get the header 
    curl_setopt($c, CURLOPT_NOBODY, 1); // and *only* get the header 
    curl_setopt($c, CURLOPT_RETURNTRANSFER, 1); // get the response as a string from curl_exec(), rather than echoing it 
    curl_setopt($c, CURLOPT_FRESH_CONNECT, 1); // don't use a cached version of the url 
    if (!curl_exec($c)) { return false; } 

<?php 
curl_setopt($ch, CURLOPT_HTTPHEADER, Array("Content-Type: text/xml")); 
?> 

makesure you watch for cache issue: 
the below code will prevent cache... 

         <?php 

         $credentials = "username:password"; 
         
         // Read the XML to send to the Web Service 
         $request_file = "./SampleRequest.xml"; 
        $fh = fopen($request_file, 'r'); 
        $xml_data = fread($fh, filesize($request_file)); 
        fclose($fh); 
                
        $url = "http://www.example.com/services/calculation"; 
        $page = "/services/calculation"; 
        $headers = array( 
            "POST ".$page." HTTP/1.0", 
            "Content-type: text/xml;charset=\"utf-8\"", 
            "Accept: text/xml", 
            "Cache-Control: no-cache", 
            "Pragma: no-cache", 
            "SOAPAction: \"run\"", 
            "Content-length: ".strlen($xml_data), 
            "Authorization: Basic " . base64_encode($credentials) 
        ); 
       
        $ch = curl_init(); 
        curl_setopt($ch, CURLOPT_URL,$url); 
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); 
        curl_setopt($ch, CURLOPT_TIMEOUT, 60); 
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers); 
        curl_setopt($ch, CURLOPT_USERAGENT, $defined_vars['HTTP_USER_AGENT']); 
        
        // Apply the XML to our curl call 
        curl_setopt($ch, CURLOPT_POST, 1); 
        curl_setopt($ch, CURLOPT_POSTFIELDS, $xml_data); 

        $data = curl_exec($ch); 

        if (curl_errno($ch)) { 
            print "Error: " . curl_error($ch); 
        } else { 
            // Show me the result 
            var_dump($data); 
            curl_close($ch); 
        } 

<?php curl_setopt($session, CURLOPT_HTTPPROXYTUNNEL, 1); ?> 

means that you will tunnel THROUGH the proxy, as in "your communications will go as if the proxy is NOT THERE". 

Why do you care? - Well, if you are trying to use, say, Paros, to debug HTTP between your cURL and the server, with CURLOPT_HTTPPROXYTUNNEL set to TRUE Paros will not see or log your traffic thus defeating the purpose and driving you nuts. 

SSL: certificate subject name 'example.com' does not match target host name 'example.net' 

Then you can set the following option to get around it: 

This piece of code solves it: 

<?php 

if ($cookies != '') 
    { 
    if (substr(PHP_OS, 0, 3) == 'WIN') 
        {
$cookies = str_replace('\\','/', getcwd().'/'.$cookies);} 
    curl_setopt($ch, CURLOPT_COOKIEJAR, $cookies); 
    curl_setopt($ch, CURLOPT_COOKIEFILE, $cookies); 
    } 

CURLOPT_FTP_SSL 

Pass a long using one of the values from below, to make libcurl use your desired level of SSL for the ftp transfer. (Added in 7.11.0) 

CURLFTPSSL_NONE 

Don't attempt to use SSL. 

CURLFTPSSL_TRY 

Try using SSL, proceed as normal otherwise. 

CURLFTPSSL_CONTROL 

Require SSL for the control connection or fail with CURLE_FTP_SSL_FAILED. 

CURLFTPSSL_ALL 

curl_error() told me "SSL certificate problem, verify that the CA cert is OK." 

I googled it and found the same "solution" over and over again: bypass verification by adding this line after curl_init(): 

<?php 
curl_setopt($connection, CURLOPT_SSL_VERIFYPEER, false); 
?> 

This worked great, but I was required to verify, so here's what I did. Add the following lines:

<?php 
curl_setopt($connection, CURLOPT_SSL_VERIFYPEER, 1); 
curl_setopt($connection, CURLOPT_CAINFO, "path:/ca-bundle.crt"); 
?> 

with "path:/ca-bundle.crt" being the path to that certificate file. You can get this file by downloading the curl package (http://curl.haxx.se/download.html) and looking for it in the lib folder. 

- CURLOPT_HEADERFUNCTION is for handling header lines received *in the response*,
- CURLOPT_WRITEFUNCTION is for handling data received *from the response*,
- CURLOPT_READFUNCTION is for handling data passed along *in the request*.

The callback "string" can be any callable function, that includes the array(&$obj, 'someMethodName') format.