Need help with curlcpp?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

JosephP91
443 Stars 151 Forks MIT License 282 Commits 4 Opened issues

Description

An object oriented C++ wrapper for CURL (libcurl)

Services available

!
?

Need anything else?

Contributors list

No Data

curlcpp

An object-oriented C++ wrapper for cURL tool

If you want to know a bit more about cURL and libcurl, you should go on the official website http://curl.haxx.se/

Donate

Help me to improve this project!

paypal

Compile and link

Standalone

cd build
cmake ..
make # -j2

Note: cURL >= 7.34 is required.

Then add

/build/src/
to your library path and
/include/
to your include path.

When linking, link against

curlcpp
(e.g.: g++ -std=c++11 example.cpp -o example -lcurlcpp -lcurl). Or if you want run from terminal,

g++ -std=c++11 example.cpp -L/home/username/path/to/build/src/ -I/home/username/path/to/include/ -lcurlcpp -lcurl

Submodule

When using a git submodule and CMake-buildsystem, add the following lines to your

CMakeLists.txt
:
ADD_SUBDIRECTORY(ext/curlcpp) # Change `ext/curlcpp` to a directory according to your setup
INCLUDE_DIRECTORIES(${CURLCPP_SOURCE_DIR}/include)

Simple usage example

Here are some usage examples. You will find more examples in the test folder!

Here's an example of a simple HTTP request to get google web page, using the curl_easy interface:

#include "curl_easy.h"

using curl::curl_easy; using curl::curl_easy_exception; using curl::curlcpp_traceback;

/**

  • This example shows how to make a simple request with curl.

  • / int main() { // Easy object to handle the connection. curl_easy easy;

    // Add some options. easy.add("http://"); easy.add(1L);

    try {

      easy.perform();

    } catch (curl_easy_exception &error) {

      // If you want to print the last error.
      std::cerr&lt;<error.what return>

    If you want to get information about the current curl session, you could do:

    #include "curl_easy.h"
    #include "curl_ios.h"
    #include "curl_exception.h"
    
    

using std::ostringstream;

using curl::curl_easy; using curl::curl_easy_exception; using curl::curlcpp_traceback; using curl::curl_ios;

/**

  • This example shows how to use the easy interface and obtain

  • informations about the current session.

  • / int main(int argc, const char **argv) { // Let's declare a stream ostringstream stream;

    // We are going to put the request's output in the previously declared stream curl_ios ios(stream);

    // Declaration of an easy object curl_easy easy(ios);

    // Add some option to the curl_easy object. easy.add("http://"); easy.add(1L);

    try {

      easy.perform();
    
      // Retrieve information about curl current session.
      auto x = easy.get_info<curlinfo_content_type>();
    
      /**
       * get_info returns a curl_easy_info object. With the get method we retrieve
       * the std::pair object associated with it: the first item is the return code of the
       * request. The second is the element requested by the specified libcurl macro.
       */
      std::cout&lt;<x.get catch if you want to print the last error. std::cerr entire error stack can do error.print_traceback return>

    Here's instead, the creation of an HTTPS POST login form:

    #include 
    
    

#include "curl_easy.h" #include "curl_pair.h" #include "curl_form.h" #include "curl_exception.h"

using std::string;

using curl::curl_form; using curl::curl_easy; using curl::curl_pair; using curl::curl_easy_exception; using curl::curlcpp_traceback;

int main(int argc, const char * argv[]) { curl_form form; curl_easy easy;

// Forms creation
curl_pair<curlformoption> name_form(CURLFORM_COPYNAME,"user");
curl_pair<curlformoption> name_cont(CURLFORM_COPYCONTENTS,"you username here");
curl_pair<curlformoption> pass_form(CURLFORM_COPYNAME,"passw");
curl_pair<curlformoption> pass_cont(CURLFORM_COPYCONTENTS,"your password here");

try {
    // Form adding
    form.add(name_form,name_cont);
    form.add(pass_form,pass_cont);

    // Add some options to our request
    easy.add<curlopt_url>("http://<your_url_here>");
    easy.add<curlopt_ssl_verifypeer>(false);
    easy.add<curlopt_httppost>(form.get());
    // Execute the request.
    easy.perform();

} catch (curl_easy_exception &amp;error) {
    // If you want to get the entire error stack we can do:
    curlcpp_traceback errors = error.get_traceback();
    // Otherwise we could print the stack like this:
    error.print_traceback();
}
return 0;

}

And if we would like to put the returned content in a file? Nothing easier than:

#include 
#include 
#include 

#include "curl_easy.h" #include "curl_ios.h" #include "curl_exception.h"

using std::cout; using std::endl; using std::ostream; using std::ofstream;

using curl::curl_easy; using curl::curl_ios; using curl::curl_easy_exception; using curl::curlcpp_traceback;

int main(int argc, const char * argv[]) { // Create a file ofstream myfile; myfile.open ("/path/to/your/file");

// Create a curl_ios object to handle the stream
curl_ios<ostream> writer(myfile);
// Pass it to the easy constructor and watch the content returned in that file!
curl_easy easy(writer);

// Add some option to the easy handle
easy.add<curlopt_url>("http://<your_url_here>");
easy.add<curlopt_followlocation>(1L);
try {
    // Execute the request
    easy.perform();

} catch (curl_easy_exception &amp;error) {
    // If you want to print the last error.
    std::cerr&lt;<error.what if you want to print the entire error stack can do error.print_traceback myfile.close return>

Not interested in files? So let's put the request's output in a variable!

#include 
#include 

#include "curl_easy.h" #include "curl_form.h" #include "curl_ios.h" #include "curl_exception.h"

using std::cout; using std::endl; using std::ostringstream;

using curl::curl_easy; using curl::curl_ios; using curl::curl_easy_exception; using curl::curlcpp_traceback;

int main() { // Create a stringstream object ostringstream str; // Create a curl_ios object, passing the stream object. curl_ios writer(str);

// Pass the writer to the easy constructor and watch the content returned in that variable!
curl_easy easy(writer);
// Add some option to the easy handle
easy.add<curlopt_url>("http://<your_url_here>");
easy.add<curlopt_followlocation>(1L);

try {
    easy.perform();

    // Let's print the stream content
    cout&lt;<str.str catch if you want to print the last error. std::cerr entire error stack can do error.print_traceback return>

I have implemented a sender and a receiver to make it easy to use send/receive without handling buffers. For example, a very simple send/receiver would be:

#include 
#include 

#include "curl_easy.h" #include "curl_form.h" #include "curl_pair.h" #include "curl_receiver.h" #include "curl_exception.h" #include "curl_sender.h"

using std::cout; using std::endl; using std::string;

using curl::curl_form; using curl::curl_easy; using curl::curl_sender; using curl::curl_receiver; using curl::curl_easy_exception; using curl::curlcpp_traceback;

int main(int argc, const char * argv[]) { // Simple request string request = "GET / HTTP/1.0\r\nHost: example.com\r\n\r\n"; // Creation of easy object. curl_easy easy; try { easy.add("http://"); // Just connect easy.add(true); // Execute the request. easy.perform();

} catch (curl_easy_exception &amp;error) {
    // If you want to get the entire error stack we can do:
    curlcpp_traceback errors = error.get_traceback();
    // Otherwise we could print the stack like this:
    error.print_traceback();
}

// Creation of a sender. You should wait here using select to check if socket is ready to send.
curl_sender<string> sender(easy);
sender.send(request);
// Prints che sent bytes number.
cout&lt; receiver;
        // Receive the content on the easy handler
        receiver.receive(easy);
        // Prints the received bytes number.
        cout&lt;</string></curlopt_connect_only></your_url_here></curlopt_url></string></iostream></pre></str.str></curlopt_followlocation></your_url_here></curlopt_url></ostringstream></ostream></iostream></pre></error.what></curlopt_followlocation></your_url_here></curlopt_url></ostream></fstream></ostream></iostream></pre></x.get></curlinfo_content_type></curlopt_followlocation></your_url_here></curlopt_url></ostringstream></pre></error.what></curlopt_followlocation></your_url_here></curlopt_url></pre>

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.