CURLoption type

include builtins\libcurl.e
 
function write_callback(atom pData, integer size, integer nmemb, atom pUserdata);
integer bytes_written = size*nmemb
    ... peek(pData,bytes_processed) ...
    return bytes_written
end function
constant write_cb = call_back({'+',routine_id("write_callback")})

curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb)

include builtins\libcurl.e
 
function read_callback(atom pbuffer, integer size, nmemb, atom userdata)
-- copy a maximum of isize*nmemb bytes into pbuffer
-- (you could just declare integer fn as the 4th parameter, but it can
--  also be a pointer to some allocated memory, or maybe an index, etc.)
    integer fn = userdata,
            bytes_written = 0
    for i=1 to isize*nmemb do
        integer byte = getc(fn)
        if fn=-1 then exit end if
        poke(pbuffer,byte)
        pbuffer += 1
        byte_written += 1
    end for
    printf(2, "*** We read %d bytes from file\n", bytes_written)
    return bytes_written
end function
constant read_cb = call_back({'+',routine_id("read_callback")})
 
procedure setup(string uploadthis)
    integer fn = open(uploadthis,"rb")
 
    -- set callback to use
    curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb)
 
    -- pass in suitable argument to callback
    curl_easy_setopt(curl, CURLOPT_READDATA, fn)
 
    CURLcode result = curl_easy_perform(curl)
end procedure

include builtins\libcurl.e
 
user_data = allocate_string(filename) -- (for instance)
curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, user_data)

include builtins\libcurl.e
 
user_data = allocate_string(filename) -- (for instance)
curl_easy_setopt(curl, CURLOPT_XFERINFODATA, user_data)

include builtins\libcurl.e

function curl_xferinfo_callback64(atom clientp, dltotal, dlnow, ultotal, ulnow)
--
-- On 64-bit, int64 are handled just as you might expect ...
--
    atom percentage = iff(dltotal=0?0:dlnow*100/dltotal)
    string filename = peek_string(clientp)
    sequence args = {filename, dlnow, dltotal, percentage}
    printf(1, "Downloading %s:  Current=%d   Total=%d  (%d%%)\n  ", args)
    return 0 -- signify success
end function

function curl_xferinfo_callback32(atom clientp, dltotal, dltotal_hi, dlnow, dlnow_hi,
                                                ultotal, ultotal_hi, ulnow, ulnow_hi)
--
-- ... whereas on 32-bit, parameters dltotal..ulnow are passed as int64, 
--      however call_back() grabs 32 bits at a time off the system stack, 
--      so we need to stitch them back together (if any are >32 values).
--      (No precision loss unless downloading bigger than 8000TB files!)
--
    if dltotal_hi!=0 then dltotal += dltotal_hi*#100000000 end if
    if   dlnow_hi!=0 then   dlnow +=   dlnow_hi*#100000000 end if
    if ultotal_hi!=0 then ultotal += ultotal_hi*#100000000 end if
    if   ulnow_hi!=0 then   ulnow +=   ulnow_hi*#100000000 end if

    return curl_xferinfo_callback64(clientp, dltotal, dlnow, ultotal, ulnow)
end function

constant r_xferinfo64 = routine_id("curl_xferinfo_callback64"),
         r_xferinfo32 = routine_id("curl_xferinfo_callback32"),
         r_xferinfo = iff(machine_bits()=64?r_xferinfo64:r_xferinfo32),
         xferinfo_cb = call_back({'+', r_xferinfo})

atom clientp = allocate_string(filename)
curl_easy_setopt(curl, CURLOPT_XFERINFODATA, clientp)
curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, xferinfo_cb)
curl_easy_setopt(curl, CURLOPT_NOPROGRESS,false)

include builtins\libcurl.e
 
function header_callback(atom pData, integer size, integer nmemb, atom pUserdata);
integer bytes_processed = size*nmemb
  ... peek(pData,bytes_processed) ...
  return bytes_processed
end function
constant header_cb = call_back({'+',routine_id("header_callback")})

curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, header_cb)

function debug_callback(atom curl, integer infotype, atom pData, 
                                   integer data_size, atom pUserPtr)
  ...
  return 0
end function
constant debug_cb = call_back({'+',routine_id("debug_callback")})

procedure dump(string text, integer fn, atom pData, integer data_size)
 
    printf(fn, "%s, %10.10d bytes (0x%8.8x)\n", {text, data_size, data_size})
 
    integer width=0x10
    for i=1 to data_size by width do
        printf(fn, "%4.4x: ", i)
 
        /* show hex to the left */
        for c=1 to width do
            if (i+c-1)<=data_size then
                printf(fn, "%02x ", peek(pData+i+c-1))
            else
                puts(fn,"   ")
            end if
        end for
 
        /* show data on the right */
        for c=1 to width do
            if (i+c-1)>data_size then exit end if
            integer ch = peek(pData+i+c-1)
            if ch<0x20 or ch>=0x80 then ch = '.' end if
            puts(fn, ch)
        end for
 
        puts(fn,'\n')
    end for
end procedure
 
constant stderr = 2

function debug_callback(atom /*curl*/, integer infotype, atom pData, 
                                       integer data_size, atom /*pUserPtr*/)
    string text
    switch infotype do
--      case CURLINFO_TEXT:
--          printf(stderr, "== Info: %s", {peek_string(pData)})
--          fallthrough
--      default: /* in case a new one is introduced to shock us */
--          return 0
        case CURLINFO_HEADER_OUT:   text = "=> Send header"
        case CURLINFO_DATA_OUT:     text = "=> Send data"
        case CURLINFO_SSL_DATA_OUT: text = "=> Send SSL data"
        case CURLINFO_HEADER_IN:    text = "<= Recv header"
        case CURLINFO_DATA_IN:      text = "<= Recv data"
        case CURLINFO_SSL_DATA_IN:  text = "<= Recv SSL data"
        case CURLINFO_TEXT:
            printf(stderr, "== Info: %s", {peek_string(pData)})
            fallthrough
        default: /* in case a new one is introduced to shock us */
            return 0
    end switch
    dump(text, stderr, pData, data_size)
    return 0
end function
constant debug_cb = call_back({'+',routine_id("debug_callback")})

atom curl = curl_easy_init()

curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, debug_cb)
 
/* the DEBUGFUNCTION has no effect until we enable VERBOSE */
curl_easy_setopt(curl, CURLOPT_VERBOSE, true)
 
/* example.com is redirected, so we tell libcurl to follow redirection */
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, true)
 
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com/")
integer res = curl_easy_perform(curl)
/* Check for errors */
if res!=CURLE_OK then
    printf(stderr, "curl_easy_perform() failed: %s\n",{curl_easy_strerror(res)})
end if
 
/* always cleanup */
curl_easy_cleanup(curl)

atom pErrorBuffer = allocate(CURL_ERROR_SIZE)
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, pErrorBuffer)
...
curl_easy_cleanup(curl)
free(pErrorBuffer)

atom curl = curl_easy_init()
curl_easy_setopt(curl, CURLOPT_URL, "https://example.com/")
curl_easy_setopt(curl, CURLOPT_FAILONERROR, true)
CURLcode ret = curl_easy_perform(curl)
if ret=CURLE_HTTP_RETURNED_ERROR then
    /* a HTTP response error problem */
end if

atom curl = curl_easy_init()
curl_easy_setopt(curl, CURLOPT_URL, "https://example.com/")
/* example.com is redirected, so we tell libcurl to follow redirection */
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, true)
CURLcode ret = curl_easy_perform(curl)

atom curl = curl_easy_init()
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com/foo.bin")
curl_easy_setopt(curl, CURLOPT_POST, true)
 
/* set up the read callback with CURLOPT_READFUNCTION */
 
ret = curl_easy_perform(curl)
 
curl_easy_cleanup(curl)

atom curl = curl_easy_init()
string data = "data to send"
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com");
/* size of the POST data */
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, length(data))
/* pass in a pointer to the data - libcurl will not copy */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data)
curl_easy_perform(curl)

atom curl = curl_easy_init()
string data = "data to send"
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com")
/* size of the POST data */
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, length(data)) 
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data)
curl_easy_perform(curl)

atom curl = curl_easy_init()
atom pData = large_chunk    -- (or string)
atom length_of_data         -- set somehow
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com")
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE, length_of_data)
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, pData)
curl_easy_perform(curl)

atom curl = curl_easy_init()
string buffer = "data to send"
atom length_of_data = length(buffer)
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com")
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, length_of_data)
curl_easy_setopt(curl, CURLOPT_COPYPOSTFIELDS, pData)
curl_easy_perform(curl)

atom curl = curl_easy_init()
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com")
curl_easy_setopt(curl, CURLOPT_USERAGENT, "Dark Secret Ninja/1.0")
curl_easy_perform(curl)

atom curl = curl_easy_init()
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com")
atom headers = NULL
headers = curl_slist_append(headers, "Shoesize: 10")
headers = curl_slist_append(headers, "Accept:")
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers)

curl_easy_perform(curl)
 
/* always cleanup */
curl_easy_cleanup(curl)
curl_slist_free_all(headers)

include builtins\libcurl.e
 
atom curl = curl_easy_init()
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com/foo.bin")

-- get cookies from an existing file
curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "/tmp/cookies.txt")

object ret = curl_easy_perform(curl)
curl_easy_cleanup(curl)

atom curl = curl_easy_init()
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com/foo.bin")
 
/* export cookies to this file when closing the handle */
curl_easy_setopt(curl, CURLOPT_COOKIEJAR, "/tmp/cookies.txt");
 
ret = curl_easy_perform(curl)
 
/* close the handle, write the cookies! */
curl_easy_cleanup(curl)

/* This example shows an inline import of a cookie in Netscape format.
You can set the cookie as HttpOnly to prevent XSS attacks by prepending
#HttpOnly_ to the hostname. That may be useful if the cookie will later
be imported by a browser.
*/
 
string my_cookie = "example.com\tFALSE\t/\tFALSE\t0\tfoo\tbar"
                -- Hostname = example.com,
                -- Include subdomains = FALSE,
                -- Path = \,
                -- Secure = FALSE,
                -- Expiry = 0, (==Session)
                -- Name = foo,
                -- Value = bar

/* my_cookie is imported immediately via CURLOPT_COOKIELIST. */
curl_easy_setopt(curl, CURLOPT_COOKIELIST, my_cookie)
 
/* The list of cookies in cookies.txt will not be imported until right
before a transfer is performed. Cookies in the list that have the same
hostname, path and name as in my_cookie are skipped. That is because
libcurl has already imported my_cookie and it's considered a "live"
cookie. A live cookie won't be replaced by one read from a file.
*/
curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "cookies.txt")   /* import */
 
/* Cookies are exported after curl_easy_cleanup is called. The server
may have added, deleted or modified cookies by then. The cookies that
were skipped on import are not exported.
*/
curl_easy_setopt(curl, CURLOPT_COOKIEJAR, "cookies.txt")  /* export */
 
curl_easy_perform(curl)  /* cookies imported from cookies.txt */
 
curl_easy_cleanup(curl)  /* cookies exported to cookies.txt */

curl = curl_easy_init()
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com")
 
/* use a GET to fetch this */
curl_easy_setopt(curl, CURLOPT_HTTPGET, true)
 
/* Perform the request */
curl_easy_perform(curl)

atom curl = curl_easy_init(),
     list = NULL
list = curl_slist_append(list, "root@localhost")
list = curl_slist_append(list, "person@example.com");
curl_easy_setopt(curl, CURLOPT_URL, "smtp://example.com/");
curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, list);
integer ret = curl_easy_perform(curl)
curl_slist_free_all(list)
curl_easy_cleanup(curl)

atom curl = curl_easy_init()
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com/foo.bin")
/* DELETE the given path */
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
ret = curl_easy_perform(curl)
curl_easy_cleanup(curl)

atom curl = curl_easy_init()
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com/foo.bin")
/* DELETE the given path */
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
ret = curl_easy_perform(curl)
curl_easy_cleanup(curl)

atom curl = curl_easy_init()
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com/foo.bin")
/* DELETE the given path */
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
ret = curl_easy_perform(curl)
curl_easy_cleanup(curl)

atom curl = curl_easy_init()
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com/foo.bin")
/* DELETE the given path */
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
ret = curl_easy_perform(curl)
curl_easy_cleanup(curl)

atom curl = curl_easy_init()
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com")
curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, true)
CURLcode ret = curl_easy_perform(curl);
if ret=CURLE_OK then
    /* only connected! */
end if

atom hosts = NULL
hosts = curl_slist_append(hosts, "example.com:80:127.0.0.1")
 
atom curl = curl_easy_init()
curl_easy_setopt(curl, CURLOPT_RESOLVE, hosts)
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com")
 
/* always cleanup */
curl_easy_cleanup(curl)

curl_slist_free_all(hosts)

atom curl = curl_easy_init()
atom private = NULL

curl_easy_setopt(curl, CURLOPT_URL, "http://example.com")
 
/* store a pointer to our private struct */
curl_easy_setopt(curl, CURLOPT_PRIVATE, private)
 
atom res = curl_easy_perform(curl)
 
/* we can extract the private pointer again too */
{res,private} = curl_easy_getinfo(curl, CURLINFO_PRIVATE)

/* always cleanup */
curl_easy_cleanup(curl)

atom curl = curl_easy_init()
atom curl2 = curl_easy_init() /* a second handle */
atom shobject = curl_share_init()
curl_share_setopt(shobject, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE)

curl_easy_setopt(curl, CURLOPT_URL, "https://example.com/")
curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "")
curl_easy_setopt(curl, CURLOPT_SHARE, shobject)
integer res = curl_easy_perform(curl)
curl_easy_cleanup(curl)

/* the second handle shares cookies from the first */
curl_easy_setopt(curl2, CURLOPT_URL, "https://example.com/second")
curl_easy_setopt(curl2, CURLOPT_COOKIEFILE, "")
curl_easy_setopt(curl2, CURLOPT_SHARE, shobject)
res = curl_easy_perform(curl2)
curl_easy_cleanup(curl2)

curl_share_cleanup(shobject)