return n * l;
}
-static void add_transfer(CURLM *cm, unsigned int i, int *left)
+static void add_transfer(CURLM *multi, unsigned int i, int *left)
{
- CURL *eh = curl_easy_init();
- if(eh) {
- curl_easy_setopt(eh, CURLOPT_WRITEFUNCTION, write_cb);
- curl_easy_setopt(eh, CURLOPT_URL, urls[i]);
- curl_easy_setopt(eh, CURLOPT_PRIVATE, urls[i]);
- curl_multi_add_handle(cm, eh);
+ CURL *curl = curl_easy_init();
+ if(curl) {
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
+ curl_easy_setopt(curl, CURLOPT_URL, urls[i]);
+ curl_easy_setopt(curl, CURLOPT_PRIVATE, urls[i]);
+ curl_multi_add_handle(multi, curl);
}
(*left)++;
}
int main(void)
{
- CURLM *cm;
+ CURLM *multi;
CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
if(res)
return (int)res;
- cm = curl_multi_init();
- if(cm) {
+ multi = curl_multi_init();
+ if(multi) {
CURLMsg *msg;
unsigned int transfers = 0;
int msgs_left = -1;
int left = 0;
/* Limit the amount of simultaneous connections curl should allow: */
- curl_multi_setopt(cm, CURLMOPT_MAXCONNECTS, (long)MAX_PARALLEL);
+ curl_multi_setopt(multi, CURLMOPT_MAXCONNECTS, (long)MAX_PARALLEL);
for(transfers = 0; transfers < MAX_PARALLEL && transfers < NUM_URLS;
transfers++)
- add_transfer(cm, transfers, &left);
+ add_transfer(multi, transfers, &left);
do {
int still_alive = 1;
- curl_multi_perform(cm, &still_alive);
+ curl_multi_perform(multi, &still_alive);
/* !checksrc! disable EQUALSNULL 1 */
- while((msg = curl_multi_info_read(cm, &msgs_left)) != NULL) {
+ while((msg = curl_multi_info_read(multi, &msgs_left)) != NULL) {
if(msg->msg == CURLMSG_DONE) {
char *url;
- CURL *e = msg->easy_handle;
- curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, &url);
+ CURL *curl = msg->easy_handle;
+ curl_easy_getinfo(curl, CURLINFO_PRIVATE, &url);
fprintf(stderr, "R: %d - %s <%s>\n",
msg->data.result, curl_easy_strerror(msg->data.result), url);
- curl_multi_remove_handle(cm, e);
- curl_easy_cleanup(e);
+ curl_multi_remove_handle(multi, curl);
+ curl_easy_cleanup(curl);
left--;
}
else {
fprintf(stderr, "E: CURLMsg (%d)\n", msg->msg);
}
if(transfers < NUM_URLS)
- add_transfer(cm, transfers++, &left);
+ add_transfer(multi, transfers++, &left);
}
if(left)
- curl_multi_wait(cm, NULL, 0, 1000, NULL);
+ curl_multi_wait(multi, NULL, 0, 1000, NULL);
} while(left);
- curl_multi_cleanup(cm);
+ curl_multi_cleanup(multi);
}
curl_global_cleanup();
}
/* read callback function, fread() look alike */
-static size_t read_callback(char *ptr, size_t size, size_t nmemb, void *stream)
+static size_t read_cb(char *ptr, size_t size, size_t nmemb, void *stream)
{
size_t nread;
curl = curl_easy_init();
if(curl) {
/* we want to use our own read function */
- curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);
/* which file to upload */
curl_easy_setopt(curl, CURLOPT_READDATA, (void *) fp);
typedef int ossl_valsize_t;
#endif
-static size_t writefunction(void *ptr, size_t size, size_t nmemb, void *stream)
+static size_t write_cb(void *ptr, size_t size, size_t nmemb, void *stream)
{
fwrite(ptr, size, nmemb, (FILE *)stream);
return nmemb * size;
int main(void)
{
- CURL *ch;
+ CURL *curl;
CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
if(res)
return (int)res;
- ch = curl_easy_init();
- if(ch) {
- curl_easy_setopt(ch, CURLOPT_VERBOSE, 0L);
- curl_easy_setopt(ch, CURLOPT_HEADER, 0L);
- curl_easy_setopt(ch, CURLOPT_NOPROGRESS, 1L);
- curl_easy_setopt(ch, CURLOPT_NOSIGNAL, 1L);
- curl_easy_setopt(ch, CURLOPT_WRITEFUNCTION, writefunction);
- curl_easy_setopt(ch, CURLOPT_WRITEDATA, stdout);
- curl_easy_setopt(ch, CURLOPT_HEADERFUNCTION, writefunction);
- curl_easy_setopt(ch, CURLOPT_HEADERDATA, stderr);
- curl_easy_setopt(ch, CURLOPT_SSLCERTTYPE, "PEM");
- curl_easy_setopt(ch, CURLOPT_SSL_VERIFYPEER, 1L);
- curl_easy_setopt(ch, CURLOPT_URL, "https://www.example.com/");
+ curl = curl_easy_init();
+ if(curl) {
+ curl_easy_setopt(curl, CURLOPT_VERBOSE, 0L);
+ curl_easy_setopt(curl, CURLOPT_HEADER, 0L);
+ curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
+ curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, stdout);
+ curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, write_cb);
+ curl_easy_setopt(curl, CURLOPT_HEADERDATA, stderr);
+ curl_easy_setopt(curl, CURLOPT_SSLCERTTYPE, "PEM");
+ curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);
+ curl_easy_setopt(curl, CURLOPT_URL, "https://www.example.com/");
/* Turn off the default CA locations, otherwise libcurl loads CA
* certificates from the locations that were detected/specified at
* build-time
*/
- curl_easy_setopt(ch, CURLOPT_CAINFO, NULL);
- curl_easy_setopt(ch, CURLOPT_CAPATH, NULL);
+ curl_easy_setopt(curl, CURLOPT_CAINFO, NULL);
+ curl_easy_setopt(curl, CURLOPT_CAPATH, NULL);
/* first try: retrieve page without ca certificates -> should fail
* unless libcurl was built --with-ca-fallback enabled at build-time
*/
- res = curl_easy_perform(ch);
+ res = curl_easy_perform(curl);
if(res == CURLE_OK)
printf("*** transfer succeeded ***\n");
else
* performance of multiple transfers but it is necessary order to
* demonstrate this example. recall that the ssl ctx callback is only
* called _before_ an SSL connection is established, therefore it does not
- * affect existing verified SSL connections already in the connection cache
- * associated with this handle. normally you would set the ssl ctx function
- * before making any transfers, and not use this option.
+ * affect existing verified SSL connections already in the connection
+ * cache associated with this handle. normally you would set the ssl ctx
+ * function before making any transfers, and not use this option.
*/
- curl_easy_setopt(ch, CURLOPT_FRESH_CONNECT, 1L);
+ curl_easy_setopt(curl, CURLOPT_FRESH_CONNECT, 1L);
- /* second try: retrieve page using cacerts' certificate -> succeeds to load
- * the certificate by installing a function doing the necessary
+ /* second try: retrieve page using cacerts' certificate -> succeeds to
+ * load the certificate by installing a function doing the necessary
* "modifications" to the SSL CONTEXT just before link init
*/
- curl_easy_setopt(ch, CURLOPT_SSL_CTX_FUNCTION, sslctx_function);
- res = curl_easy_perform(ch);
+ curl_easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION, sslctx_function);
+ res = curl_easy_perform(curl);
if(res == CURLE_OK)
printf("*** transfer succeeded ***\n");
else
printf("*** transfer failed ***\n");
- curl_easy_cleanup(ch);
+ curl_easy_cleanup(curl);
}
curl_global_cleanup();
return (int)res;
#include <curl/curl.h>
-static size_t wrfu(void *ptr, size_t size, size_t nmemb, void *stream)
+static size_t write_cb(void *ptr, size_t size, size_t nmemb, void *stream)
{
(void)stream;
(void)ptr;
if(curl) {
curl_easy_setopt(curl, CURLOPT_URL, "https://www.example.com/");
- curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, wrfu);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
#define CHKSPEED_VERSION "1.0"
-static size_t WriteCallback(void *ptr, size_t size, size_t nmemb, void *data)
+static size_t write_cb(void *ptr, size_t size, size_t nmemb, void *data)
{
/* we are not interested in the downloaded bytes itself,
so we only return the size we would have saved ... */
int main(int argc, char *argv[])
{
- CURL *curl_handle;
+ CURL *curl;
CURLcode res;
int prtall = 0, prtsep = 0, prttime = 0;
const char *url = URL_1M;
return (int)res;
/* init the curl session */
- curl_handle = curl_easy_init();
- if(curl_handle) {
+ curl = curl_easy_init();
+ if(curl) {
/* specify URL to get */
- curl_easy_setopt(curl_handle, CURLOPT_URL, url);
+ curl_easy_setopt(curl, CURLOPT_URL, url);
/* send all data to this function */
- curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, WriteCallback);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
/* some servers do not like requests that are made without a user-agent
field, so we provide one */
- curl_easy_setopt(curl_handle, CURLOPT_USERAGENT,
+ curl_easy_setopt(curl, CURLOPT_USERAGENT,
"libcurl-speedchecker/" CHKSPEED_VERSION);
/* get it! */
- res = curl_easy_perform(curl_handle);
+ res = curl_easy_perform(curl);
if(CURLE_OK == res) {
curl_off_t val;
/* check for bytes downloaded */
- res = curl_easy_getinfo(curl_handle, CURLINFO_SIZE_DOWNLOAD_T, &val);
+ res = curl_easy_getinfo(curl, CURLINFO_SIZE_DOWNLOAD_T, &val);
if((CURLE_OK == res) && (val > 0))
printf("Data downloaded: %" CURL_FORMAT_CURL_OFF_T " bytes.\n", val);
/* check for total download time */
- res = curl_easy_getinfo(curl_handle, CURLINFO_TOTAL_TIME_T, &val);
+ res = curl_easy_getinfo(curl, CURLINFO_TOTAL_TIME_T, &val);
if((CURLE_OK == res) && (val > 0))
printf("Total download time: %" CURL_FORMAT_CURL_OFF_T
".%06" CURL_FORMAT_CURL_OFF_T " sec.\n",
val % 1000000);
/* check for average download speed */
- res = curl_easy_getinfo(curl_handle, CURLINFO_SPEED_DOWNLOAD_T, &val);
+ res = curl_easy_getinfo(curl, CURLINFO_SPEED_DOWNLOAD_T, &val);
if((CURLE_OK == res) && (val > 0))
printf("Average download speed: "
"%" CURL_FORMAT_CURL_OFF_T " kbyte/sec.\n",
if(prtall) {
/* check for name resolution time */
- res = curl_easy_getinfo(curl_handle, CURLINFO_NAMELOOKUP_TIME_T, &val);
+ res = curl_easy_getinfo(curl, CURLINFO_NAMELOOKUP_TIME_T, &val);
if((CURLE_OK == res) && (val > 0))
printf("Name lookup time: %" CURL_FORMAT_CURL_OFF_T
".%06" CURL_FORMAT_CURL_OFF_T " sec.\n",
val % 1000000);
/* check for connect time */
- res = curl_easy_getinfo(curl_handle, CURLINFO_CONNECT_TIME_T, &val);
+ res = curl_easy_getinfo(curl, CURLINFO_CONNECT_TIME_T, &val);
if((CURLE_OK == res) && (val > 0))
printf("Connect time: %" CURL_FORMAT_CURL_OFF_T
".%06" CURL_FORMAT_CURL_OFF_T " sec.\n",
}
/* cleanup curl stuff */
- curl_easy_cleanup(curl_handle);
+ curl_easy_cleanup(curl);
}
/* we are done with libcurl, so clean it up */
size_t size;
};
-static size_t grow_buffer(void *contents, size_t sz, size_t nmemb, void *ctx)
+static size_t write_cb(void *contents, size_t sz, size_t nmemb, void *ctx)
{
size_t realsize = sz * nmemb;
struct memory *mem = (struct memory*) ctx;
static CURL *make_handle(const char *url)
{
- CURL *handle = curl_easy_init();
+ CURL *curl = curl_easy_init();
struct memory *mem;
/* Important: use HTTP2 over HTTPS */
- curl_easy_setopt(handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2TLS);
- curl_easy_setopt(handle, CURLOPT_URL, url);
+ curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2TLS);
+ curl_easy_setopt(curl, CURLOPT_URL, url);
/* buffer body */
mem = malloc(sizeof(*mem));
mem->size = 0;
mem->buf = malloc(1);
- curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, grow_buffer);
- curl_easy_setopt(handle, CURLOPT_WRITEDATA, mem);
- curl_easy_setopt(handle, CURLOPT_PRIVATE, mem);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, mem);
+ curl_easy_setopt(curl, CURLOPT_PRIVATE, mem);
/* For completeness */
- curl_easy_setopt(handle, CURLOPT_ACCEPT_ENCODING, "");
- curl_easy_setopt(handle, CURLOPT_TIMEOUT, 5L);
- curl_easy_setopt(handle, CURLOPT_FOLLOWLOCATION, 1L);
+ curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, "");
+ curl_easy_setopt(curl, CURLOPT_TIMEOUT, 5L);
+ curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
/* only allow redirects to HTTP and HTTPS URLs */
- curl_easy_setopt(handle, CURLOPT_REDIR_PROTOCOLS_STR, "http,https");
- curl_easy_setopt(handle, CURLOPT_AUTOREFERER, 1L);
- curl_easy_setopt(handle, CURLOPT_MAXREDIRS, 10L);
+ curl_easy_setopt(curl, CURLOPT_REDIR_PROTOCOLS_STR, "http,https");
+ curl_easy_setopt(curl, CURLOPT_AUTOREFERER, 1L);
+ curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 10L);
/* each transfer needs to be done within 20 seconds! */
- curl_easy_setopt(handle, CURLOPT_TIMEOUT_MS, 20000L);
+ curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, 20000L);
/* connect fast or fail */
- curl_easy_setopt(handle, CURLOPT_CONNECTTIMEOUT_MS, 2000L);
+ curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT_MS, 2000L);
/* skip files larger than a gigabyte */
- curl_easy_setopt(handle, CURLOPT_MAXFILESIZE_LARGE,
+ curl_easy_setopt(curl, CURLOPT_MAXFILESIZE_LARGE,
(curl_off_t)1024*1024*1024);
- curl_easy_setopt(handle, CURLOPT_COOKIEFILE, "");
- curl_easy_setopt(handle, CURLOPT_FILETIME, 1L);
- curl_easy_setopt(handle, CURLOPT_USERAGENT, "mini crawler");
- curl_easy_setopt(handle, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
- curl_easy_setopt(handle, CURLOPT_UNRESTRICTED_AUTH, 1L);
- curl_easy_setopt(handle, CURLOPT_PROXYAUTH, CURLAUTH_ANY);
- curl_easy_setopt(handle, CURLOPT_EXPECT_100_TIMEOUT_MS, 0L);
- return handle;
+ curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "");
+ curl_easy_setopt(curl, CURLOPT_FILETIME, 1L);
+ curl_easy_setopt(curl, CURLOPT_USERAGENT, "mini crawler");
+ curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
+ curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1L);
+ curl_easy_setopt(curl, CURLOPT_PROXYAUTH, CURLAUTH_ANY);
+ curl_easy_setopt(curl, CURLOPT_EXPECT_100_TIMEOUT_MS, 0L);
+ return curl;
}
/* HREF finder implemented in libxml2 but could be any HTML parser */
-static size_t follow_links(CURLM *multi_handle, struct memory *mem,
+static size_t follow_links(CURLM *multi, struct memory *mem,
const char *url)
{
int opts = HTML_PARSE_NOBLANKS | HTML_PARSE_NOERROR | \
if(!link || strlen(link) < 20)
continue;
if(!strncmp(link, "http://", 7) || !strncmp(link, "https://", 8)) {
- curl_multi_add_handle(multi_handle, make_handle(link));
+ curl_multi_add_handle(multi, make_handle(link));
if(count++ == max_link_per_page)
break;
}
int main(void)
{
- CURLM *multi_handle;
+ CURLM *multi;
int msgs_left;
int pending;
int complete;
signal(SIGINT, sighandler);
LIBXML_TEST_VERSION
- multi_handle = curl_multi_init();
- if(multi_handle) {
- curl_multi_setopt(multi_handle, CURLMOPT_MAX_TOTAL_CONNECTIONS, max_con);
- curl_multi_setopt(multi_handle, CURLMOPT_MAX_HOST_CONNECTIONS, 6L);
+ multi = curl_multi_init();
+ if(multi) {
+ curl_multi_setopt(multi, CURLMOPT_MAX_TOTAL_CONNECTIONS, max_con);
+ curl_multi_setopt(multi, CURLMOPT_MAX_HOST_CONNECTIONS, 6L);
/* enables http/2 if available */
#ifdef CURLPIPE_MULTIPLEX
- curl_multi_setopt(multi_handle, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
+ curl_multi_setopt(multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
#endif
/* sets html start page */
- curl_multi_add_handle(multi_handle, make_handle(start_page));
+ curl_multi_add_handle(multi, make_handle(start_page));
pending = 0;
complete = 0;
int numfds;
CURLMsg *m;
- curl_multi_wait(multi_handle, NULL, 0, 1000, &numfds);
- curl_multi_perform(multi_handle, &still_running);
+ curl_multi_wait(multi, NULL, 0, 1000, &numfds);
+ curl_multi_perform(multi, &still_running);
/* See how the transfers went */
m = NULL;
- while((m = curl_multi_info_read(multi_handle, &msgs_left))) {
+ while((m = curl_multi_info_read(multi, &msgs_left))) {
if(m->msg == CURLMSG_DONE) {
- CURL *handle = m->easy_handle;
+ CURL *curl = m->easy_handle;
char *url;
struct memory *mem;
- curl_easy_getinfo(handle, CURLINFO_PRIVATE, &mem);
- curl_easy_getinfo(handle, CURLINFO_EFFECTIVE_URL, &url);
+ curl_easy_getinfo(curl, CURLINFO_PRIVATE, &mem);
+ curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &url);
if(m->data.result == CURLE_OK) {
long res_status;
- curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &res_status);
+ curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &res_status);
if(res_status == 200) {
char *ctype;
- curl_easy_getinfo(handle, CURLINFO_CONTENT_TYPE, &ctype);
+ curl_easy_getinfo(curl, CURLINFO_CONTENT_TYPE, &ctype);
printf("[%d] HTTP 200 (%s): %s\n", complete, ctype, url);
if(is_html(ctype) && mem->size > 100) {
if(pending < max_requests &&
(complete + pending) < max_total) {
- pending += follow_links(multi_handle, mem, url);
+ pending += follow_links(multi_curl, mem, url);
still_running = 1;
}
}
else {
printf("[%d] Connection failure: %s\n", complete, url);
}
- curl_multi_remove_handle(multi_handle, handle);
- curl_easy_cleanup(handle);
+ curl_multi_remove_handle(multi, curl);
+ curl_easy_cleanup(curl);
free(mem->buf);
free(mem);
complete++;
}
}
}
- curl_multi_cleanup(multi_handle);
+ curl_multi_cleanup(multi);
}
curl_global_cleanup();
return 0;
fflush(stream);
}
-static int my_trace(CURL *handle, curl_infotype type,
+static int my_trace(CURL *curl, curl_infotype type,
char *data, size_t size, void *userp)
{
struct data *config = (struct data *)userp;
const char *text;
- (void)handle;
+ (void)curl;
switch(type) {
case CURLINFO_TEXT:
/* Information associated with a specific easy handle */
struct ConnInfo {
- CURL *easy;
+ CURL *curl;
char *url;
struct GlobalInfo *global;
char error[CURL_ERROR_SIZE];
/* Information associated with a specific socket */
struct SockInfo {
curl_socket_t sockfd;
- CURL *easy;
+ CURL *curl;
int action;
long timeout;
struct GlobalInfo *global;
CURLMsg *msg;
int msgs_left;
struct ConnInfo *conn;
- CURL *easy;
- CURLcode res;
fprintf(MSG_OUT, "REMAINING: %d\n", g->still_running);
while((msg = curl_multi_info_read(g->multi, &msgs_left))) {
if(msg->msg == CURLMSG_DONE) {
- easy = msg->easy_handle;
- res = msg->data.result;
- curl_easy_getinfo(easy, CURLINFO_PRIVATE, &conn);
- curl_easy_getinfo(easy, CURLINFO_EFFECTIVE_URL, &eff_url);
+ CURL *curl = msg->easy_handle;
+ CURLcode res = msg->data.result;
+ curl_easy_getinfo(curl, CURLINFO_PRIVATE, &conn);
+ curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &eff_url);
fprintf(MSG_OUT, "DONE: %s => (%d) %s\n", eff_url, res, conn->error);
- curl_multi_remove_handle(g->multi, easy);
+ curl_multi_remove_handle(g->multi, curl);
free(conn->url);
- curl_easy_cleanup(easy);
+ curl_easy_cleanup(curl);
free(conn);
}
}
f->sockfd = s;
f->action = act;
- f->easy = e;
+ f->curl = e;
ev.events = kind;
ev.data.fd = s;
}
/* Initialize a new SockInfo structure */
-static void addsock(curl_socket_t s, CURL *easy, int action,
+static void addsock(curl_socket_t s, CURL *curl, int action,
struct GlobalInfo *g)
{
struct SockInfo *fdp = (struct SockInfo*)calloc(1, sizeof(struct SockInfo));
fdp->global = g;
- setsock(fdp, s, easy, action, g);
+ setsock(fdp, s, curl, action, g);
curl_multi_assign(g->multi, s, fdp);
}
conn = (struct ConnInfo*)calloc(1, sizeof(*conn));
conn->error[0] = '\0';
- conn->easy = curl_easy_init();
- if(!conn->easy) {
+ conn->curl = curl_easy_init();
+ if(!conn->curl) {
fprintf(MSG_OUT, "curl_easy_init() failed, exiting!\n");
exit(2);
}
conn->global = g;
conn->url = strdup(url);
- curl_easy_setopt(conn->easy, CURLOPT_URL, conn->url);
- curl_easy_setopt(conn->easy, CURLOPT_WRITEFUNCTION, write_cb);
- curl_easy_setopt(conn->easy, CURLOPT_WRITEDATA, conn);
- curl_easy_setopt(conn->easy, CURLOPT_VERBOSE, 1L);
- curl_easy_setopt(conn->easy, CURLOPT_ERRORBUFFER, conn->error);
- curl_easy_setopt(conn->easy, CURLOPT_PRIVATE, conn);
- curl_easy_setopt(conn->easy, CURLOPT_NOPROGRESS, 0L);
- curl_easy_setopt(conn->easy, CURLOPT_PROGRESSFUNCTION, prog_cb);
- curl_easy_setopt(conn->easy, CURLOPT_PROGRESSDATA, conn);
- curl_easy_setopt(conn->easy, CURLOPT_FOLLOWLOCATION, 1L);
- curl_easy_setopt(conn->easy, CURLOPT_LOW_SPEED_TIME, 3L);
- curl_easy_setopt(conn->easy, CURLOPT_LOW_SPEED_LIMIT, 10L);
+ curl_easy_setopt(conn->curl, CURLOPT_URL, conn->url);
+ curl_easy_setopt(conn->curl, CURLOPT_WRITEFUNCTION, write_cb);
+ curl_easy_setopt(conn->curl, CURLOPT_WRITEDATA, conn);
+ curl_easy_setopt(conn->curl, CURLOPT_VERBOSE, 1L);
+ curl_easy_setopt(conn->curl, CURLOPT_ERRORBUFFER, conn->error);
+ curl_easy_setopt(conn->curl, CURLOPT_PRIVATE, conn);
+ curl_easy_setopt(conn->curl, CURLOPT_NOPROGRESS, 0L);
+ curl_easy_setopt(conn->curl, CURLOPT_PROGRESSFUNCTION, prog_cb);
+ curl_easy_setopt(conn->curl, CURLOPT_PROGRESSDATA, conn);
+ curl_easy_setopt(conn->curl, CURLOPT_FOLLOWLOCATION, 1L);
+ curl_easy_setopt(conn->curl, CURLOPT_LOW_SPEED_TIME, 3L);
+ curl_easy_setopt(conn->curl, CURLOPT_LOW_SPEED_LIMIT, 10L);
fprintf(MSG_OUT,
- "Adding easy %p to multi %p (%s)\n", conn->easy, g->multi, url);
- rc = curl_multi_add_handle(g->multi, conn->easy);
+ "Adding easy %p to multi %p (%s)\n", conn->curl, g->multi, url);
+ rc = curl_multi_add_handle(g->multi, conn->curl);
mcode_or_die("new_conn: curl_multi_add_handle", rc);
/* note that the add_handle() sets a timeout to trigger soon so that the
/* Information associated with a specific easy handle */
struct ConnInfo {
- CURL *easy;
+ CURL *curl;
char *url;
struct GlobalInfo *global;
char error[CURL_ERROR_SIZE];
/* Information associated with a specific socket */
struct SockInfo {
curl_socket_t sockfd;
- CURL *easy;
+ CURL *curl;
int action;
long timeout;
struct ev_io ev;
CURLMsg *msg;
int msgs_left;
struct ConnInfo *conn;
- CURL *easy;
- CURLcode res;
fprintf(MSG_OUT, "REMAINING: %d\n", g->still_running);
while((msg = curl_multi_info_read(g->multi, &msgs_left))) {
if(msg->msg == CURLMSG_DONE) {
- easy = msg->easy_handle;
- res = msg->data.result;
- curl_easy_getinfo(easy, CURLINFO_PRIVATE, &conn);
- curl_easy_getinfo(easy, CURLINFO_EFFECTIVE_URL, &eff_url);
+ CURL *curl = msg->easy_handle;
+ CURLcode res = msg->data.result;
+ curl_easy_getinfo(curl, CURLINFO_PRIVATE, &conn);
+ curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &eff_url);
fprintf(MSG_OUT, "DONE: %s => (%d) %s\n", eff_url, res, conn->error);
- curl_multi_remove_handle(g->multi, easy);
+ curl_multi_remove_handle(g->multi, curl);
free(conn->url);
- curl_easy_cleanup(easy);
+ curl_easy_cleanup(curl);
free(conn);
}
}
f->sockfd = s;
f->action = act;
- f->easy = e;
+ f->curl = e;
if(f->evset)
ev_io_stop(g->loop, &f->ev);
ev_io_init(&f->ev, event_cb, f->sockfd, kind);
}
/* Initialize a new SockInfo structure */
-static void addsock(curl_socket_t s, CURL *easy, int action,
+static void addsock(curl_socket_t s, CURL *curl, int action,
struct GlobalInfo *g)
{
struct SockInfo *fdp = calloc(1, sizeof(struct SockInfo));
fdp->global = g;
- setsock(fdp, s, easy, action, g);
+ setsock(fdp, s, curl, action, g);
curl_multi_assign(g->multi, s, fdp);
}
conn = calloc(1, sizeof(*conn));
conn->error[0]='\0';
- conn->easy = curl_easy_init();
- if(!conn->easy) {
+ conn->curl = curl_easy_init();
+ if(!conn->curl) {
fprintf(MSG_OUT, "curl_easy_init() failed, exiting!\n");
exit(2);
}
conn->global = g;
conn->url = strdup(url);
- curl_easy_setopt(conn->easy, CURLOPT_URL, conn->url);
- curl_easy_setopt(conn->easy, CURLOPT_WRITEFUNCTION, write_cb);
- curl_easy_setopt(conn->easy, CURLOPT_WRITEDATA, conn);
- curl_easy_setopt(conn->easy, CURLOPT_VERBOSE, 1L);
- curl_easy_setopt(conn->easy, CURLOPT_ERRORBUFFER, conn->error);
- curl_easy_setopt(conn->easy, CURLOPT_PRIVATE, conn);
- curl_easy_setopt(conn->easy, CURLOPT_NOPROGRESS, 0L);
- curl_easy_setopt(conn->easy, CURLOPT_XFERINFOFUNCTION, xferinfo_cb);
- curl_easy_setopt(conn->easy, CURLOPT_PROGRESSDATA, conn);
- curl_easy_setopt(conn->easy, CURLOPT_LOW_SPEED_TIME, 3L);
- curl_easy_setopt(conn->easy, CURLOPT_LOW_SPEED_LIMIT, 10L);
+ curl_easy_setopt(conn->curl, CURLOPT_URL, conn->url);
+ curl_easy_setopt(conn->curl, CURLOPT_WRITEFUNCTION, write_cb);
+ curl_easy_setopt(conn->curl, CURLOPT_WRITEDATA, conn);
+ curl_easy_setopt(conn->curl, CURLOPT_VERBOSE, 1L);
+ curl_easy_setopt(conn->curl, CURLOPT_ERRORBUFFER, conn->error);
+ curl_easy_setopt(conn->curl, CURLOPT_PRIVATE, conn);
+ curl_easy_setopt(conn->curl, CURLOPT_NOPROGRESS, 0L);
+ curl_easy_setopt(conn->curl, CURLOPT_XFERINFOFUNCTION, xferinfo_cb);
+ curl_easy_setopt(conn->curl, CURLOPT_PROGRESSDATA, conn);
+ curl_easy_setopt(conn->curl, CURLOPT_LOW_SPEED_TIME, 3L);
+ curl_easy_setopt(conn->curl, CURLOPT_LOW_SPEED_LIMIT, 10L);
fprintf(MSG_OUT,
- "Adding easy %p to multi %p (%s)\n", conn->easy, g->multi, url);
- rc = curl_multi_add_handle(g->multi, conn->easy);
+ "Adding easy %p to multi %p (%s)\n", conn->curl, g->multi, url);
+ rc = curl_multi_add_handle(g->multi, conn->curl);
mcode_or_die("new_conn: curl_multi_add_handle", rc);
/* note that add_handle() sets a timeout to trigger soon so that the
#define INADDR_NONE 0xffffffff
#endif
-static size_t write_data(void *ptr, size_t size, size_t nmemb, void *stream)
+static size_t write_cb(void *ptr, size_t size, size_t nmemb, void *stream)
{
size_t written = fwrite(ptr, size, nmemb, (FILE *)stream);
return written;
curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
/* send all data to this function */
- curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
/* call this function to get a socket */
curl_easy_setopt(curl, CURLOPT_OPENSOCKETFUNCTION, opensocket);
* </DESC>
*/
-static size_t my_fwrite(void *buffer, size_t size, size_t nmemb, void *stream)
+static size_t write_cb(void *buffer, size_t size, size_t nmemb, void *stream)
{
(void)buffer;
(void)stream;
*/
curl_easy_setopt(curl, CURLOPT_URL, "ftp://ftp.example.com/");
/* Define our callback to get called when there is data to be written */
- curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, my_fwrite);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
/* Switch on full protocol/debug output */
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
return CURL_CHUNK_END_FUNC_OK;
}
-static size_t write_it(char *buff, size_t size, size_t nmemb,
+static size_t write_cb(char *buff, size_t size, size_t nmemb,
void *cb_data)
{
struct callback_data *data = cb_data;
int main(int argc, char **argv)
{
/* curl easy handle */
- CURL *handle;
+ CURL *curl;
/* help data */
struct callback_data data = { 0 };
return (int)res;
/* initialization of easy handle */
- handle = curl_easy_init();
- if(!handle) {
+ curl = curl_easy_init();
+ if(!curl) {
curl_global_cleanup();
return CURLE_OUT_OF_MEMORY;
}
/* turn on wildcard matching */
- curl_easy_setopt(handle, CURLOPT_WILDCARDMATCH, 1L);
+ curl_easy_setopt(curl, CURLOPT_WILDCARDMATCH, 1L);
/* callback is called before download of concrete file started */
- curl_easy_setopt(handle, CURLOPT_CHUNK_BGN_FUNCTION, file_is_coming);
+ curl_easy_setopt(curl, CURLOPT_CHUNK_BGN_FUNCTION, file_is_coming);
/* callback is called after data from the file have been transferred */
- curl_easy_setopt(handle, CURLOPT_CHUNK_END_FUNCTION, file_is_downloaded);
+ curl_easy_setopt(curl, CURLOPT_CHUNK_END_FUNCTION, file_is_downloaded);
/* this callback writes contents into files */
- curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, write_it);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
/* put transfer data into callbacks */
- curl_easy_setopt(handle, CURLOPT_CHUNK_DATA, &data);
- curl_easy_setopt(handle, CURLOPT_WRITEDATA, &data);
+ curl_easy_setopt(curl, CURLOPT_CHUNK_DATA, &data);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, &data);
- /* curl_easy_setopt(handle, CURLOPT_VERBOSE, 1L); */
+ /* curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); */
/* set a URL containing wildcard pattern (only in the last part) */
if(argc == 2)
- curl_easy_setopt(handle, CURLOPT_URL, argv[1]);
+ curl_easy_setopt(curl, CURLOPT_URL, argv[1]);
else
- curl_easy_setopt(handle, CURLOPT_URL, "ftp://example.com/test/*");
+ curl_easy_setopt(curl, CURLOPT_URL, "ftp://example.com/test/*");
/* and start transfer! */
- res = curl_easy_perform(handle);
+ res = curl_easy_perform(curl);
- curl_easy_cleanup(handle);
+ curl_easy_cleanup(curl);
curl_global_cleanup();
return (int)res;
}
FILE *stream;
};
-static size_t my_fwrite(void *buffer, size_t size, size_t nmemb, void *stream)
+static size_t write_cb(void *buffer, size_t size, size_t nmemb, void *stream)
{
struct FtpFile *out = (struct FtpFile *)stream;
if(!out->stream) {
curl_easy_setopt(curl, CURLOPT_URL,
"ftp://ftp.example.com/curl/curl-7.9.2.tar.gz");
/* Define our callback to get called when there is data to be written */
- curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, my_fwrite);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
/* Set a pointer to our struct to pass to the callback */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &ftpfile);
FILE *stream;
};
-static size_t my_fwrite(void *buffer, size_t size, size_t nmemb,
+static size_t write_cb(void *buffer, size_t size, size_t nmemb,
void *stream)
{
struct FtpFile *out = (struct FtpFile *)stream;
curl_easy_setopt(curl, CURLOPT_URL,
"ftp://user@server/home/user/file.txt");
/* Define our callback to get called when there is data to be written */
- curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, my_fwrite);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
/* Set a pointer to our struct to pass to the callback */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &ftpfile);
you MUST also provide a read callback with CURLOPT_READFUNCTION. Failing to
do so might give you a crash since a DLL may not use the variable's memory
when passed in to it from an app like this. */
-static size_t read_callback(char *ptr, size_t size, size_t nmemb, void *stream)
+static size_t read_cb(char *ptr, size_t size, size_t nmemb, void *stream)
{
unsigned long nread;
/* in real-world cases, this would probably get this data differently
headerlist = curl_slist_append(headerlist, buf_2);
/* we want to use our own read function */
- curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
size_t sizeleft;
};
-static size_t read_callback(char *ptr, size_t size, size_t nmemb, void *userp)
+static size_t read_cb(char *ptr, size_t size, size_t nmemb, void *userp)
{
struct WriteThis *upload = (struct WriteThis *)userp;
size_t max = size*nmemb;
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
/* we want to use our own read function */
- curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);
/* pointer to pass to our read function */
curl_easy_setopt(curl, CURLOPT_READDATA, &upload);
}
/* discard downloaded data */
-static size_t discardfunc(void *ptr, size_t size, size_t nmemb, void *stream)
+static size_t write_cb(void *ptr, size_t size, size_t nmemb, void *stream)
{
(void)ptr;
(void)stream;
}
/* read data to upload */
-static size_t readfunc(char *ptr, size_t size, size_t nmemb, void *stream)
+static size_t read_cb(char *ptr, size_t size, size_t nmemb, void *stream)
{
FILE *f = stream;
size_t n;
}
-static int upload(CURL *curlhandle, const char *remotepath,
+static int upload(CURL *curl, const char *remotepath,
const char *localpath, long timeout, long tries)
{
FILE *f;
long uploaded_len = 0;
- CURLcode r = CURLE_GOT_NOTHING;
+ CURLcode res = CURLE_GOT_NOTHING;
int c;
f = fopen(localpath, "rb");
return 0;
}
- curl_easy_setopt(curlhandle, CURLOPT_UPLOAD, 1L);
+ curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
- curl_easy_setopt(curlhandle, CURLOPT_URL, remotepath);
+ curl_easy_setopt(curl, CURLOPT_URL, remotepath);
if(timeout)
- curl_easy_setopt(curlhandle, CURLOPT_SERVER_RESPONSE_TIMEOUT, timeout);
+ curl_easy_setopt(curl, CURLOPT_SERVER_RESPONSE_TIMEOUT, timeout);
- curl_easy_setopt(curlhandle, CURLOPT_HEADERFUNCTION, getcontentlengthfunc);
- curl_easy_setopt(curlhandle, CURLOPT_HEADERDATA, &uploaded_len);
+ curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, getcontentlengthfunc);
+ curl_easy_setopt(curl, CURLOPT_HEADERDATA, &uploaded_len);
- curl_easy_setopt(curlhandle, CURLOPT_WRITEFUNCTION, discardfunc);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
- curl_easy_setopt(curlhandle, CURLOPT_READFUNCTION, readfunc);
- curl_easy_setopt(curlhandle, CURLOPT_READDATA, f);
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);
+ curl_easy_setopt(curl, CURLOPT_READDATA, f);
/* enable active mode */
- curl_easy_setopt(curlhandle, CURLOPT_FTPPORT, "-");
+ curl_easy_setopt(curl, CURLOPT_FTPPORT, "-");
/* allow the server no more than 7 seconds to connect back */
- curl_easy_setopt(curlhandle, CURLOPT_ACCEPTTIMEOUT_MS, 7000L);
+ curl_easy_setopt(curl, CURLOPT_ACCEPTTIMEOUT_MS, 7000L);
- curl_easy_setopt(curlhandle, CURLOPT_FTP_CREATE_MISSING_DIRS, 1L);
+ curl_easy_setopt(curl, CURLOPT_FTP_CREATE_MISSING_DIRS, 1L);
- curl_easy_setopt(curlhandle, CURLOPT_VERBOSE, 1L);
+ curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
- for(c = 0; (r != CURLE_OK) && (c < tries); c++) {
+ for(c = 0; (res != CURLE_OK) && (c < tries); c++) {
/* are we resuming? */
if(c) { /* yes */
/* determine the length of the file already written */
/*
* With NOBODY and NOHEADER, libcurl issues a SIZE command, but the only
* way to retrieve the result is to parse the returned Content-Length
- * header. Thus, getcontentlengthfunc(). We need discardfunc() above
+ * header. Thus, getcontentlengthfunc(). We need write_cb() above
* because HEADER dumps the headers to stdout without it.
*/
- curl_easy_setopt(curlhandle, CURLOPT_NOBODY, 1L);
- curl_easy_setopt(curlhandle, CURLOPT_HEADER, 1L);
+ curl_easy_setopt(curl, CURLOPT_NOBODY, 1L);
+ curl_easy_setopt(curl, CURLOPT_HEADER, 1L);
- r = curl_easy_perform(curlhandle);
- if(r != CURLE_OK)
+ res = curl_easy_perform(curl);
+ if(res != CURLE_OK)
continue;
- curl_easy_setopt(curlhandle, CURLOPT_NOBODY, 0L);
- curl_easy_setopt(curlhandle, CURLOPT_HEADER, 0L);
+ curl_easy_setopt(curl, CURLOPT_NOBODY, 0L);
+ curl_easy_setopt(curl, CURLOPT_HEADER, 0L);
fseek(f, uploaded_len, SEEK_SET);
- curl_easy_setopt(curlhandle, CURLOPT_APPEND, 1L);
+ curl_easy_setopt(curl, CURLOPT_APPEND, 1L);
}
else { /* no */
- curl_easy_setopt(curlhandle, CURLOPT_APPEND, 0L);
+ curl_easy_setopt(curl, CURLOPT_APPEND, 0L);
}
- r = curl_easy_perform(curlhandle);
+ res = curl_easy_perform(curl);
}
fclose(f);
- if(r == CURLE_OK)
+ if(res == CURLE_OK)
return 1;
else {
- fprintf(stderr, "%s\n", curl_easy_strerror(r));
+ fprintf(stderr, "%s\n", curl_easy_strerror(res));
return 0;
}
}
int main(void)
{
- CURL *curlhandle = NULL;
+ CURL *curl = NULL;
CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
if(res)
return (int)res;
- curlhandle = curl_easy_init();
- if(curlhandle) {
-
- upload(curlhandle, "ftp://user:pass@example.com/path/file", "C:\\file",
- 0, 3);
-
- curl_easy_cleanup(curlhandle);
+ curl = curl_easy_init();
+ if(curl) {
+ upload(curl, "ftp://user:pass@example.com/path/file", "C:\\file", 0, 3);
+ curl_easy_cleanup(curl);
}
curl_global_cleanup();
size_t size;
};
-static size_t WriteMemoryCallback(void *contents, size_t size, size_t nmemb,
+static size_t write_cb(void *contents, size_t size, size_t nmemb,
void *userp)
{
size_t realsize = size * nmemb;
int main(void)
{
- CURL *curl_handle;
+ CURL *curl;
CURLcode res;
struct MemoryStruct chunk;
chunk.size = 0; /* no data at this point */
/* init the curl session */
- curl_handle = curl_easy_init();
- if(curl_handle) {
+ curl = curl_easy_init();
+ if(curl) {
/* specify URL to get */
- curl_easy_setopt(curl_handle, CURLOPT_URL, "https://www.example.com/");
+ curl_easy_setopt(curl, CURLOPT_URL, "https://www.example.com/");
/* send all data to this function */
- curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
/* we pass our 'chunk' struct to the callback function */
- curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)&chunk);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* some servers do not like requests that are made without a user-agent
field, so we provide one */
- curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0");
+ curl_easy_setopt(curl, CURLOPT_USERAGENT, "libcurl-agent/1.0");
/* get it! */
- res = curl_easy_perform(curl_handle);
+ res = curl_easy_perform(curl);
/* check for errors */
if(res != CURLE_OK) {
}
/* cleanup curl stuff */
- curl_easy_cleanup(curl_handle);
+ curl_easy_cleanup(curl);
}
free(chunk.memory);
/* Information associated with a specific easy handle */
struct ConnInfo {
- CURL *easy;
+ CURL *curl;
char *url;
struct GlobalInfo *global;
char error[CURL_ERROR_SIZE];
/* Information associated with a specific socket */
struct SockInfo {
curl_socket_t sockfd;
- CURL *easy;
+ CURL *curl;
int action;
long timeout;
GIOChannel *ch;
MSG_OUT("REMAINING: %d\n", g->still_running);
while((msg = curl_multi_info_read(g->multi, &msgs_left))) {
if(msg->msg == CURLMSG_DONE) {
- CURL *easy = msg->easy_handle;
+ CURL *curl = msg->easy_handle;
CURLcode res = msg->data.result;
char *eff_url;
struct ConnInfo *conn;
- curl_easy_getinfo(easy, CURLINFO_PRIVATE, &conn);
- curl_easy_getinfo(easy, CURLINFO_EFFECTIVE_URL, &eff_url);
+ curl_easy_getinfo(curl, CURLINFO_PRIVATE, &conn);
+ curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &eff_url);
MSG_OUT("DONE: %s => (%d) %s\n", eff_url, res, conn->error);
- curl_multi_remove_handle(g->multi, easy);
+ curl_multi_remove_handle(g->multi, curl);
free(conn->url);
- curl_easy_cleanup(easy);
+ curl_easy_cleanup(curl);
free(conn);
}
}
f->sockfd = s;
f->action = act;
- f->easy = e;
+ f->curl = e;
if(f->ev) {
g_source_remove(f->ev);
}
}
/* Initialize a new SockInfo structure */
-static void addsock(curl_socket_t s, CURL *easy, int action,
+static void addsock(curl_socket_t s, CURL *curl, int action,
struct GlobalInfo *g)
{
struct SockInfo *fdp = g_malloc0(sizeof(struct SockInfo));
fdp->global = g;
fdp->ch = g_io_channel_unix_new(s);
- setsock(fdp, s, easy, action, g);
+ setsock(fdp, s, curl, action, g);
curl_multi_assign(g->multi, s, fdp);
}
conn = g_malloc0(sizeof(*conn));
conn->error[0] = '\0';
- conn->easy = curl_easy_init();
- if(!conn->easy) {
+ conn->curl = curl_easy_init();
+ if(!conn->curl) {
MSG_OUT("curl_easy_init() failed, exiting!\n");
exit(2);
}
conn->global = g;
conn->url = g_strdup(url);
- curl_easy_setopt(conn->easy, CURLOPT_URL, conn->url);
- curl_easy_setopt(conn->easy, CURLOPT_WRITEFUNCTION, write_cb);
- curl_easy_setopt(conn->easy, CURLOPT_WRITEDATA, &conn);
- curl_easy_setopt(conn->easy, CURLOPT_VERBOSE, SHOW_VERBOSE);
- curl_easy_setopt(conn->easy, CURLOPT_ERRORBUFFER, conn->error);
- curl_easy_setopt(conn->easy, CURLOPT_PRIVATE, conn);
- curl_easy_setopt(conn->easy, CURLOPT_NOPROGRESS, SHOW_PROGRESS ? 0L : 1L);
- curl_easy_setopt(conn->easy, CURLOPT_XFERINFOFUNCTION, xferinfo_cb);
- curl_easy_setopt(conn->easy, CURLOPT_PROGRESSDATA, conn);
- curl_easy_setopt(conn->easy, CURLOPT_FOLLOWLOCATION, 1L);
- curl_easy_setopt(conn->easy, CURLOPT_CONNECTTIMEOUT, 30L);
- curl_easy_setopt(conn->easy, CURLOPT_LOW_SPEED_LIMIT, 1L);
- curl_easy_setopt(conn->easy, CURLOPT_LOW_SPEED_TIME, 30L);
-
- MSG_OUT("Adding easy %p to multi %p (%s)\n", conn->easy, g->multi, url);
- rc = curl_multi_add_handle(g->multi, conn->easy);
+ curl_easy_setopt(conn->curl, CURLOPT_URL, conn->url);
+ curl_easy_setopt(conn->curl, CURLOPT_WRITEFUNCTION, write_cb);
+ curl_easy_setopt(conn->curl, CURLOPT_WRITEDATA, &conn);
+ curl_easy_setopt(conn->curl, CURLOPT_VERBOSE, SHOW_VERBOSE);
+ curl_easy_setopt(conn->curl, CURLOPT_ERRORBUFFER, conn->error);
+ curl_easy_setopt(conn->curl, CURLOPT_PRIVATE, conn);
+ curl_easy_setopt(conn->curl, CURLOPT_NOPROGRESS, SHOW_PROGRESS ? 0L : 1L);
+ curl_easy_setopt(conn->curl, CURLOPT_XFERINFOFUNCTION, xferinfo_cb);
+ curl_easy_setopt(conn->curl, CURLOPT_PROGRESSDATA, conn);
+ curl_easy_setopt(conn->curl, CURLOPT_FOLLOWLOCATION, 1L);
+ curl_easy_setopt(conn->curl, CURLOPT_CONNECTTIMEOUT, 30L);
+ curl_easy_setopt(conn->curl, CURLOPT_LOW_SPEED_LIMIT, 1L);
+ curl_easy_setopt(conn->curl, CURLOPT_LOW_SPEED_TIME, 30L);
+
+ MSG_OUT("Adding easy %p to multi %p (%s)\n", conn->curl, g->multi, url);
+ rc = curl_multi_add_handle(g->multi, conn->curl);
mcode_or_die("new_conn: curl_multi_add_handle", rc);
/* note that add_handle() sets a timeout to trigger soon so that the
/* Information associated with a specific easy handle */
struct ConnInfo {
- CURL *easy;
+ CURL *curl;
char *url;
struct GlobalInfo *global;
char error[CURL_ERROR_SIZE];
/* Information associated with a specific socket */
struct SockInfo {
curl_socket_t sockfd;
- CURL *easy;
+ CURL *curl;
int action;
long timeout;
struct event ev;
CURLMsg *msg;
int msgs_left;
struct ConnInfo *conn;
- CURL *easy;
- CURLcode res;
fprintf(MSG_OUT, "REMAINING: %d\n", g->still_running);
while((msg = curl_multi_info_read(g->multi, &msgs_left))) {
if(msg->msg == CURLMSG_DONE) {
- easy = msg->easy_handle;
- res = msg->data.result;
- curl_easy_getinfo(easy, CURLINFO_PRIVATE, &conn);
- curl_easy_getinfo(easy, CURLINFO_EFFECTIVE_URL, &eff_url);
+ CURL *curl = msg->easy_handle;
+ CURLcode res = msg->data.result;
+ curl_easy_getinfo(curl, CURLINFO_PRIVATE, &conn);
+ curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &eff_url);
fprintf(MSG_OUT, "DONE: %s => (%d) %s\n", eff_url, res, conn->error);
- curl_multi_remove_handle(g->multi, easy);
+ curl_multi_remove_handle(g->multi, curl);
free(conn->url);
- curl_easy_cleanup(easy);
+ curl_easy_cleanup(curl);
free(conn);
}
}
f->sockfd = s;
f->action = act;
- f->easy = e;
+ f->curl = e;
if(event_initialized(&f->ev)) {
event_del(&f->ev);
}
}
/* Initialize a new SockInfo structure */
-static void addsock(curl_socket_t s, CURL *easy, int action,
+static void addsock(curl_socket_t s, CURL *curl, int action,
struct GlobalInfo *g)
{
struct SockInfo *fdp = calloc(1, sizeof(struct SockInfo));
fdp->global = g;
- setsock(fdp, s, easy, action, g);
+ setsock(fdp, s, curl, action, g);
curl_multi_assign(g->multi, s, fdp);
}
conn = calloc(1, sizeof(*conn));
conn->error[0] = '\0';
- conn->easy = curl_easy_init();
- if(!conn->easy) {
+ conn->curl = curl_easy_init();
+ if(!conn->curl) {
fprintf(MSG_OUT, "curl_easy_init() failed, exiting!\n");
exit(2);
}
conn->global = g;
conn->url = strdup(url);
- curl_easy_setopt(conn->easy, CURLOPT_URL, conn->url);
- curl_easy_setopt(conn->easy, CURLOPT_WRITEFUNCTION, write_cb);
- curl_easy_setopt(conn->easy, CURLOPT_WRITEDATA, conn);
- curl_easy_setopt(conn->easy, CURLOPT_VERBOSE, 1L);
- curl_easy_setopt(conn->easy, CURLOPT_ERRORBUFFER, conn->error);
- curl_easy_setopt(conn->easy, CURLOPT_PRIVATE, conn);
- curl_easy_setopt(conn->easy, CURLOPT_NOPROGRESS, 0L);
- curl_easy_setopt(conn->easy, CURLOPT_XFERINFOFUNCTION, xferinfo_cb);
- curl_easy_setopt(conn->easy, CURLOPT_PROGRESSDATA, conn);
- curl_easy_setopt(conn->easy, CURLOPT_FOLLOWLOCATION, 1L);
+ curl_easy_setopt(conn->curl, CURLOPT_URL, conn->url);
+ curl_easy_setopt(conn->curl, CURLOPT_WRITEFUNCTION, write_cb);
+ curl_easy_setopt(conn->curl, CURLOPT_WRITEDATA, conn);
+ curl_easy_setopt(conn->curl, CURLOPT_VERBOSE, 1L);
+ curl_easy_setopt(conn->curl, CURLOPT_ERRORBUFFER, conn->error);
+ curl_easy_setopt(conn->curl, CURLOPT_PRIVATE, conn);
+ curl_easy_setopt(conn->curl, CURLOPT_NOPROGRESS, 0L);
+ curl_easy_setopt(conn->curl, CURLOPT_XFERINFOFUNCTION, xferinfo_cb);
+ curl_easy_setopt(conn->curl, CURLOPT_PROGRESSDATA, conn);
+ curl_easy_setopt(conn->curl, CURLOPT_FOLLOWLOCATION, 1L);
fprintf(MSG_OUT,
- "Adding easy %p to multi %p (%s)\n", conn->easy, g->multi, url);
- rc = curl_multi_add_handle(g->multi, conn->easy);
+ "Adding easy %p to multi %p (%s)\n", conn->curl, g->multi, url);
+ rc = curl_multi_add_handle(g->multi, conn->curl);
mcode_or_die("new_conn: curl_multi_add_handle", rc);
/* note that the add_handle() sets a time-out to trigger soon so that
/* "read" is from the point of the library, it wants data from us. One domain
entry per invoke. */
-static CURLSTScode hstsread(CURL *easy, struct curl_hstsentry *e,
+static CURLSTScode hstsread(CURL *curl, struct curl_hstsentry *e,
void *userp)
{
const char *host;
const char *expire;
struct state *s = (struct state *)userp;
- (void)easy;
+ (void)curl;
host = preload_hosts[s->index].name;
expire = preload_hosts[s->index++].exp;
return CURLSTS_OK;
}
-static CURLSTScode hstswrite(CURL *easy, struct curl_hstsentry *e,
+static CURLSTScode hstswrite(CURL *curl, struct curl_hstsentry *e,
struct curl_index *i, void *userp)
{
- (void)easy;
+ (void)curl;
(void)userp; /* we have no custom input */
printf("[%u/%u] %s %s\n", (unsigned int)i->index, (unsigned int)i->total,
e->name, e->expire);
// libcurl connection initialization
//
-static bool init(CURL *&conn, const char *url)
+static bool init(CURL *&curl, const char *url)
{
- CURLcode code;
+ CURLcode res;
- conn = curl_easy_init();
+ curl = curl_easy_init();
- if(conn == NULL) {
- fprintf(stderr, "Failed to create CURL connection\n");
+ if(!curl) {
+ fprintf(stderr, "Failed to create CURL handle\n");
return false;
}
- code = curl_easy_setopt(conn, CURLOPT_ERRORBUFFER, errorBuffer);
- if(code != CURLE_OK) {
- fprintf(stderr, "Failed to set error buffer [%d]\n", code);
+ res = curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, errorBuffer);
+ if(res != CURLE_OK) {
+ fprintf(stderr, "Failed to set error buffer [%d]\n", res);
return false;
}
- code = curl_easy_setopt(conn, CURLOPT_URL, url);
- if(code != CURLE_OK) {
+ res = curl_easy_setopt(curl, CURLOPT_URL, url);
+ if(res != CURLE_OK) {
fprintf(stderr, "Failed to set URL [%s]\n", errorBuffer);
return false;
}
- code = curl_easy_setopt(conn, CURLOPT_FOLLOWLOCATION, 1L);
- if(code != CURLE_OK) {
+ res = curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+ if(res != CURLE_OK) {
fprintf(stderr, "Failed to set redirect option [%s]\n", errorBuffer);
return false;
}
- code = curl_easy_setopt(conn, CURLOPT_WRITEFUNCTION, writer);
- if(code != CURLE_OK) {
+ res = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writer);
+ if(res != CURLE_OK) {
fprintf(stderr, "Failed to set writer [%s]\n", errorBuffer);
return false;
}
- code = curl_easy_setopt(conn, CURLOPT_WRITEDATA, &buffer);
- if(code != CURLE_OK) {
+ res = curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buffer);
+ if(res != CURLE_OK) {
fprintf(stderr, "Failed to set write data [%s]\n", errorBuffer);
return false;
}
int main(int argc, char *argv[])
{
- CURL *conn = NULL;
+ CURL *curl = NULL;
CURLcode res;
std::string title;
if(res)
return (int)res;
- // Initialize CURL connection
+ // Initialize CURL handle
- if(!init(conn, argv[1])) {
- fprintf(stderr, "Connection initialization failed\n");
+ if(!init(curl, argv[1])) {
+ fprintf(stderr, "Handle initialization failed\n");
curl_global_cleanup();
return EXIT_FAILURE;
}
// Retrieve content for the URL
- res = curl_easy_perform(conn);
- curl_easy_cleanup(conn);
+ res = curl_easy_perform(curl);
+ curl_easy_cleanup(curl);
if(res != CURLE_OK) {
fprintf(stderr, "Failed to get '%s' [%s]\n", argv[1], errorBuffer);
struct transfer {
FILE *out;
- CURL *easy;
+ CURL *curl;
int num;
};
}
}
-static int my_trace(CURL *handle, curl_infotype type,
+static int my_trace(CURL *curl, curl_infotype type,
char *data, size_t size, void *userp)
{
const char *text;
struct transfer *t = (struct transfer *)userp;
int num = t->num;
- (void)handle;
+ (void)curl;
switch(type) {
case CURLINFO_TEXT:
static int setup(struct transfer *t, int num)
{
char filename[128];
- CURL *easy;
+ CURL *curl;
- easy = t->easy = NULL;
+ curl = t->curl = NULL;
t->num = num;
snprintf(filename, sizeof(filename), "dl-%d", num);
return 1;
}
- easy = t->easy = curl_easy_init();
- if(easy) {
+ curl = t->curl = curl_easy_init();
+ if(curl) {
/* write to this file */
- curl_easy_setopt(easy, CURLOPT_WRITEDATA, t->out);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, t->out);
/* set the same URL */
- curl_easy_setopt(easy, CURLOPT_URL, "https://localhost:8443/index.html");
+ curl_easy_setopt(curl, CURLOPT_URL, "https://localhost:8443/index.html");
/* please be verbose */
- curl_easy_setopt(easy, CURLOPT_VERBOSE, 1L);
- curl_easy_setopt(easy, CURLOPT_DEBUGFUNCTION, my_trace);
- curl_easy_setopt(easy, CURLOPT_DEBUGDATA, t);
+ curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+ curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
+ curl_easy_setopt(curl, CURLOPT_DEBUGDATA, t);
/* enlarge the receive buffer for potentially higher transfer speeds */
- curl_easy_setopt(easy, CURLOPT_BUFFERSIZE, 100000L);
+ curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, 100000L);
/* HTTP/2 please */
- curl_easy_setopt(easy, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
+ curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
#if (CURLPIPE_MULTIPLEX > 0)
/* wait for pipe connection to confirm */
- curl_easy_setopt(easy, CURLOPT_PIPEWAIT, 1L);
+ curl_easy_setopt(curl, CURLOPT_PIPEWAIT, 1L);
#endif
}
return 0;
{
CURLcode res;
struct transfer *trans;
- CURLM *multi_handle = NULL;
+ CURLM *multi = NULL;
int i;
int still_running = 0; /* keep number of running handles */
int num_transfers;
}
/* init a multi stack */
- multi_handle = curl_multi_init();
- if(!multi_handle)
+ multi = curl_multi_init();
+ if(!multi)
goto error;
for(i = 0; i < num_transfers; i++) {
}
/* add the individual transfer */
- curl_multi_add_handle(multi_handle, trans[i].easy);
+ curl_multi_add_handle(multi, trans[i].curl);
}
- curl_multi_setopt(multi_handle, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
+ curl_multi_setopt(multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
do {
- CURLMcode mc = curl_multi_perform(multi_handle, &still_running);
+ CURLMcode mc = curl_multi_perform(multi, &still_running);
if(still_running)
/* wait for activity, timeout or "nothing" */
- mc = curl_multi_poll(multi_handle, NULL, 0, 1000, NULL);
+ mc = curl_multi_poll(multi, NULL, 0, 1000, NULL);
if(mc)
break;
error:
- if(multi_handle) {
+ if(multi) {
for(i = 0; i < num_transfers; i++) {
- curl_multi_remove_handle(multi_handle, trans[i].easy);
- curl_easy_cleanup(trans[i].easy);
+ curl_multi_remove_handle(multi, trans[i].curl);
+ curl_easy_cleanup(trans[i].curl);
if(trans[i].out)
fclose(trans[i].out);
}
- curl_multi_cleanup(multi_handle);
+ curl_multi_cleanup(multi);
}
free(trans);
chunk->size = 0; /* no data at this point */
}
-static void setup(CURL *hnd)
+static void setup(CURL *curl)
{
/* set the same URL */
- curl_easy_setopt(hnd, CURLOPT_URL, "https://localhost:8443/index.html");
+ curl_easy_setopt(curl, CURLOPT_URL, "https://localhost:8443/index.html");
/* HTTP/2 please */
- curl_easy_setopt(hnd, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
+ curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
/* we use a self-signed test server, skip verification during debugging */
- curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYPEER, 0L);
- curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYHOST, 0L);
+ curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
+ curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
/* write data to a struct */
- curl_easy_setopt(hnd, CURLOPT_WRITEFUNCTION, write_cb);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
init_memory(&files[0]);
- curl_easy_setopt(hnd, CURLOPT_WRITEDATA, &files[0]);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, &files[0]);
/* wait for pipe connection to confirm */
- curl_easy_setopt(hnd, CURLOPT_PIPEWAIT, 1L);
+ curl_easy_setopt(curl, CURLOPT_PIPEWAIT, 1L);
}
/* called when there is an incoming push */
static int server_push_callback(CURL *parent,
- CURL *easy,
+ CURL *curl,
size_t num_headers,
struct curl_pushheaders *headers,
void *userp)
/* write to this buffer */
init_memory(&files[pushindex]);
- curl_easy_setopt(easy, CURLOPT_WRITEDATA, &files[pushindex]);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, &files[pushindex]);
pushindex++;
headp = curl_pushheader_byname(headers, ":path");
*/
int main(void)
{
- CURL *easy;
+ CURL *curl;
CURLM *multi;
int transfers = 1; /* we start with one */
int i;
/* init a multi stack */
multi = curl_multi_init();
- easy = curl_easy_init();
+ curl = curl_easy_init();
/* set options */
- setup(easy);
+ setup(curl);
/* add the easy transfer */
- curl_multi_add_handle(multi, easy);
+ curl_multi_add_handle(multi, curl);
curl_multi_setopt(multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
curl_multi_setopt(multi, CURLMOPT_PUSHFUNCTION, server_push_callback);
int msgq = 0;
m = curl_multi_info_read(multi, &msgq);
if(m && (m->msg == CURLMSG_DONE)) {
- CURL *e = m->easy_handle;
+ curl = m->easy_handle;
transfers--;
- curl_multi_remove_handle(multi, e);
- curl_easy_cleanup(e);
+ curl_multi_remove_handle(multi, curl);
+ curl_easy_cleanup(curl);
}
} while(m);
}
}
}
-static int my_trace(CURL *handle, curl_infotype type,
+static int my_trace(CURL *curl, curl_infotype type,
char *data, size_t size, void *userp)
{
const char *text;
- (void)handle;
+ (void)curl;
(void)userp;
switch(type) {
case CURLINFO_TEXT:
#define OUTPUTFILE "dl"
-static int setup(CURL *hnd, const char *url)
+static int setup(CURL *curl, const char *url)
{
out_download = fopen(OUTPUTFILE, "wb");
if(!out_download)
return 1; /* failed */
/* set the same URL */
- curl_easy_setopt(hnd, CURLOPT_URL, url);
+ curl_easy_setopt(curl, CURLOPT_URL, url);
/* HTTP/2 please */
- curl_easy_setopt(hnd, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
+ curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
/* we use a self-signed test server, skip verification during debugging */
- curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYPEER, 0L);
- curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYHOST, 0L);
+ curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
+ curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
/* write to this file */
- curl_easy_setopt(hnd, CURLOPT_WRITEDATA, out_download);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, out_download);
/* please be verbose */
- curl_easy_setopt(hnd, CURLOPT_VERBOSE, 1L);
- curl_easy_setopt(hnd, CURLOPT_DEBUGFUNCTION, my_trace);
+ curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+ curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
#if CURLPIPE_MULTIPLEX > 0
/* wait for pipe connection to confirm */
- curl_easy_setopt(hnd, CURLOPT_PIPEWAIT, 1L);
+ curl_easy_setopt(curl, CURLOPT_PIPEWAIT, 1L);
#endif
return 0; /* all is good */
}
/* called when there is an incoming push */
static int server_push_callback(CURL *parent,
- CURL *easy,
+ CURL *curl,
size_t num_headers,
struct curl_pushheaders *headers,
void *userp)
}
/* write to this file */
- curl_easy_setopt(easy, CURLOPT_WRITEDATA, out_push);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, out_push);
fprintf(stderr, "**** push callback approves stream %u, got %lu headers!\n",
count, (unsigned long)num_headers);
int main(int argc, char *argv[])
{
CURLcode res;
- CURL *easy;
- CURLM *multi_handle;
+ CURL *curl;
+ CURLM *multi;
int transfers = 1; /* we start with one */
const char *url = "https://localhost:8443/index.html";
return (int)res;
/* init a multi stack */
- multi_handle = curl_multi_init();
- if(!multi_handle)
+ multi = curl_multi_init();
+ if(!multi)
goto error;
- easy = curl_easy_init();
+ curl = curl_easy_init();
/* set options */
- if(!easy || setup(easy, url)) {
+ if(!curl || setup(curl, url)) {
fprintf(stderr, "failed\n");
goto error;
}
- curl_multi_setopt(multi_handle, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
- curl_multi_setopt(multi_handle, CURLMOPT_PUSHFUNCTION, server_push_callback);
- curl_multi_setopt(multi_handle, CURLMOPT_PUSHDATA, &transfers);
+ curl_multi_setopt(multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
+ curl_multi_setopt(multi, CURLMOPT_PUSHFUNCTION, server_push_callback);
+ curl_multi_setopt(multi, CURLMOPT_PUSHDATA, &transfers);
/* add the easy transfer */
- curl_multi_add_handle(multi_handle, easy);
+ curl_multi_add_handle(multi, curl);
do {
struct CURLMsg *m;
int still_running; /* keep number of running handles */
- CURLMcode mc = curl_multi_perform(multi_handle, &still_running);
+ CURLMcode mc = curl_multi_perform(multi, &still_running);
if(still_running)
/* wait for activity, timeout or "nothing" */
- mc = curl_multi_poll(multi_handle, NULL, 0, 1000, NULL);
+ mc = curl_multi_poll(multi, NULL, 0, 1000, NULL);
if(mc)
break;
*/
do {
int msgq = 0;
- m = curl_multi_info_read(multi_handle, &msgq);
+ m = curl_multi_info_read(multi, &msgq);
if(m && (m->msg == CURLMSG_DONE)) {
- CURL *e = m->easy_handle;
+ curl = m->easy_handle;
transfers--;
- curl_multi_remove_handle(multi_handle, e);
- curl_easy_cleanup(e);
+ curl_multi_remove_handle(multi, curl);
+ curl_easy_cleanup(curl);
}
} while(m);
error:
- if(multi_handle)
- curl_multi_cleanup(multi_handle);
+ if(multi)
+ curl_multi_cleanup(multi);
curl_global_cleanup();
FILE *in;
FILE *out;
size_t bytes_read; /* count up */
- CURL *easy;
+ CURL *curl;
int num;
};
}
}
-static int my_trace(CURL *handle, curl_infotype type,
+static int my_trace(CURL *curl, curl_infotype type,
char *data, size_t size, void *userp)
{
char timebuf[60];
struct timeval tv;
time_t secs;
struct tm *now;
- (void)handle;
+ (void)curl;
gettimeofday(&tv, NULL);
if(!known_offset) {
return 0;
}
-static size_t read_callback(char *ptr, size_t size, size_t nmemb, void *userp)
+static size_t read_cb(char *ptr, size_t size, size_t nmemb, void *userp)
{
struct input *i = userp;
size_t retcode = fread(ptr, size, nmemb, i->in);
char filename[128];
struct stat file_info;
curl_off_t uploadsize;
- CURL *easy;
+ CURL *curl;
- easy = t->easy = NULL;
+ curl = t->curl = NULL;
t->num = num;
snprintf(filename, sizeof(filename), "dl-%d", num);
uploadsize = file_info.st_size;
- easy = t->easy = curl_easy_init();
- if(easy) {
+ curl = t->curl = curl_easy_init();
+ if(curl) {
/* write to this file */
- curl_easy_setopt(easy, CURLOPT_WRITEDATA, t->out);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, t->out);
/* we want to use our own read function */
- curl_easy_setopt(easy, CURLOPT_READFUNCTION, read_callback);
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);
/* read from this file */
- curl_easy_setopt(easy, CURLOPT_READDATA, t);
+ curl_easy_setopt(curl, CURLOPT_READDATA, t);
/* provide the size of the upload */
- curl_easy_setopt(easy, CURLOPT_INFILESIZE_LARGE, uploadsize);
+ curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, uploadsize);
/* send in the URL to store the upload as */
- curl_easy_setopt(easy, CURLOPT_URL, url);
+ curl_easy_setopt(curl, CURLOPT_URL, url);
/* upload please */
- curl_easy_setopt(easy, CURLOPT_UPLOAD, 1L);
+ curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
/* please be verbose */
- curl_easy_setopt(easy, CURLOPT_VERBOSE, 1L);
- curl_easy_setopt(easy, CURLOPT_DEBUGFUNCTION, my_trace);
- curl_easy_setopt(easy, CURLOPT_DEBUGDATA, t);
+ curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+ curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
+ curl_easy_setopt(curl, CURLOPT_DEBUGDATA, t);
/* HTTP/2 please */
- curl_easy_setopt(easy, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
+ curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
/* we use a self-signed test server, skip verification during debugging */
- curl_easy_setopt(easy, CURLOPT_SSL_VERIFYPEER, 0L);
- curl_easy_setopt(easy, CURLOPT_SSL_VERIFYHOST, 0L);
+ curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
+ curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
#if (CURLPIPE_MULTIPLEX > 0)
/* wait for pipe connection to confirm */
- curl_easy_setopt(easy, CURLOPT_PIPEWAIT, 1L);
+ curl_easy_setopt(curl, CURLOPT_PIPEWAIT, 1L);
#endif
}
return 0;
{
CURLcode res;
struct input *trans;
- CURLM *multi_handle = NULL;
+ CURLM *multi = NULL;
int i;
const char *filename = "index.html";
int still_running = 0; /* keep number of running handles */
}
/* init a multi stack */
- multi_handle = curl_multi_init();
- if(!multi_handle)
+ multi = curl_multi_init();
+ if(!multi)
goto error;
for(i = 0; i < num_transfers; i++) {
}
/* add the individual transfer */
- curl_multi_add_handle(multi_handle, trans[i].easy);
+ curl_multi_add_handle(multi, trans[i].curl);
}
- curl_multi_setopt(multi_handle, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
+ curl_multi_setopt(multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
/* We do HTTP/2 so let's stick to one connection per host */
- curl_multi_setopt(multi_handle, CURLMOPT_MAX_HOST_CONNECTIONS, 1L);
+ curl_multi_setopt(multi, CURLMOPT_MAX_HOST_CONNECTIONS, 1L);
do {
- CURLMcode mc = curl_multi_perform(multi_handle, &still_running);
+ CURLMcode mc = curl_multi_perform(multi, &still_running);
if(still_running)
/* wait for activity, timeout or "nothing" */
- mc = curl_multi_poll(multi_handle, NULL, 0, 1000, NULL);
+ mc = curl_multi_poll(multi, NULL, 0, 1000, NULL);
if(mc)
break;
error:
- if(multi_handle) {
+ if(multi) {
for(i = 0; i < num_transfers; i++) {
- curl_multi_remove_handle(multi_handle, trans[i].easy);
- curl_easy_cleanup(trans[i].easy);
+ curl_multi_remove_handle(multi, trans[i].curl);
+ curl_easy_cleanup(trans[i].curl);
if(trans[i].in)
fclose(trans[i].in);
if(trans[i].out)
fclose(trans[i].out);
}
- curl_multi_cleanup(multi_handle);
+ curl_multi_cleanup(multi);
}
free(trans);
* http://www.apacheweek.com/features/put
*/
-static size_t read_callback(char *ptr, size_t size, size_t nmemb, void *stream)
+static size_t read_cb(char *ptr, size_t size, size_t nmemb, void *stream)
{
size_t retcode;
unsigned long nread;
curl = curl_easy_init();
if(curl) {
/* we want to use our own read function */
- curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);
/* enable uploading (implies PUT over HTTP) */
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
size_t bytes_read;
};
-static size_t payload_source(char *ptr, size_t size, size_t nmemb, void *userp)
+static size_t read_cb(char *ptr, size_t size, size_t nmemb, void *userp)
{
struct upload_status *upload_ctx = (struct upload_status *)userp;
const char *data;
/* In this case, we are using a callback function to specify the data. You
* could just use the CURLOPT_READDATA option to specify a FILE pointer to
* read from. */
- curl_easy_setopt(curl, CURLOPT_READFUNCTION, payload_source);
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);
curl_easy_setopt(curl, CURLOPT_READDATA, &upload_ctx);
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
curl = curl_easy_init();
if(curl) {
- CURLM *mcurl;
+ CURLM *multi;
- mcurl = curl_multi_init();
- if(mcurl) {
+ multi = curl_multi_init();
+ if(multi) {
int still_running = 1;
/* Set username and password */
"INBOX/;UID=1");
/* Tell the multi stack about our easy handle */
- curl_multi_add_handle(mcurl, curl);
+ curl_multi_add_handle(multi, curl);
do {
- CURLMcode mc = curl_multi_perform(mcurl, &still_running);
+ CURLMcode mc = curl_multi_perform(multi, &still_running);
if(still_running)
/* wait for activity, timeout or "nothing" */
- mc = curl_multi_poll(mcurl, NULL, 0, 1000, NULL);
+ mc = curl_multi_poll(multi, NULL, 0, 1000, NULL);
if(mc)
break;
} while(still_running);
/* Always cleanup */
- curl_multi_remove_handle(mcurl, curl);
- curl_multi_cleanup(mcurl);
+ curl_multi_remove_handle(multi, curl);
+ curl_multi_cleanup(multi);
}
curl_easy_cleanup(curl);
}
return -1;
}
-static int mydebug(CURL *handle, curl_infotype type,
+static int mydebug(CURL *curl, curl_infotype type,
char *data, size_t size, void *userdata)
{
struct transfer *t = (struct transfer *)userdata;
static const char s_infotype[CURLINFO_END][3] = {
"* ", "< ", "> ", "{ ", "} ", "{ ", "} " };
- (void)handle;
+ (void)curl;
switch(type) {
case CURLINFO_TEXT:
return 0;
}
-static size_t mywrite(char *ptr, size_t size, size_t nmemb, void *userdata)
+static size_t write_cb(char *ptr, size_t size, size_t nmemb, void *userdata)
{
struct transfer *t = (struct transfer *)userdata;
curl_easy_setopt(t->curl, CURLOPT_DEBUGDATA, t);
/* Enable writing the body to a file */
- curl_easy_setopt(t->curl, CURLOPT_WRITEFUNCTION, mywrite);
+ curl_easy_setopt(t->curl, CURLOPT_WRITEFUNCTION, write_cb);
curl_easy_setopt(t->curl, CURLOPT_WRITEDATA, t);
/* Enable immediate error on HTTP status codes >= 400 in most cases,
int main(void)
{
- CURL *handles[HANDLECOUNT];
- CURLM *multi_handle;
+ CURL *curl[HANDLECOUNT];
+ CURLM *multi;
int i;
/* Allocate one curl handle per transfer */
for(i = 0; i < HANDLECOUNT; i++)
- handles[i] = curl_easy_init();
+ curl[i] = curl_easy_init();
/* set the options (I left out a few, you get the point anyway) */
- curl_easy_setopt(handles[HTTP_HANDLE], CURLOPT_URL, "https://example.com");
+ curl_easy_setopt(curl[HTTP_HANDLE], CURLOPT_URL, "https://example.com");
- curl_easy_setopt(handles[FTP_HANDLE], CURLOPT_URL, "ftp://example.com");
- curl_easy_setopt(handles[FTP_HANDLE], CURLOPT_UPLOAD, 1L);
+ curl_easy_setopt(curl[FTP_HANDLE], CURLOPT_URL, "ftp://example.com");
+ curl_easy_setopt(curl[FTP_HANDLE], CURLOPT_UPLOAD, 1L);
/* init a multi stack */
- multi_handle = curl_multi_init();
- if(multi_handle) {
+ multi = curl_multi_init();
+ if(multi) {
int still_running = 1; /* keep number of running handles */
/* add the individual transfers */
for(i = 0; i < HANDLECOUNT; i++)
- curl_multi_add_handle(multi_handle, handles[i]);
+ curl_multi_add_handle(multi, curl[i]);
while(still_running) {
- CURLMcode mc = curl_multi_perform(multi_handle, &still_running);
+ CURLMcode mc = curl_multi_perform(multi, &still_running);
if(still_running)
/* wait for activity, timeout or "nothing" */
- mc = curl_multi_poll(multi_handle, NULL, 0, 1000, NULL);
+ mc = curl_multi_poll(multi, NULL, 0, 1000, NULL);
if(mc)
break;
/* See how the transfers went */
/* !checksrc! disable EQUALSNULL 1 */
- while((msg = curl_multi_info_read(multi_handle, &msgs_left)) != NULL) {
+ while((msg = curl_multi_info_read(multi, &msgs_left)) != NULL) {
if(msg->msg == CURLMSG_DONE) {
int idx;
/* Find out which handle this message is about */
for(idx = 0; idx < HANDLECOUNT; idx++) {
- int found = (msg->easy_handle == handles[idx]);
+ int found = (msg->easy_handle == curl[idx]);
if(found)
break;
}
/* remove the transfers */
for(i = 0; i < HANDLECOUNT; i++)
- curl_multi_remove_handle(multi_handle, handles[i]);
+ curl_multi_remove_handle(multi, curl[i]);
- curl_multi_cleanup(multi_handle);
+ curl_multi_cleanup(multi);
}
/* Free the curl handles */
for(i = 0; i < HANDLECOUNT; i++)
- curl_easy_cleanup(handles[i]);
+ curl_easy_cleanup(curl[i]);
curl_global_cleanup();
fflush(stream);
}
-static int my_trace(CURL *handle, curl_infotype type,
+static int my_trace(CURL *curl, curl_infotype type,
unsigned char *data, size_t size,
void *userp)
{
const char *text;
(void)userp;
- (void)handle;
+ (void)curl;
switch(type) {
case CURLINFO_TEXT:
*/
int main(void)
{
- CURL *http_handle;
+ CURL *curl;
CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
if(res)
return (int)res;
- http_handle = curl_easy_init();
- if(http_handle) {
+ curl = curl_easy_init();
+ if(curl) {
- CURLM *multi_handle;
+ CURLM *multi;
/* set the options (I left out a few, you get the point anyway) */
- curl_easy_setopt(http_handle, CURLOPT_URL, "https://www.example.com/");
+ curl_easy_setopt(curl, CURLOPT_URL, "https://www.example.com/");
- curl_easy_setopt(http_handle, CURLOPT_DEBUGFUNCTION, my_trace);
- curl_easy_setopt(http_handle, CURLOPT_VERBOSE, 1L);
+ curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
+ curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
/* init a multi stack */
- multi_handle = curl_multi_init();
- if(multi_handle) {
+ multi = curl_multi_init();
+ if(multi) {
int still_running = 0; /* keep number of running handles */
/* add the individual transfers */
- curl_multi_add_handle(multi_handle, http_handle);
+ curl_multi_add_handle(multi, curl);
do {
- CURLMcode mc = curl_multi_perform(multi_handle, &still_running);
+ CURLMcode mc = curl_multi_perform(multi, &still_running);
if(still_running)
/* wait for activity, timeout or "nothing" */
- mc = curl_multi_poll(multi_handle, NULL, 0, 1000, NULL);
+ mc = curl_multi_poll(multi, NULL, 0, 1000, NULL);
if(mc)
break;
} while(still_running);
- curl_multi_cleanup(multi_handle);
+ curl_multi_cleanup(multi);
}
- curl_easy_cleanup(http_handle);
+ curl_easy_cleanup(curl);
}
curl_global_cleanup();
*/
int main(void)
{
- CURL *http_handle;
- CURL *http_handle2;
+ CURL *curl;
+ CURL *curl2;
CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
if(res)
return (int)res;
- http_handle = curl_easy_init();
- http_handle2 = curl_easy_init();
+ curl = curl_easy_init();
+ curl2 = curl_easy_init();
- if(http_handle &&
- http_handle2) {
+ if(curl && curl2) {
- CURLM *multi_handle;
+ CURLM *multi;
/* set options */
- curl_easy_setopt(http_handle, CURLOPT_URL, "https://www.example.com/");
+ curl_easy_setopt(curl, CURLOPT_URL, "https://www.example.com/");
/* set options */
- curl_easy_setopt(http_handle2, CURLOPT_URL, "http://localhost/");
+ curl_easy_setopt(curl2, CURLOPT_URL, "http://localhost/");
/* init a multi stack */
- multi_handle = curl_multi_init();
- if(multi_handle) {
+ multi = curl_multi_init();
+ if(multi) {
int still_running = 1; /* keep number of running handles */
/* add the individual transfers */
- curl_multi_add_handle(multi_handle, http_handle);
- curl_multi_add_handle(multi_handle, http_handle2);
+ curl_multi_add_handle(multi, curl);
+ curl_multi_add_handle(multi, curl2);
while(still_running) {
CURLMsg *msg;
int queued;
- CURLMcode mc = curl_multi_perform(multi_handle, &still_running);
+ CURLMcode mc = curl_multi_perform(multi, &still_running);
if(still_running)
/* wait for activity, timeout or "nothing" */
- mc = curl_multi_poll(multi_handle, NULL, 0, 1000, NULL);
+ mc = curl_multi_poll(multi, NULL, 0, 1000, NULL);
if(mc)
break;
do {
- msg = curl_multi_info_read(multi_handle, &queued);
+ msg = curl_multi_info_read(multi, &queued);
if(msg) {
if(msg->msg == CURLMSG_DONE) {
/* a transfer ended */
} while(msg);
}
- curl_multi_remove_handle(multi_handle, http_handle);
- curl_multi_remove_handle(multi_handle, http_handle2);
+ curl_multi_remove_handle(multi, curl);
+ curl_multi_remove_handle(multi, curl2);
- curl_multi_cleanup(multi_handle);
+ curl_multi_cleanup(multi);
}
}
- curl_easy_cleanup(http_handle);
- curl_easy_cleanup(http_handle2);
+ curl_easy_cleanup(curl);
+ curl_easy_cleanup(curl2);
curl_global_cleanup();
#include <curl/curl.h>
static struct event_base *base;
-static CURLM *curl_handle;
+static CURLM *multi;
static struct event *timeout;
struct curl_context {
{
char filename[50];
FILE *file;
- CURL *handle;
+ CURL *curl;
snprintf(filename, sizeof(filename), "%d.download", num);
return;
}
- handle = curl_easy_init();
- curl_easy_setopt(handle, CURLOPT_WRITEDATA, file);
- curl_easy_setopt(handle, CURLOPT_PRIVATE, file);
- curl_easy_setopt(handle, CURLOPT_URL, url);
- curl_multi_add_handle(curl_handle, handle);
+ curl = curl_easy_init();
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, file);
+ curl_easy_setopt(curl, CURLOPT_PRIVATE, file);
+ curl_easy_setopt(curl, CURLOPT_URL, url);
+ curl_multi_add_handle(multi, curl);
fprintf(stderr, "Added download %s -> %s\n", url, filename);
}
char *done_url;
CURLMsg *message;
int pending;
- CURL *easy_handle;
+ CURL *curl;
FILE *file;
- while((message = curl_multi_info_read(curl_handle, &pending))) {
+ while((message = curl_multi_info_read(multi, &pending))) {
switch(message->msg) {
case CURLMSG_DONE:
/* Do not use message data after calling curl_multi_remove_handle() and
"WARNING: The data the returned pointer points to does not survive
calling curl_multi_cleanup, curl_multi_remove_handle or
curl_easy_cleanup." */
- easy_handle = message->easy_handle;
+ curl = message->easy_handle;
- curl_easy_getinfo(easy_handle, CURLINFO_EFFECTIVE_URL, &done_url);
- curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, &file);
+ curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &done_url);
+ curl_easy_getinfo(curl, CURLINFO_PRIVATE, &file);
printf("%s DONE\n", done_url);
- curl_multi_remove_handle(curl_handle, easy_handle);
- curl_easy_cleanup(easy_handle);
+ curl_multi_remove_handle(multi, curl);
+ curl_easy_cleanup(curl);
if(file) {
fclose(file);
}
context = (struct curl_context *) arg;
- curl_multi_socket_action(curl_handle, context->sockfd, flags,
+ curl_multi_socket_action(multi, context->sockfd, flags,
&running_handles);
check_multi_info();
(void)fd;
(void)events;
(void)arg;
- curl_multi_socket_action(curl_handle, CURL_SOCKET_TIMEOUT, 0,
+ curl_multi_socket_action(multi, CURL_SOCKET_TIMEOUT, 0,
&running_handles);
check_multi_info();
}
return 0;
}
-static int handle_socket(CURL *easy, curl_socket_t s, int action, void *userp,
+static int handle_socket(CURL *curl, curl_socket_t s, int action, void *userp,
void *socketp)
{
struct curl_context *curl_context;
int events = 0;
- (void)easy;
+ (void)curl;
(void)userp;
switch(action) {
curl_context = socketp ?
(struct curl_context *) socketp : create_curl_context(s);
- curl_multi_assign(curl_handle, s, (void *) curl_context);
+ curl_multi_assign(multi, s, (void *) curl_context);
if(action != CURL_POLL_IN)
events |= EV_WRITE;
if(socketp) {
event_del(((struct curl_context*) socketp)->event);
destroy_curl_context((struct curl_context*) socketp);
- curl_multi_assign(curl_handle, s, NULL);
+ curl_multi_assign(multi, s, NULL);
}
break;
default:
base = event_base_new();
timeout = evtimer_new(base, on_timeout, NULL);
- curl_handle = curl_multi_init();
- if(curl_handle) {
- curl_multi_setopt(curl_handle, CURLMOPT_SOCKETFUNCTION, handle_socket);
- curl_multi_setopt(curl_handle, CURLMOPT_TIMERFUNCTION, start_timeout);
+ multi = curl_multi_init();
+ if(multi) {
+ curl_multi_setopt(multi, CURLMOPT_SOCKETFUNCTION, handle_socket);
+ curl_multi_setopt(multi, CURLMOPT_TIMERFUNCTION, start_timeout);
while(argc-- > 1) {
add_download(argv[argc], argc);
event_base_dispatch(base);
- curl_multi_cleanup(curl_handle);
+ curl_multi_cleanup(multi);
}
event_free(timeout);
event_base_free(base);
curl = curl_easy_init();
if(curl) {
- CURLM *multi_handle;
+ CURLM *multi;
- multi_handle = curl_multi_init();
- if(multi_handle) {
+ multi = curl_multi_init();
+ if(multi) {
int still_running = 0;
curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
)
- curl_multi_add_handle(multi_handle, curl);
+ curl_multi_add_handle(multi, curl);
do {
- CURLMcode mc = curl_multi_perform(multi_handle, &still_running);
+ CURLMcode mc = curl_multi_perform(multi, &still_running);
if(still_running)
/* wait for activity, timeout or "nothing" */
- mc = curl_multi_poll(multi_handle, NULL, 0, 1000, NULL);
+ mc = curl_multi_poll(multi, NULL, 0, 1000, NULL);
if(mc)
break;
} while(still_running);
- curl_multi_cleanup(multi_handle);
+ curl_multi_cleanup(multi);
}
/* always cleanup */
int main(void)
{
- CURL *handles[HANDLECOUNT];
- CURLM *multi_handle;
+ CURL *curl[HANDLECOUNT];
+ CURLM *multi;
int i;
/* Allocate one curl handle per transfer */
for(i = 0; i < HANDLECOUNT; i++)
- handles[i] = curl_easy_init();
+ curl[i] = curl_easy_init();
/* set the options (I left out a few, you get the point anyway) */
- curl_easy_setopt(handles[HTTP_HANDLE], CURLOPT_URL, "https://example.com");
+ curl_easy_setopt(curl[HTTP_HANDLE], CURLOPT_URL, "https://example.com");
- curl_easy_setopt(handles[FTP_HANDLE], CURLOPT_URL, "ftp://example.com");
- curl_easy_setopt(handles[FTP_HANDLE], CURLOPT_UPLOAD, 1L);
+ curl_easy_setopt(curl[FTP_HANDLE], CURLOPT_URL, "ftp://example.com");
+ curl_easy_setopt(curl[FTP_HANDLE], CURLOPT_UPLOAD, 1L);
/* init a multi stack */
- multi_handle = curl_multi_init();
- if(multi_handle) {
+ multi = curl_multi_init();
+ if(multi) {
int still_running = 0; /* keep number of running handles */
/* add the individual transfers */
for(i = 0; i < HANDLECOUNT; i++)
- curl_multi_add_handle(multi_handle, handles[i]);
+ curl_multi_add_handle(multi, curl[i]);
/* we start some action by calling perform right away */
- curl_multi_perform(multi_handle, &still_running);
+ curl_multi_perform(multi, &still_running);
while(still_running) {
timeout.tv_sec = 1;
timeout.tv_usec = 0;
- curl_multi_timeout(multi_handle, &curl_timeo);
+ curl_multi_timeout(multi, &curl_timeo);
if(curl_timeo >= 0) {
#if defined(MSDOS) || defined(__AMIGA__)
timeout.tv_sec = (time_t)(curl_timeo / 1000);
}
/* get file descriptors from the transfers */
- mc = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
+ mc = curl_multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd);
if(mc != CURLM_OK) {
fprintf(stderr, "curl_multi_fdset() failed, code %d.\n", mc);
break;
case 0: /* timeout */
default: /* action */
- curl_multi_perform(multi_handle, &still_running);
+ curl_multi_perform(multi, &still_running);
break;
}
}
/* See how the transfers went */
/* !checksrc! disable EQUALSNULL 1 */
- while((msg = curl_multi_info_read(multi_handle, &msgs_left)) != NULL) {
+ while((msg = curl_multi_info_read(multi, &msgs_left)) != NULL) {
if(msg->msg == CURLMSG_DONE) {
int idx;
/* Find out which handle this message is about */
for(idx = 0; idx < HANDLECOUNT; idx++) {
- int found = (msg->easy_handle == handles[idx]);
+ int found = (msg->easy_handle == curl[idx]);
if(found)
break;
}
}
}
- curl_multi_cleanup(multi_handle);
+ curl_multi_cleanup(multi);
}
/* Free the curl handles */
for(i = 0; i < HANDLECOUNT; i++)
- curl_easy_cleanup(handles[i]);
+ curl_easy_cleanup(curl[i]);
curl_global_cleanup();
curl = curl_easy_init();
if(curl) {
- CURLM *multi_handle;
+ CURLM *multi;
- multi_handle = curl_multi_init();
- if(multi_handle) {
+ multi = curl_multi_init();
+ if(multi) {
int still_running = 0;
/* Create the form */
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist);
curl_easy_setopt(curl, CURLOPT_MIMEPOST, form);
- curl_multi_add_handle(multi_handle, curl);
+ curl_multi_add_handle(multi, curl);
do {
- CURLMcode mc = curl_multi_perform(multi_handle, &still_running);
+ CURLMcode mc = curl_multi_perform(multi, &still_running);
if(still_running)
/* wait for activity, timeout or "nothing" */
- mc = curl_multi_poll(multi_handle, NULL, 0, 1000, NULL);
+ mc = curl_multi_poll(multi, NULL, 0, 1000, NULL);
if(mc)
break;
} while(still_running);
- curl_multi_cleanup(multi_handle);
+ curl_multi_cleanup(multi);
}
/* always cleanup */
*/
int main(void)
{
- CURL *http_handle;
+ CURL *curl;
CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
if(res)
return (int)res;
- http_handle = curl_easy_init();
- if(http_handle) {
+ curl = curl_easy_init();
+ if(curl) {
- CURLM *multi_handle;
+ CURLM *multi;
int still_running = 1; /* keep number of running handles */
/* set the options (I left out a few, you get the point anyway) */
- curl_easy_setopt(http_handle, CURLOPT_URL, "https://www.example.com/");
+ curl_easy_setopt(curl, CURLOPT_URL, "https://www.example.com/");
/* init a multi stack */
- multi_handle = curl_multi_init();
- if(multi_handle) {
+ multi = curl_multi_init();
+ if(multi) {
/* add the individual transfers */
- curl_multi_add_handle(multi_handle, http_handle);
+ curl_multi_add_handle(multi, curl);
do {
- CURLMcode mc = curl_multi_perform(multi_handle, &still_running);
+ CURLMcode mc = curl_multi_perform(multi, &still_running);
if(!mc)
/* wait for activity, timeout or "nothing" */
- mc = curl_multi_poll(multi_handle, NULL, 0, 1000, NULL);
+ mc = curl_multi_poll(multi, NULL, 0, 1000, NULL);
if(mc) {
fprintf(stderr, "curl_multi_poll() failed, code %d.\n", (int)mc);
} while(still_running);
- curl_multi_remove_handle(multi_handle, http_handle);
+ curl_multi_remove_handle(multi, curl);
- curl_multi_cleanup(multi_handle);
+ curl_multi_cleanup(multi);
}
- curl_easy_cleanup(http_handle);
+ curl_easy_cleanup(curl);
}
curl_global_cleanup();
{
char filename[50];
FILE *file;
- CURL *handle;
+ CURL *curl;
snprintf(filename, sizeof(filename), "%d.download", num);
return;
}
- handle = curl_easy_init();
- curl_easy_setopt(handle, CURLOPT_WRITEDATA, file);
- curl_easy_setopt(handle, CURLOPT_PRIVATE, file);
- curl_easy_setopt(handle, CURLOPT_URL, url);
- curl_multi_add_handle(multi, handle);
+ curl = curl_easy_init();
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, file);
+ curl_easy_setopt(curl, CURLOPT_PRIVATE, file);
+ curl_easy_setopt(curl, CURLOPT_URL, url);
+ curl_multi_add_handle(multi, curl);
fprintf(stderr, "Added download %s -> %s\n", url, filename);
}
char *done_url;
CURLMsg *message;
int pending;
- CURL *easy_handle;
+ CURL *curl;
FILE *file;
while((message = curl_multi_info_read(context->uv->multi, &pending))) {
"WARNING: The data the returned pointer points to does not survive
calling curl_multi_cleanup, curl_multi_remove_handle or
curl_easy_cleanup." */
- easy_handle = message->easy_handle;
+ curl = message->easy_handle;
- curl_easy_getinfo(easy_handle, CURLINFO_EFFECTIVE_URL, &done_url);
- curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, &file);
+ curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &done_url);
+ curl_easy_getinfo(curl, CURLINFO_PRIVATE, &file);
printf("%s DONE\n", done_url);
- curl_multi_remove_handle(context->uv->multi, easy_handle);
- curl_easy_cleanup(easy_handle);
+ curl_multi_remove_handle(context->uv->multi, curl);
+ curl_easy_cleanup(curl);
if(file) {
fclose(file);
}
}
/* callback from libcurl to update socket activity to wait for */
-static int cb_socket(CURL *easy, curl_socket_t s, int action,
+static int cb_socket(CURL *curl, curl_socket_t s, int action,
void *userp, void *socketp)
{
struct datauv *uv = (struct datauv *)userp;
struct curl_context *curl_context;
int events = 0;
- (void)easy;
+ (void)curl;
switch(action) {
case CURL_POLL_IN:
curl = curl_easy_init();
if(curl) {
- CURLM *mcurl;
+ CURLM *multi;
- mcurl = curl_multi_init();
- if(mcurl) {
+ multi = curl_multi_init();
+ if(multi) {
int still_running = 1;
/* Set username and password */
curl_easy_setopt(curl, CURLOPT_URL, "pop3://pop.example.com/1");
/* Tell the multi stack about our easy handle */
- curl_multi_add_handle(mcurl, curl);
+ curl_multi_add_handle(multi, curl);
do {
- CURLMcode mc = curl_multi_perform(mcurl, &still_running);
+ CURLMcode mc = curl_multi_perform(multi, &still_running);
if(still_running)
/* wait for activity, timeout or "nothing" */
- mc = curl_multi_poll(mcurl, NULL, 0, 1000, NULL);
+ mc = curl_multi_poll(multi, NULL, 0, 1000, NULL);
if(mc)
break;
} while(still_running);
/* Always cleanup */
- curl_multi_remove_handle(mcurl, curl);
- curl_multi_cleanup(mcurl);
+ curl_multi_remove_handle(multi, curl);
+ curl_multi_cleanup(multi);
}
curl_easy_cleanup(curl);
}
size_t sizeleft;
};
-static size_t read_callback(char *dest, size_t size, size_t nmemb, void *userp)
+static size_t read_cb(char *dest, size_t size, size_t nmemb, void *userp)
{
struct WriteThis *wt = (struct WriteThis *)userp;
size_t buffer_size = size*nmemb;
curl_easy_setopt(curl, CURLOPT_POST, 1L);
/* we want to use our own read function */
- curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);
/* pointer to pass to our read function */
curl_easy_setopt(curl, CURLOPT_READDATA, &wt);
size_t size;
};
-static size_t WriteMemoryCallback(void *contents, size_t size, size_t nmemb,
+static size_t write_cb(void *contents, size_t size, size_t nmemb,
void *userp)
{
size_t realsize = size * nmemb;
curl_easy_setopt(curl, CURLOPT_URL, "https://www.example.org/");
/* send all data to this function */
- curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
#include <curl/curl.h>
-static size_t write_data(void *ptr, size_t size, size_t nmemb, void *stream)
+static size_t write_cb(void *ptr, size_t size, size_t nmemb, void *stream)
{
size_t written = fwrite(ptr, size, nmemb, (FILE *)stream);
return written;
int main(void)
{
- CURL *curl_handle;
+ CURL *curl;
CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
if(res)
return (int)res;
/* init the curl session */
- curl_handle = curl_easy_init();
- if(curl_handle) {
+ curl = curl_easy_init();
+ if(curl) {
static const char *headerfilename = "head.out";
FILE *headerfile;
static const char *bodyfilename = "body.out";
FILE *bodyfile;
/* set URL to get */
- curl_easy_setopt(curl_handle, CURLOPT_URL, "https://example.com");
+ curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
/* no progress meter please */
- curl_easy_setopt(curl_handle, CURLOPT_NOPROGRESS, 1L);
+ curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
/* send all data to this function */
- curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, write_data);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
/* open the header file */
headerfile = fopen(headerfilename, "wb");
if(!headerfile) {
- curl_easy_cleanup(curl_handle);
+ curl_easy_cleanup(curl);
curl_global_cleanup();
return -1;
}
/* open the body file */
bodyfile = fopen(bodyfilename, "wb");
if(!bodyfile) {
- curl_easy_cleanup(curl_handle);
+ curl_easy_cleanup(curl);
fclose(headerfile);
curl_global_cleanup();
return -1;
}
/* we want the headers be written to this file handle */
- curl_easy_setopt(curl_handle, CURLOPT_HEADERDATA, headerfile);
+ curl_easy_setopt(curl, CURLOPT_HEADERDATA, headerfile);
/* we want the body be written to this file handle instead of stdout */
- curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, bodyfile);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, bodyfile);
/* get it! */
- res = curl_easy_perform(curl_handle);
+ res = curl_easy_perform(curl);
/* close the header file */
fclose(headerfile);
fclose(bodyfile);
/* cleanup curl stuff */
- curl_easy_cleanup(curl_handle);
+ curl_easy_cleanup(curl);
}
curl_global_cleanup();
static CURL *curl;
-static size_t wrfu(void *ptr, size_t size, size_t nmemb, void *stream)
+static size_t write_cb(void *ptr, size_t size, size_t nmemb, void *stream)
{
const struct curl_tlssessioninfo *info;
CURLcode res;
curl = curl_easy_init();
if(curl) {
curl_easy_setopt(curl, CURLOPT_URL, "https://www.example.com/");
- curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, wrfu);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 0L);
res = curl_easy_perform(curl);
FILE *stream;
};
-static size_t my_fwrite(void *buffer, size_t size, size_t nmemb,
+static size_t write_cb(void *buffer, size_t size, size_t nmemb,
void *stream)
{
struct FtpFile *out = (struct FtpFile *)stream;
curl_easy_setopt(curl, CURLOPT_URL,
"sftp://user@server/home/user/file.txt");
/* Define our callback to get called when there is data to be written */
- curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, my_fwrite);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
/* Set a pointer to our struct to pass to the callback */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &ftpfile);
#include <curl/curl.h>
/* read data to upload */
-static size_t readfunc(char *ptr, size_t size, size_t nmemb, void *stream)
+static size_t read_cb(char *ptr, size_t size, size_t nmemb, void *stream)
{
FILE *f = (FILE *)stream;
size_t n;
static curl_off_t sftpGetRemoteFileSize(const char *i_remoteFile)
{
curl_off_t remoteFileSizeByte = -1;
- CURL *curlHandlePtr = curl_easy_init();
+ CURL *curl = curl_easy_init();
- if(curlHandlePtr) {
+ if(curl) {
CURLcode result;
- curl_easy_setopt(curlHandlePtr, CURLOPT_VERBOSE, 1L);
+ curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
- curl_easy_setopt(curlHandlePtr, CURLOPT_URL, i_remoteFile);
- curl_easy_setopt(curlHandlePtr, CURLOPT_NOPROGRESS, 1L);
- curl_easy_setopt(curlHandlePtr, CURLOPT_NOBODY, 1L);
- curl_easy_setopt(curlHandlePtr, CURLOPT_HEADER, 1L);
- curl_easy_setopt(curlHandlePtr, CURLOPT_FILETIME, 1L);
+ curl_easy_setopt(curl, CURLOPT_URL, i_remoteFile);
+ curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
+ curl_easy_setopt(curl, CURLOPT_NOBODY, 1L);
+ curl_easy_setopt(curl, CURLOPT_HEADER, 1L);
+ curl_easy_setopt(curl, CURLOPT_FILETIME, 1L);
- result = curl_easy_perform(curlHandlePtr);
+ result = curl_easy_perform(curl);
if(CURLE_OK == result) {
- result = curl_easy_getinfo(curlHandlePtr,
+ result = curl_easy_getinfo(curl,
CURLINFO_CONTENT_LENGTH_DOWNLOAD_T,
&remoteFileSizeByte);
if(result)
return -1;
printf("filesize: %" CURL_FORMAT_CURL_OFF_T "\n", remoteFileSizeByte);
}
- curl_easy_cleanup(curlHandlePtr);
+ curl_easy_cleanup(curl);
}
return remoteFileSizeByte;
}
-static int sftpResumeUpload(CURL *curlhandle, const char *remotepath,
+static int sftpResumeUpload(CURL *curl, const char *remotepath,
const char *localpath)
{
FILE *f = NULL;
return 0;
}
- curl_easy_setopt(curlhandle, CURLOPT_UPLOAD, 1L);
- curl_easy_setopt(curlhandle, CURLOPT_URL, remotepath);
- curl_easy_setopt(curlhandle, CURLOPT_READFUNCTION, readfunc);
- curl_easy_setopt(curlhandle, CURLOPT_READDATA, f);
+ curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
+ curl_easy_setopt(curl, CURLOPT_URL, remotepath);
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);
+ curl_easy_setopt(curl, CURLOPT_READDATA, f);
#if defined(_WIN32) && !defined(UNDER_CE)
_fseeki64(f, remoteFileSizeByte, SEEK_SET);
#else
fseek(f, (long)remoteFileSizeByte, SEEK_SET);
#endif
- curl_easy_setopt(curlhandle, CURLOPT_APPEND, 1L);
- result = curl_easy_perform(curlhandle);
+ curl_easy_setopt(curl, CURLOPT_APPEND, 1L);
+ result = curl_easy_perform(curl);
fclose(f);
int main(void)
{
- CURL *curlhandle = NULL;
+ CURL *curl = NULL;
CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
if(res)
return (int)res;
- curlhandle = curl_easy_init();
- if(curlhandle) {
+ curl = curl_easy_init();
+ if(curl) {
const char *remote = "sftp://user:pass@example.com/path/filename";
const char *filename = "filename";
- if(!sftpResumeUpload(curlhandle, remote, filename)) {
+ if(!sftpResumeUpload(curl, remote, filename)) {
printf("resumed upload using curl %s failed\n", curl_version());
}
- curl_easy_cleanup(curlhandle);
+ curl_easy_cleanup(curl);
}
curl_global_cleanup();
#include <stdio.h>
#include <curl/curl.h>
-static void my_lock(CURL *handle, curl_lock_data data,
+static void my_lock(CURL *curl, curl_lock_data data,
curl_lock_access laccess, void *useptr)
{
- (void)handle;
+ (void)curl;
(void)data;
(void)laccess;
(void)useptr;
fprintf(stderr, "-> Mutex lock\n");
}
-static void my_unlock(CURL *handle, curl_lock_data data, void *useptr)
+static void my_unlock(CURL *curl, curl_lock_data data, void *useptr)
{
- (void)handle;
+ (void)curl;
(void)data;
(void)useptr;
fprintf(stderr, "<- Mutex unlock\n");
"90030"
};
-size_t write_file(void *ptr, size_t size, size_t nmemb, FILE *stream)
+size_t write_cb(void *ptr, size_t size, size_t nmemb, FILE *stream)
{
return fwrite(ptr, size, nmemb, stream);
}
/* Write to the file */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, outfile);
- curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_file);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
(void)curl_easy_perform(curl);
fclose(outfile);
size_t bytes_read;
};
-static size_t payload_source(char *ptr, size_t size, size_t nmemb, void *userp)
+static size_t read_cb(char *ptr, size_t size, size_t nmemb, void *userp)
{
struct upload_status *upload_ctx = (struct upload_status *)userp;
const char *data;
/* We are using a callback function to specify the payload (the headers and
* body of the message). You could just use the CURLOPT_READDATA option to
* specify a FILE pointer to read from. */
- curl_easy_setopt(curl, CURLOPT_READFUNCTION, payload_source);
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);
curl_easy_setopt(curl, CURLOPT_READDATA, &upload_ctx);
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
size_t bytes_read;
};
-static size_t payload_source(char *ptr, size_t size, size_t nmemb, void *userp)
+static size_t read_cb(char *ptr, size_t size, size_t nmemb, void *userp)
{
struct upload_status *upload_ctx = (struct upload_status *)userp;
const char *data;
/* We are using a callback function to specify the payload (the headers and
* body of the message). You could just use the CURLOPT_READDATA option to
* specify a FILE pointer to read from. */
- curl_easy_setopt(curl, CURLOPT_READFUNCTION, payload_source);
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);
curl_easy_setopt(curl, CURLOPT_READDATA, &upload_ctx);
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
size_t bytes_read;
};
-static size_t payload_source(char *ptr, size_t size, size_t nmemb, void *userp)
+static size_t read_cb(char *ptr, size_t size, size_t nmemb, void *userp)
{
struct upload_status *upload_ctx = (struct upload_status *)userp;
const char *data;
curl = curl_easy_init();
if(curl) {
- CURLM *mcurl;
+ CURLM *multi;
- mcurl = curl_multi_init();
- if(mcurl) {
+ multi = curl_multi_init();
+ if(multi) {
int still_running = 1;
struct curl_slist *recipients = NULL;
struct upload_status upload_ctx = { 0 };
/* We are using a callback function to specify the payload (the headers
* and body of the message). You could just use the CURLOPT_READDATA
* option to specify a FILE pointer to read from. */
- curl_easy_setopt(curl, CURLOPT_READFUNCTION, payload_source);
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);
curl_easy_setopt(curl, CURLOPT_READDATA, &upload_ctx);
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
/* Tell the multi stack about our easy handle */
- curl_multi_add_handle(mcurl, curl);
+ curl_multi_add_handle(multi, curl);
do {
- CURLMcode mc = curl_multi_perform(mcurl, &still_running);
+ CURLMcode mc = curl_multi_perform(multi, &still_running);
if(still_running)
/* wait for activity, timeout or "nothing" */
- mc = curl_multi_poll(mcurl, NULL, 0, 1000, NULL);
+ mc = curl_multi_poll(multi, NULL, 0, 1000, NULL);
if(mc)
break;
curl_slist_free_all(recipients);
/* Always cleanup */
- curl_multi_remove_handle(mcurl, curl);
- curl_multi_cleanup(mcurl);
+ curl_multi_remove_handle(multi, curl);
+ curl_multi_cleanup(multi);
}
curl_easy_cleanup(curl);
}
size_t bytes_read;
};
-static size_t payload_source(char *ptr, size_t size, size_t nmemb, void *userp)
+static size_t read_cb(char *ptr, size_t size, size_t nmemb, void *userp)
{
struct upload_status *upload_ctx = (struct upload_status *)userp;
const char *data;
/* We are using a callback function to specify the payload (the headers and
* body of the message). You could just use the CURLOPT_READDATA option to
* specify a FILE pointer to read from. */
- curl_easy_setopt(curl, CURLOPT_READFUNCTION, payload_source);
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);
curl_easy_setopt(curl, CURLOPT_READDATA, &upload_ctx);
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
size_t bytes_read;
};
-static size_t payload_source(char *ptr, size_t size, size_t nmemb, void *userp)
+static size_t read_cb(char *ptr, size_t size, size_t nmemb, void *userp)
{
struct upload_status *upload_ctx = (struct upload_status *)userp;
const char *data;
/* We are using a callback function to specify the payload (the headers and
* body of the message). You could just use the CURLOPT_READDATA option to
* specify a FILE pointer to read from. */
- curl_easy_setopt(curl, CURLOPT_READFUNCTION, payload_source);
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);
curl_easy_setopt(curl, CURLOPT_READDATA, &upload_ctx);
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
#define HTTP_COMMAND_HEAD 0
#define HTTP_COMMAND_GET 1
-static size_t SyncTime_CURL_WriteOutput(void *ptr, size_t size, size_t nmemb,
+static size_t write_cb(void *ptr, size_t size, size_t nmemb,
void *stream)
{
fwrite(ptr, size, nmemb, stream);
curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, proxy_user_password);
curl_easy_setopt(curl, CURLOPT_USERAGENT, SYNCTIME_UA);
- curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, SyncTime_CURL_WriteOutput);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, SyncTime_CURL_WriteHeader);
}
#include <curl/curl.h>
-static size_t write_data(void *ptr, size_t size, size_t nmemb, void *stream)
+static size_t write_cb(void *ptr, size_t size, size_t nmemb, void *stream)
{
size_t written = fwrite(ptr, size, nmemb, (FILE *)stream);
return written;
static const char *pagefilename = "page.out";
CURLcode res;
- CURL *curl_handle;
+ CURL *curl;
if(argc < 2) {
printf("Usage: %s <URL>\n", argv[0]);
}
/* init the curl session */
- curl_handle = curl_easy_init();
- if(curl_handle) {
+ curl = curl_easy_init();
+ if(curl) {
FILE *pagefile;
/* set URL to get here */
- curl_easy_setopt(curl_handle, CURLOPT_URL, argv[1]);
+ curl_easy_setopt(curl, CURLOPT_URL, argv[1]);
/* Switch on full protocol/debug output while testing */
- curl_easy_setopt(curl_handle, CURLOPT_VERBOSE, 1L);
+ curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
/* disable progress meter, set to 0L to enable it */
- curl_easy_setopt(curl_handle, CURLOPT_NOPROGRESS, 1L);
+ curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
/* send all data to this function */
- curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, write_data);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
/* open the file */
pagefile = fopen(pagefilename, "wb");
if(pagefile) {
/* write the page body to this file handle */
- curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, pagefile);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, pagefile);
/* get it! */
- res = curl_easy_perform(curl_handle);
+ res = curl_easy_perform(curl);
/* close the header file */
fclose(pagefile);
}
/* cleanup curl stuff */
- curl_easy_cleanup(curl_handle);
+ curl_easy_cleanup(curl);
}
curl_global_cleanup();
int main(void)
{
- CURL *ch;
+ CURL *curl;
CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
if(res)
return (int)res;
- ch = curl_easy_init();
- if(ch) {
- curl_easy_setopt(ch, CURLOPT_VERBOSE, 0L);
- curl_easy_setopt(ch, CURLOPT_HEADER, 0L);
- curl_easy_setopt(ch, CURLOPT_NOPROGRESS, 1L);
- curl_easy_setopt(ch, CURLOPT_NOSIGNAL, 1L);
- curl_easy_setopt(ch, CURLOPT_WRITEFUNCTION, writefunction);
- curl_easy_setopt(ch, CURLOPT_WRITEDATA, stdout);
- curl_easy_setopt(ch, CURLOPT_HEADERFUNCTION, writefunction);
- curl_easy_setopt(ch, CURLOPT_HEADERDATA, stderr);
- curl_easy_setopt(ch, CURLOPT_SSLCERTTYPE, "PEM");
+ curl = curl_easy_init();
+ if(curl) {
+ curl_easy_setopt(curl, CURLOPT_VERBOSE, 0L);
+ curl_easy_setopt(curl, CURLOPT_HEADER, 0L);
+ curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
+ curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writefunction);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, stdout);
+ curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, writefunction);
+ curl_easy_setopt(curl, CURLOPT_HEADERDATA, stderr);
+ curl_easy_setopt(curl, CURLOPT_SSLCERTTYPE, "PEM");
/* both VERIFYPEER and VERIFYHOST are set to 0 in this case because there
is no CA certificate */
- curl_easy_setopt(ch, CURLOPT_SSL_VERIFYPEER, 0L);
- curl_easy_setopt(ch, CURLOPT_SSL_VERIFYHOST, 0L);
+ curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
+ curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
- curl_easy_setopt(ch, CURLOPT_URL, "https://www.example.com/");
- curl_easy_setopt(ch, CURLOPT_SSLKEYTYPE, "PEM");
+ curl_easy_setopt(curl, CURLOPT_URL, "https://www.example.com/");
+ curl_easy_setopt(curl, CURLOPT_SSLKEYTYPE, "PEM");
/* first try: retrieve page without user certificate and key -> fails */
- res = curl_easy_perform(ch);
+ res = curl_easy_perform(curl);
if(res == CURLE_OK)
printf("*** transfer succeeded ***\n");
else
* load the certificate and key by installing a function doing
* the necessary "modifications" to the SSL CONTEXT just before link init
*/
- curl_easy_setopt(ch, CURLOPT_SSL_CTX_FUNCTION, sslctx_function);
- res = curl_easy_perform(ch);
+ curl_easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION, sslctx_function);
+ res = curl_easy_perform(curl);
if(res == CURLE_OK)
printf("*** transfer succeeded ***\n");
else
printf("*** transfer failed ***\n");
- curl_easy_cleanup(ch);
+ curl_easy_cleanup(curl);
}
curl_global_cleanup();
return (int)res;
#include <stdio.h>
#include <curl/curl.h>
-static size_t writecb(char *b, size_t size, size_t nitems, void *p)
+static size_t write_cb(char *b, size_t size, size_t nitems, void *p)
{
- CURL *easy = p;
+ CURL *curl = p;
size_t i;
- const struct curl_ws_frame *frame = curl_ws_meta(easy);
+ const struct curl_ws_frame *frame = curl_ws_meta(curl);
fprintf(stderr, "Type: %s\n", frame->flags & CURLWS_BINARY ?
"binary" : "text");
fprintf(stderr, "Bytes: %u", (unsigned int)(nitems * size));
if(curl) {
curl_easy_setopt(curl, CURLOPT_URL, "wss://example.com");
- curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writecb);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
/* pass the easy handle to the callback */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, curl);
#include <string.h>
#include <curl/curl.h>
-static size_t writecb(char *b, size_t size, size_t nitems, void *p)
+static size_t write_cb(char *b, size_t size, size_t nitems, void *p)
{
- CURL *easy = p;
+ CURL *curl = p;
size_t i;
unsigned int blen = (unsigned int)(nitems * size);
- const struct curl_ws_frame *frame = curl_ws_meta(easy);
+ const struct curl_ws_frame *frame = curl_ws_meta(curl);
fprintf(stderr, "Type: %s\n", frame->flags & CURLWS_BINARY ?
"binary" : "text");
if(frame->flags & CURLWS_BINARY) {
}
struct read_ctx {
- CURL *easy;
+ CURL *curl;
char buf[1024];
size_t blen;
size_t nsent;
};
-static size_t readcb(char *buf, size_t nitems, size_t buflen, void *p)
+static size_t read_cb(char *buf, size_t nitems, size_t buflen, void *p)
{
struct read_ctx *ctx = p;
size_t len = nitems * buflen;
if(!ctx->nsent) {
/* On first call, set the FRAME information to be used (it defaults
* to CURLWS_BINARY otherwise). */
- result = curl_ws_start_frame(ctx->easy, CURLWS_TEXT,
+ result = curl_ws_start_frame(ctx->curl, CURLWS_TEXT,
(curl_off_t)ctx->blen);
if(result) {
fprintf(stderr, "error starting frame: %d\n", result);
int main(int argc, const char *argv[])
{
- CURL *easy;
+ CURL *curl;
struct read_ctx rctx;
const char *payload = "Hello, friend!";
memset(&rctx, 0, sizeof(rctx));
- easy = curl_easy_init();
- if(easy) {
+ curl = curl_easy_init();
+ if(curl) {
if(argc == 2)
- curl_easy_setopt(easy, CURLOPT_URL, argv[1]);
+ curl_easy_setopt(curl, CURLOPT_URL, argv[1]);
else
- curl_easy_setopt(easy, CURLOPT_URL, "wss://example.com");
+ curl_easy_setopt(curl, CURLOPT_URL, "wss://example.com");
- curl_easy_setopt(easy, CURLOPT_WRITEFUNCTION, writecb);
- curl_easy_setopt(easy, CURLOPT_WRITEDATA, easy);
- curl_easy_setopt(easy, CURLOPT_READFUNCTION, readcb);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, curl);
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);
/* tell curl that we want to send the payload */
- rctx.easy = easy;
+ rctx.curl = curl;
rctx.blen = strlen(payload);
memcpy(rctx.buf, payload, rctx.blen);
- curl_easy_setopt(easy, CURLOPT_READDATA, &rctx);
- curl_easy_setopt(easy, CURLOPT_UPLOAD, 1L);
+ curl_easy_setopt(curl, CURLOPT_READDATA, &rctx);
+ curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
/* Perform the request, res gets the return code */
- res = curl_easy_perform(easy);
+ res = curl_easy_perform(curl);
/* Check for errors */
if(res != CURLE_OK)
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
/* always cleanup */
- curl_easy_cleanup(easy);
+ curl_easy_cleanup(curl);
}
curl_global_cleanup();
return (int)res;
printf("%5lu %10lu %s\n", state->depth, state->characters.size, name);
}
-static size_t parseStreamCallback(void *contents, size_t length, size_t nmemb,
- void *userp)
+static size_t write_cb(void *contents, size_t length, size_t nmemb,
+ void *userp)
{
XML_Parser parser = (XML_Parser) userp;
size_t real_size = length * nmemb;
int main(void)
{
- CURL *curl_handle;
+ CURL *curl;
CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
if(res)
return (int)res;
/* Initialize a libcurl handle. */
- curl_handle = curl_easy_init();
+ curl = curl_easy_init();
if(curl) {
XML_Parser parser;
struct ParserStruct state;
XML_SetElementHandler(parser, startElement, endElement);
XML_SetCharacterDataHandler(parser, characterDataHandler);
- curl_easy_setopt(curl_handle, CURLOPT_URL,
+ curl_easy_setopt(curl, CURLOPT_URL,
"https://www.w3schools.com/xml/simple.xml");
- curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, parseStreamCallback);
- curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)parser);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)parser);
printf("Depth Characters Closing Tag\n");
/* Perform the request and any follow-up parsing. */
- res = curl_easy_perform(curl_handle);
+ res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
free(state.characters.memory);
XML_ParserFree(parser);
- curl_easy_cleanup(curl_handle);
+ curl_easy_cleanup(curl);
}
curl_global_cleanup();
projects / thirdparty / curl.git / commitdiff
