Curl이란?

/*

sample for O'ReillyNet article on libcURL:
    {TITLE}
    {URL}
    AUTHOR: Ethan McCallum

anon ftp/download (scenario: fetch remote file)

이 코드는 Ubuntu 리눅스 Kernel 2.6.15에서
libcURL 버젼 7.15.1로 테스트 되었다.
2006년 8월 3일

*/

#include<iostream>
#include<string>
#include<sstream>
#include<list>

extern "C" {
    #include<curl/curl.h>
}

// - - - - - - - - - - - - - - - - - - - -

typedef std::list< std::string > FileList ;

enum {
    ERROR_ARGS = 1 ,
    ERROR_CURL_INIT = 2
} ;

enum {
    OPTION_FALSE = 0 ,
    OPTION_TRUE = 1
} ;

// - - - - - - - - - - - - - - - - - - - -

// 콜백함수에서 사용할 사용자 정의 객체 
class XferInfo {

    private:
    int bytesTransferred_ ;
    int invocations_ ;

    protected:
    // empty

    public:
    XferInfo(){

        reset() ;

    } // ctor

    /// reset counters
    void reset(){

        bytesTransferred_ = 0 ;
        invocations_ = 0 ;

        return ;

    } // reset()

    /// add the number of bytes transferred in this call
    void add( int more ){

        bytesTransferred_ += more ;
        ++invocations_ ;

        return ;

    } // add()    

    /// get the amount of data transferred, in bytes
    int getBytesTransferred() const {
        return( bytesTransferred_ ) ;
    } // getBytesTransferred()

    /// get the number of times add() has been called
    int getTimesCalled(){
        return( invocations_ ) ;
    } // getTimesCalled()
} ;

// - - - - - - - - - - - - - - - - - - - -

// C++ 에서 C함수를 링크시키기 위해서는, "extern C"를 이용해야 한다.
extern "C"
size_t showSize( void *source , size_t size , size_t nmemb , void *userData ){

    // this function may be called any number of times for even a single
    // transfer; be sure to write it accordingly.

    // source is the actual data fetched by libcURL; cast it to whatever
    // type you need (usually char*).  It has NO terminating NULL byte.

    // we don't touch the data here, so the cast is commented out
    // const char* data = static_cast< const char* >( source ) ;

    // userData is called "stream" in the docs, which is misleading:
    // that parameter can be _any_ data type, not necessarily a FILE*
    // Here, we use it to save state between calls to this function
    // and track number of times this callback is invoked.
    XferInfo* info = static_cast< XferInfo* >( userData ) ;

    const int bufferSize = size * nmemb ;

    std::cout << 't' << "showSize() called: " << bufferSize << " bytes passed" << std::endl ;

    // ... pretend real data processing on *source happens here ...

    info->add( bufferSize ) ;

    /*
    return some number less than bufferSize to indicate an
    error (xfer abort)

    nicer code would also set a status var (in userData) for the
    calling function
    */

    return( bufferSize ) ;

} // showSize()

// - - - - - - - - - - - - - - - - - - - -

int main( const int argc , const char** argv ){

    if( argc < 3 ){
        std::cerr << "test of libcURL: anonymous FTP" << std::endl ;
        std::cerr << " Usage: " << argv[0] << " {server} {file1} [{file2} ...]" << std::endl ;
        return( ERROR_ARGS ) ;
    }

    // remote FTP server
    const char* server = argv[1] ;

    const int totalTargets = argc - 2 ;

    std::cout << "Attempting to download " << totalTargets
        << " files from " << server << std::endl
    ;

    curl_global_init( CURL_GLOBAL_ALL ) ;

    CURL* ctx = curl_easy_init() ;

    if( NULL == ctx ){
        std::cerr << "Unable to initialize cURL interface" << std::endl ;
        return( ERROR_CURL_INIT ) ;
    }

    /* BEGIN: global handle options */

    // handy for debugging: see *everything* that goes on
    // curl_easy_setopt( ctx , CURLOPT_VERBOSE, OPTION_TRUE ) ;

    // no progress bar:
    curl_easy_setopt( ctx , CURLOPT_NOPROGRESS , OPTION_TRUE ) ;

    // what to do with returned data
    curl_easy_setopt( ctx , CURLOPT_WRITEFUNCTION , showSize ) ;

    XferInfo info ;

    for(
        int ix = 2 ;
        ix < argc ;
        ++ix
    ){

        const char* item = argv[ ix ] ;

        // zero counters for each file
        info.reset() ;

        // target url: concatenate the server and target file name
        urlBuffer.str( "" ) ;
        urlBuffer << "ftp://" << server << "/" << item << std::flush ;

        std::cout << "Trying " << urlBuffer.str() << std::endl ;

        const std::string url = urlBuffer.str() ;

        curl_easy_setopt( ctx , CURLOPT_URL,  url.c_str() ) ;

        // set the write function's user-data (state data)
        curl_easy_setopt( ctx , CURLOPT_WRITEDATA , &info ) ;

        // action!

        const CURLcode rc = curl_easy_perform( ctx ) ;

        // for curl v7.11.x and earlier, look into
        // curl_easy_setopt( ctx , CURLOPT_ERRORBUFFER , /* char array */ ) ;
        if( CURLE_OK == rc ){
            std::cout << 't' << "xfer size: " << info.getBytesTransferred() << " bytes" << std::endl ;
            std::cout << 't' << "Callback was invoked " << info.getTimesCalled() << " times for this file" << std::endl ;
        } else {
            std::cerr << "Error from cURL: " << curl_easy_strerror( rc ) << std::endl ;
        }

        std::cout << std::endl ;

    }

    // cleanup
    curl_easy_cleanup( ctx ) ;
    curl_global_cleanup() ;

    return( 0 ) ;

} // main()

ftp://host/file

login:password

ftp://login:password@host/file

struct curl_slist *command=NULL;
command = curl_slist_append( commands, "mkdir /some/path");
command = curl_slist_append( commands, "mkdir /another/path");

curl_easy_setopt(ctx, CURLPOST_QUOTE, commands);
// curl_easy_perform을 이용해서 ftp 세션을 시작하고
// 명령을 실행한다.
curl_slist_free_all(command);

const char* postData="param1=value1¶m2=value2&...";

curl_easy_setopt(ctx, CURLOPT_POSTFIELDS, postData);

curl_sist * responseHeaders=NULL;

responseHeaders = curl_slist_append(
    responseHeaders,
    "Expect: 100-continue"
);

curl_easy_setopt(ctx, CURLOPT_HTTPHEADER, responseHeaders);

/*

sample for O'ReillyNet article on libcURL:
    {TITLE}
    {URL}
    AUTHOR: Ethan McCallum

HTTP POST (e.g. form processing or REST web services)

이 코드는 Ubuntu 6.06 Dapper Drake,  
libcURL
This code was built/tested under Fedora Core 3,
libcURL version 7.12.3 환경에서 테스트 되었다.
*/

#include<cstdio>
#include<iostream>
#include<string>
#include<sstream>

extern "C" {
    #include<curl/curl.h>
}

// - - - - - - - - - - - - - - - - - - - -

enum {
    ERROR_ARGS = 1 ,
    ERROR_CURL_INIT = 2
} ;

enum {
    OPTION_FALSE = 0 ,
    OPTION_TRUE = 1
} ;

enum {
    FLAG_DEFAULT = 0 
} ;

const char* targetUrl ;

// - - - - - - - - - - - - - - - - - - - -

int main( int argc , char** argv ){

    if( argc != 2 ){
        std::cerr << "test of libcURL: test an HTTP post" << std::endl ;
        std::cerr << "(post data is canned)" << std::endl ;
        std::cerr << " Usage: " << argv[0] << " {post url}" << std::endl ;
        std::exit( ERROR_ARGS ) ;
    }

    targetUrl = argv[1] ;

    curl_global_init( CURL_GLOBAL_ALL ) ;

    CURL* ctx = curl_easy_init() ;

    if( NULL == ctx ){
        std::cerr << "Unable to initialize cURL interface" << std::endl ;
        return( ERROR_CURL_INIT ) ;
    }

    /* BEGIN: configure the handle: */

    // Target URL: 
    curl_easy_setopt( ctx , CURLOPT_URL,  targetUrl ) ;
    // no progress bar:
    curl_easy_setopt( ctx , CURLOPT_NOPROGRESS , OPTION_TRUE ) ;

    // 응답데이터를 표준출력으로 보낸다. 
    curl_easy_setopt( ctx , CURLOPT_WRITEDATA , stdout ) ;

    // 사용자 정의 HTTP 헤더: create a linked list and assign
    curl_slist* responseHeaders = NULL ;
    responseHeaders = curl_slist_append( responseHeaders , "Expect: 100-continue" ) ;
    responseHeaders = curl_slist_append( responseHeaders , "User-Agent: Some Custom App" ) ;
    curl_easy_setopt( ctx , CURLOPT_HTTPHEADER , responseHeaders ) ;

    // POST Data 설정 
    // notice the URL-unfriendly characters (such as "%" and "&")
    // URL에서는 '%', '&', ' '와 같은 문자를 URL encoding 시켜줘야 한다.
    // curl_escape 함수를 이용해서 인코딩할 수 있다. 
    const char* postParams[] = {
        "One"      , "this has % and & symbols" ,
        "Dos"      , "value with spaces" ,
        "Trois"    , "plus+signs+will+be+escaped" ,
        "Chetirye" , "fourth param..." ,
        NULL
    } ; 

    // buffer for the POST params
    std::ostringstream postBuf ;

    const char** postParamsPtr = postParams ;

    while( NULL != *postParamsPtr )
    {
        // curl_escape( {string} , 0 ): replace special characters
        // (such as space, "&", "+", "%") with HTML entities.
        // ( 0 => "use strlen to find string length" )
        // remember to call curl_free() on the strings on the way out
        char* key = curl_escape( postParamsPtr[0] , FLAG_DEFAULT ) ;
        char* val = curl_escape( postParamsPtr[1] , FLAG_DEFAULT )  ;

        std::cout << "Setting POST param: "" << key << "" => "" << val << """ << std::endl ;
        postBuf << key << "=" << val << "&" ;

        postParamsPtr += 2 ;

        // the cURL lib allocated the escaped versions of the
        // param strings; we must free them here
        curl_free( key ) ;
        curl_free( val ) ;

    }
    postBuf << std::flush ;

    // We can't really call "postBuf.str().c_str()" here, because
    // the std::string created in the middle is a temporary.  In turn,
    // the char* buf from its c_str() operation isn't guaranteed to
    // be around after the function call.
    // The solution: explicitly create the string.

    // Larger (and/or better) code would use std::string::copy() to create
    // a const char* pointer to pass to cURL, then clean it up later.
    // e.g.:
    //    const char* postData = new char*[ 1 + postBuf.tellg() ] ;
    //     postBuf.str().copy( postData , std::string::npos ) ;
    //  postData[ postBuf.tellg() ] == '' ;
    const std::string postData = postBuf.str() ;

    std::cout << "post data: " << postData << std::endl ;
    curl_easy_setopt( ctx , CURLOPT_POSTFIELDS , postData.c_str() ) ;

    // do a standard HTTP POST op
    // in theory, this is automatically set for us by setting
    // CURLOPT_POSTFIELDS...
    curl_easy_setopt( ctx , CURLOPT_POST , OPTION_TRUE ) ;

    /* END: configure the handle */
    // action!
    std::cout << "- - - BEGIN: response - - -" << std::endl ;
    CURLcode rc = curl_easy_perform( ctx ) ;
    std::cout << "- - - END: response - - -" << std::endl ;

    // "curl_easy_strerror()" available in curl v7.12.x and later
    if( CURLE_OK != rc ){
        std::cerr << 't' << "Error from cURL: " << curl_easy_strerror( rc ) << std::endl ;
    }

    // cleanup
    curl_slist_free_all( responseHeaders ) ;
    curl_easy_cleanup( ctx ) ;
    curl_global_cleanup() ;
    std::exit( 0 ) ;
} // main()

<?
    echo "SERVER Ons      : $One<br>n";
    echo "SERVER Dos      : $Dos<br>n";
    echo "SERVER Trois    : $Trois<br>n";
    echo "SERVER Chetirye : $Chetirye<br>n";
?>