/* 
 
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() ] == '\0' ; 
    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"; 
?>