- add `curl_global_init()` and `curl_global_cleanup()` where missing.
- check the result of `curl_global_init()` where missing.
- return the last curl error from `main()`.
- drop Win32-specific socket initialization in favor of `curl_global_init()`.
- rename some outliers to `res` for curl result code.
- fix cleanup in some error cases.
Inspired by Joshua's report on examples.
Closes #19053
int msgs_left = -1;
int left = 0;
- curl_global_init(CURL_GLOBAL_ALL);
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
cm = curl_multi_init();
/* Limit the amount of simultaneous connections curl should allow: */
#if !defined(_WIN32) && !defined(MSDOS) && !defined(__AMIGA__)
/* Windows/MS-DOS users need to find how to use if_nametoindex() */
CURL *curl;
- CURLcode res;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
/* always cleanup */
curl_easy_cleanup(curl);
}
-#endif
+ curl_global_cleanup();
+ return (int)res;
+#else
return 0;
+#endif
}
int main(void)
{
CURL *curl;
- CURLcode res;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
/* always cleanup */
curl_easy_cleanup(curl);
}
- return 0;
+ curl_global_cleanup();
+ return (int)res;
}
#endif
/* In Windows, this inits the Winsock stuff */
- curl_global_init(CURL_GLOBAL_ALL);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res) {
+ fclose(fp);
+ return (int)res;
+ }
/* get a curl handle */
curl = curl_easy_init();
fclose(fp); /* close the local file */
curl_global_cleanup();
- return 0;
+ return (int)res;
}
if(!filter)
return 1;
- if(curl_global_init(CURL_GLOBAL_DEFAULT)) {
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res) {
free(filter);
- return 1;
+ return (int)res;
}
curl = curl_easy_init();
static CURLcode sslctx_function(CURL *curl, void *sslctx, void *pointer)
{
- CURLcode rv = CURLE_ABORTED_BY_CALLBACK;
-
/** This example uses two (fake) certificates **/
/* replace the XXX with the actual CA certificates */
static const char mypem[] =
(void)pointer;
if(!cts || !cbio) {
- return rv;
+ return CURLE_ABORTED_BY_CALLBACK;
}
inf = PEM_X509_INFO_read_bio(cbio, NULL, NULL, NULL);
if(!inf) {
BIO_free(cbio);
- return rv;
+ return CURLE_ABORTED_BY_CALLBACK;
}
for(i = 0; i < sk_X509_INFO_num(inf); i++) {
sk_X509_INFO_pop_free(inf, X509_INFO_free);
BIO_free(cbio);
- rv = CURLE_OK;
- return rv;
+ return CURLE_OK;
}
int main(void)
{
CURL *ch;
- CURLcode rv;
+ CURLcode res;
+
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
- curl_global_init(CURL_GLOBAL_ALL);
ch = curl_easy_init();
curl_easy_setopt(ch, CURLOPT_VERBOSE, 0L);
curl_easy_setopt(ch, CURLOPT_HEADER, 0L);
/* first try: retrieve page without ca certificates -> should fail
* unless libcurl was built --with-ca-fallback enabled at build-time
*/
- rv = curl_easy_perform(ch);
- if(rv == CURLE_OK)
+ res = curl_easy_perform(ch);
+ if(res == CURLE_OK)
printf("*** transfer succeeded ***\n");
else
printf("*** transfer failed ***\n");
* "modifications" to the SSL CONTEXT just before link init
*/
curl_easy_setopt(ch, CURLOPT_SSL_CTX_FUNCTION, sslctx_function);
- rv = curl_easy_perform(ch);
- if(rv == CURLE_OK)
+ res = curl_easy_perform(ch);
+ if(res == CURLE_OK)
printf("*** transfer succeeded ***\n");
else
printf("*** transfer failed ***\n");
curl_easy_cleanup(ch);
curl_global_cleanup();
- return (int)rv;
+ return (int)res;
}
CURL *curl;
CURLcode res;
- curl_global_init(CURL_GLOBAL_DEFAULT);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_global_cleanup();
- return 0;
+ return (int)res;
}
}
/* init libcurl */
- curl_global_init(CURL_GLOBAL_ALL);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
/* init the curl session */
curl_handle = curl_easy_init();
int main(void)
{
+ struct curl_slist *host;
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
/*
Each single string should be written using the format
*/
/* instead of curl.se:443, it resolves and uses example.com:443 but in other
aspects work as if it still is curl.se */
- struct curl_slist *host = curl_slist_append(NULL,
- "curl.se:443:example.com:443");
+ host = curl_slist_append(NULL, "curl.se:443:example.com:443");
curl = curl_easy_init();
if(curl) {
curl_slist_free_all(host);
+ curl_global_cleanup();
+
return (int)res;
}
CURL *curl;
CURLcode res;
- curl_global_init(CURL_GLOBAL_ALL);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
curl = curl_easy_init();
if(curl) {
char nline[512];
int pending;
int complete;
int still_running;
+ CURLcode res;
+
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
signal(SIGINT, sighandler);
LIBXML_TEST_VERSION
- curl_global_init(CURL_GLOBAL_DEFAULT);
multi_handle = curl_multi_init();
curl_multi_setopt(multi_handle, CURLMOPT_MAX_TOTAL_CONNECTIONS, max_con);
curl_multi_setopt(multi_handle, CURLMOPT_MAX_HOST_CONNECTIONS, 6L);
CURLcode res;
struct data config;
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
config.trace_ascii = 1; /* enable ASCII tracing */
curl = curl_easy_init();
/* always cleanup */
curl_easy_cleanup(curl);
}
- return 0;
+ curl_global_cleanup();
+ return (int)res;
}
CURL *curl;
CURLcode res;
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
curl = curl_easy_init();
if(curl) {
curl_easy_setopt(curl, CURLOPT_URL, "example.com");
/* always cleanup */
curl_easy_cleanup(curl);
}
- return 0;
+ curl_global_cleanup();
+ return (int)res;
}
int main(int argc, char **argv)
{
+ CURLcode res;
struct GlobalInfo g;
struct itimerspec its;
struct epoll_event ev;
(void)argc;
(void)argv;
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
g_should_exit_ = 0;
signal(SIGINT, sigint_handler);
g.epfd = epoll_create1(EPOLL_CLOEXEC);
if(g.epfd == -1) {
perror("epoll_create1 failed");
+ curl_global_cleanup();
return 1;
}
g.tfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);
if(g.tfd == -1) {
perror("timerfd_create failed");
+ curl_global_cleanup();
return 1;
}
ev.data.fd = g.tfd;
epoll_ctl(g.epfd, EPOLL_CTL_ADD, g.tfd, &ev);
- if(init_fifo(&g))
+ if(init_fifo(&g)) {
+ curl_global_cleanup();
return 1;
+ }
g.multi = curl_multi_init();
/* setup the generic multi interface options we want */
}
else {
perror("epoll_wait");
+ curl_global_cleanup();
return 1;
}
}
curl_multi_cleanup(g.multi);
clean_fifo(&g);
+ curl_global_cleanup();
return 0;
}
int main(int argc, char **argv)
{
+ CURLcode res;
struct GlobalInfo g;
(void)argc;
(void)argv;
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
memset(&g, 0, sizeof(g));
g.loop = ev_default_loop(0);
ev_loop(g.loop, 0);
curl_multi_cleanup(g.multi);
+ curl_global_cleanup();
return 0;
}
struct sockaddr_in servaddr; /* socket address structure */
curl_socket_t sockfd;
-#ifdef _WIN32
- WSADATA wsaData;
- int initwsa = WSAStartup(MAKEWORD(2, 2), &wsaData);
- if(initwsa) {
- printf("WSAStartup failed: %d\n", initwsa);
- return 1;
- }
-#endif
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
}
}
-#ifdef _WIN32
- WSACleanup();
-#endif
+ curl_global_cleanup();
+
return 0;
}
curl_off_t speed_upload, total_time;
FILE *fd;
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
fd = fopen("debugit", "rb"); /* open file to upload */
- if(!fd)
+ if(!fd) {
+ curl_global_cleanup();
return 1; /* cannot continue */
+ }
/* to get the file size */
#ifdef UNDER_CE
if(fstat(fileno(fd), &file_info) != 0) {
#endif
fclose(fd);
+ curl_global_cleanup();
return 1; /* cannot continue */
}
curl_easy_cleanup(curl);
}
fclose(fd);
+ curl_global_cleanup();
return 0;
}
return size * nmemb;
}
-
int main(void)
{
CURL *curl;
CURLcode res;
struct curl_slist *headerlist = NULL;
- curl_global_init(CURL_GLOBAL_DEFAULT);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_global_cleanup();
- return 0;
+ return (int)res;
}
FILE *output;
};
-static long file_is_coming(struct curl_fileinfo *finfo,
- void *data,
- int remains);
-
-static long file_is_downloaded(void *data);
-
-static size_t write_it(char *buff, size_t size, size_t nmemb,
- void *cb_data);
-
-int main(int argc, char **argv)
-{
- /* curl easy handle */
- CURL *handle;
-
- /* help data */
- struct callback_data data = { 0 };
-
- /* global initialization */
- CURLcode rc = curl_global_init(CURL_GLOBAL_ALL);
- if(rc)
- return (int)rc;
-
- /* initialization of easy handle */
- handle = curl_easy_init();
- if(!handle) {
- curl_global_cleanup();
- return CURLE_OUT_OF_MEMORY;
- }
-
- /* turn on wildcard matching */
- curl_easy_setopt(handle, CURLOPT_WILDCARDMATCH, 1L);
-
- /* callback is called before download of concrete file started */
- curl_easy_setopt(handle, 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);
-
- /* this callback writes contents into files */
- curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, write_it);
-
- /* put transfer data into callbacks */
- curl_easy_setopt(handle, CURLOPT_CHUNK_DATA, &data);
- curl_easy_setopt(handle, CURLOPT_WRITEDATA, &data);
-
- /* curl_easy_setopt(handle, 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]);
- else
- curl_easy_setopt(handle, CURLOPT_URL, "ftp://example.com/test/*");
-
- /* and start transfer! */
- rc = curl_easy_perform(handle);
-
- curl_easy_cleanup(handle);
- curl_global_cleanup();
- return (int)rc;
-}
-
static long file_is_coming(struct curl_fileinfo *finfo, void *input,
int remains)
{
written = fwrite(buff, size, nmemb, stdout);
return written;
}
+
+int main(int argc, char **argv)
+{
+ /* curl easy handle */
+ CURL *handle;
+
+ /* help data */
+ struct callback_data data = { 0 };
+
+ /* global initialization */
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
+ /* initialization of easy handle */
+ handle = curl_easy_init();
+ if(!handle) {
+ curl_global_cleanup();
+ return CURLE_OUT_OF_MEMORY;
+ }
+
+ /* turn on wildcard matching */
+ curl_easy_setopt(handle, CURLOPT_WILDCARDMATCH, 1L);
+
+ /* callback is called before download of concrete file started */
+ curl_easy_setopt(handle, 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);
+
+ /* this callback writes contents into files */
+ curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, write_it);
+
+ /* put transfer data into callbacks */
+ curl_easy_setopt(handle, CURLOPT_CHUNK_DATA, &data);
+ curl_easy_setopt(handle, CURLOPT_WRITEDATA, &data);
+
+ /* curl_easy_setopt(handle, 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]);
+ else
+ curl_easy_setopt(handle, CURLOPT_URL, "ftp://example.com/test/*");
+
+ /* and start transfer! */
+ res = curl_easy_perform(handle);
+
+ curl_easy_cleanup(handle);
+ curl_global_cleanup();
+ return (int)res;
+}
NULL
};
- curl_global_init(CURL_GLOBAL_DEFAULT);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_global_cleanup();
- return 0;
+ return (int)res;
}
curl_off_t filesize = 0;
const char *filename = strrchr(ftpurl, '/') + 1;
- curl_global_init(CURL_GLOBAL_DEFAULT);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_global_cleanup();
- return 0;
+ return (int)res;
}
FILE *ftpfile;
FILE *respfile;
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
/* local filename to store the file as */
ftpfile = fopen(FTPBODY, "wb"); /* b is binary, needed on Windows */
- if(!ftpfile)
+ if(!ftpfile) {
+ curl_global_cleanup();
return 1;
+ }
/* local filename to store the FTP server's response lines in */
respfile = fopen(FTPHEADERS, "wb"); /* b is binary, needed on Windows */
if(!respfile) {
fclose(ftpfile);
+ curl_global_cleanup();
return 1;
}
fclose(ftpfile); /* close the local file */
fclose(respfile); /* close the response file */
- return 0;
+ return (int)res;
}
NULL
};
- curl_global_init(CURL_GLOBAL_DEFAULT);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_global_cleanup();
- return 0;
+ return (int)res;
}
printf("Local file size: %lu bytes.\n", (unsigned long)fsize);
/* In Windows, this inits the Winsock stuff */
- curl_global_init(CURL_GLOBAL_ALL);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res) {
+ fclose(hd_src);
+ return (int)res;
+ }
/* get a curl handle */
curl = curl_easy_init();
fclose(hd_src); /* close the local file */
curl_global_cleanup();
- return 0;
+ return (int)res;
}
curl_easy_cleanup(curl);
}
curl_global_cleanup();
- return 0;
+ return (int)res;
}
{
CURL *curlhandle = NULL;
- curl_global_init(CURL_GLOBAL_ALL);
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
curlhandle = curl_easy_init();
upload(curlhandle, "ftp://user:pass@example.com/path/file", "C:\\file",
int main(void)
{
CURL *curl;
- CURLcode res;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
/* always cleanup */
curl_easy_cleanup(curl);
}
- return 0;
+ curl_global_cleanup();
+ return (int)res;
}
struct MemoryStruct chunk;
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
chunk.memory = malloc(1); /* grown as needed by the realloc above */
chunk.size = 0; /* no data at this point */
- curl_global_init(CURL_GLOBAL_ALL);
-
/* init the curl session */
curl_handle = curl_easy_init();
/* we are done with libcurl, so clean it up */
curl_global_cleanup();
- return 0;
+ return (int)res;
}
char *location;
long response_code;
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
curl = curl_easy_init();
if(curl) {
curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
/* always cleanup */
curl_easy_cleanup(curl);
}
- return 0;
+ curl_global_cleanup();
+ return (int)res;
}
{
CURL *curl;
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
curl = curl_easy_init();
if(curl) {
- CURLcode res;
-
curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
curl_easy_setopt(curl, CURLOPT_REFERER, "https://example.org/referrer");
/* always cleanup */
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
return 0;
}
int fd;
GIOChannel* ch;
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
fd = init_fifo();
- if(fd == CURL_SOCKET_BAD)
+ if(fd == CURL_SOCKET_BAD) {
+ curl_global_cleanup();
return 1;
+ }
ch = g_io_channel_unix_new(fd);
g_io_add_watch(ch, G_IO_IN, fifo_cb, g);
gmain = g_main_loop_new(NULL, FALSE);
g_main_loop_run(gmain);
curl_multi_cleanup(g->multi);
+ curl_global_cleanup();
return 0;
}
{
CURL *curl;
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
curl = curl_easy_init();
if(curl) {
- CURLcode res;
struct curl_header *header;
curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
/* example.com is redirected, so we tell libcurl to follow redirection */
/* always cleanup */
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
return 0;
}
int main(int argc, char **argv)
{
+ CURLcode res;
struct GlobalInfo g;
(void)argc;
(void)argv;
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
memset(&g, 0, sizeof(g));
g.evbase = event_base_new();
- if(init_fifo(&g))
+ if(init_fifo(&g)) {
+ curl_global_cleanup();
return 1;
+ }
g.multi = curl_multi_init();
evtimer_assign(&g.timer_event, g.evbase, timer_cb, &g);
event_del(&g.timer_event);
event_base_free(g.evbase);
curl_multi_cleanup(g.multi);
+ curl_global_cleanup();
return 0;
}
int main(void)
{
CURL *curl;
- CURLcode res;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
/* always cleanup */
curl_easy_cleanup(curl);
}
- return 0;
+ curl_global_cleanup();
+ return (int)res;
}
int main(int argc, char **argv)
{
- if(argc == 2) {
- CURL *curl;
- char curl_errbuf[CURL_ERROR_SIZE];
- TidyDoc tdoc;
- TidyBuffer docbuf = {0};
- TidyBuffer tidy_errbuf = {0};
- int err;
+ CURL *curl;
+ char curl_errbuf[CURL_ERROR_SIZE];
+ TidyDoc tdoc;
+ TidyBuffer docbuf = {0};
+ TidyBuffer tidy_errbuf = {0};
+ CURLcode res;
- curl = curl_easy_init();
- curl_easy_setopt(curl, CURLOPT_URL, argv[1]);
- curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, curl_errbuf);
- curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
- curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
- curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
+ if(argc != 2) {
+ printf("usage: %s <url>\n", argv[0]);
+ return 1;
+ }
+
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
+ curl = curl_easy_init();
+ curl_easy_setopt(curl, CURLOPT_URL, argv[1]);
+ curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, curl_errbuf);
+ curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
+ curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
- tdoc = tidyCreate();
- tidyOptSetBool(tdoc, TidyForceOutput, yes); /* try harder */
- tidyOptSetInt(tdoc, TidyWrapLen, 4096);
- tidySetErrorBuffer(tdoc, &tidy_errbuf);
- tidyBufInit(&docbuf);
+ tdoc = tidyCreate();
+ tidyOptSetBool(tdoc, TidyForceOutput, yes); /* try harder */
+ tidyOptSetInt(tdoc, TidyWrapLen, 4096);
+ tidySetErrorBuffer(tdoc, &tidy_errbuf);
+ tidyBufInit(&docbuf);
- curl_easy_setopt(curl, CURLOPT_WRITEDATA, &docbuf);
- err = curl_easy_perform(curl);
- if(!err) {
- err = tidyParseBuffer(tdoc, &docbuf); /* parse the input */
- if(err >= 0) {
- err = tidyCleanAndRepair(tdoc); /* fix any problems */
- if(err >= 0) {
- err = tidyRunDiagnostics(tdoc); /* load tidy error buffer */
- if(err >= 0) {
- dumpNode(tdoc, tidyGetRoot(tdoc), 0); /* walk the tree */
- fprintf(stderr, "%s\n", tidy_errbuf.bp); /* show errors */
- }
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, &docbuf);
+ res = curl_easy_perform(curl);
+ if(!res) {
+ res = tidyParseBuffer(tdoc, &docbuf); /* parse the input */
+ if(res >= 0) {
+ res = tidyCleanAndRepair(tdoc); /* fix any problems */
+ if(res >= 0) {
+ res = tidyRunDiagnostics(tdoc); /* load tidy error buffer */
+ if(res >= 0) {
+ dumpNode(tdoc, tidyGetRoot(tdoc), 0); /* walk the tree */
+ fprintf(stderr, "%s\n", tidy_errbuf.bp); /* show errors */
}
}
}
- else
- fprintf(stderr, "%s\n", curl_errbuf);
-
- /* clean-up */
- curl_easy_cleanup(curl);
- tidyBufFree(&docbuf);
- tidyBufFree(&tidy_errbuf);
- tidyRelease(tdoc);
- return err;
-
}
else
- printf("usage: %s <url>\n", argv[0]);
+ fprintf(stderr, "%s\n", curl_errbuf);
- return 0;
+ /* clean-up */
+ curl_easy_cleanup(curl);
+ curl_global_cleanup();
+ tidyBufFree(&docbuf);
+ tidyBufFree(&tidy_errbuf);
+ tidyRelease(tdoc);
+ return (int)res;
}
int main(int argc, char *argv[])
{
CURL *conn = NULL;
- CURLcode code;
+ CURLcode res;
std::string title;
// Ensure one argument is given
return EXIT_FAILURE;
}
- curl_global_init(CURL_GLOBAL_DEFAULT);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
// Initialize CURL connection
if(!init(conn, argv[1])) {
fprintf(stderr, "Connection initialization failed\n");
+ curl_global_cleanup();
return EXIT_FAILURE;
}
// Retrieve content for the URL
- code = curl_easy_perform(conn);
+ res = curl_easy_perform(conn);
curl_easy_cleanup(conn);
- if(code != CURLE_OK) {
+ if(res != CURLE_OK) {
fprintf(stderr, "Failed to get '%s' [%s]\n", argv[1], errorBuffer);
return EXIT_FAILURE;
}
// Display the extracted title
printf("Title: %s\n", title.c_str());
- return EXIT_SUCCESS;
+ return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
/* always cleanup */
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
return 0;
}
CURLcode res;
/* In Windows, this inits the Winsock stuff */
- curl_global_init(CURL_GLOBAL_ALL);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
/* get a curl handle */
curl = curl_easy_init();
curl_easy_cleanup(curl);
}
curl_global_cleanup();
- return 0;
+ return (int)res;
}
*/
int main(int argc, char **argv)
{
+ CURLcode res;
struct transfer trans[NUM_HANDLES];
CURLM *multi_handle;
int i;
int still_running = 0; /* keep number of running handles */
int num_transfers;
+
if(argc > 1) {
/* if given a number, do that many transfers */
num_transfers = atoi(argv[1]);
else
num_transfers = 3; /* suitable default */
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
/* init a multi stack */
multi_handle = curl_multi_init();
for(i = 0; i < num_transfers; i++) {
- if(setup(&trans[i], i))
+ if(setup(&trans[i], i)) {
+ curl_global_cleanup();
return 1;
+ }
/* add the individual transfer */
curl_multi_add_handle(multi_handle, trans[i].easy);
int i;
struct CURLMsg *m;
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
/* init a multi stack */
multi = curl_multi_init();
if(mcode)
break;
-
/*
* When doing server push, libcurl itself created and added one or more
* easy handles but *we* need to clean them up when they are done.
}
-
curl_multi_cleanup(multi);
+ curl_global_cleanup();
/* 'pushindex' is now the number of received transfers */
for(i = 0; i < pushindex; i++) {
*/
int main(int argc, char *argv[])
{
+ CURLcode res;
CURL *easy;
CURLM *multi_handle;
int transfers = 1; /* we start with one */
if(argc == 2)
url = argv[1];
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
/* init a multi stack */
multi_handle = curl_multi_init();
/* set options */
if(setup(easy, url)) {
fprintf(stderr, "failed\n");
+ curl_global_cleanup();
return 1;
}
} while(transfers); /* as long as we have transfers going */
curl_multi_cleanup(multi_handle);
-
+ curl_global_cleanup();
return 0;
}
*/
int main(int argc, char **argv)
{
+ CURLcode res;
struct input trans[NUM_HANDLES];
CURLM *multi_handle;
int i;
else
num_transfers = 3;
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
/* init a multi stack */
multi_handle = curl_multi_init();
for(i = 0; i < num_transfers; i++) {
- if(setup(&trans[i], i, filename))
+ if(setup(&trans[i], i, filename)) {
+ curl_global_cleanup();
return 1;
+ }
/* add the individual transfer */
curl_multi_add_handle(multi_handle, trans[i].hnd);
curl_easy_cleanup(trans[i].hnd);
}
+ curl_global_cleanup();
+
return 0;
}
{
curl_version_info_data *ver;
- curl_global_init(CURL_GLOBAL_ALL);
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
ver = curl_version_info(CURLVERSION_NOW);
if(ver->features & CURL_VERSION_HTTP2)
int main(void)
{
CURL *curl;
- CURLcode res;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
/* always cleanup */
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
return 0;
}
int main(void)
{
CURL *curl;
- CURLcode res;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
/* free the custom headers */
curl_slist_free_all(chunk);
}
- return 0;
+ curl_global_cleanup();
+ return (int)res;
}
url = argv[1];
/* In Windows, this inits the Winsock stuff */
- curl_global_init(CURL_GLOBAL_ALL);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
/* get a curl handle */
curl = curl_easy_init();
}
curl_global_cleanup();
- return 0;
+ return (int)res;
}
}
/* In Windows, this inits the Winsock stuff */
- curl_global_init(CURL_GLOBAL_ALL);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res) {
+ fclose(hd_src);
+ return (int)res;
+ }
/* get a curl handle */
curl = curl_easy_init();
fclose(hd_src); /* close the local file */
curl_global_cleanup();
- return 0;
+ return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res;
- curl_global_init(CURL_GLOBAL_DEFAULT);
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_global_cleanup();
- return 0;
+ return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLM *mcurl;
- int still_running = 1;
- curl_global_init(CURL_GLOBAL_DEFAULT);
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
- if(!curl)
- return 1;
+ if(curl) {
+ CURLM *mcurl;
- mcurl = curl_multi_init();
- if(!mcurl)
- return 2;
+ mcurl = curl_multi_init();
+ if(mcurl) {
+ int still_running = 1;
- /* Set username and password */
- curl_easy_setopt(curl, CURLOPT_USERNAME, "user");
- curl_easy_setopt(curl, CURLOPT_PASSWORD, "secret");
+ /* Set username and password */
+ curl_easy_setopt(curl, CURLOPT_USERNAME, "user");
+ curl_easy_setopt(curl, CURLOPT_PASSWORD, "secret");
- /* This fetches message 1 from the user's inbox */
- curl_easy_setopt(curl, CURLOPT_URL, "imap://imap.example.com/INBOX/;UID=1");
+ /* This fetches message 1 from the user's inbox */
+ curl_easy_setopt(curl, CURLOPT_URL, "imap://imap.example.com/"
+ "INBOX/;UID=1");
- /* Tell the multi stack about our easy handle */
- curl_multi_add_handle(mcurl, curl);
+ /* Tell the multi stack about our easy handle */
+ curl_multi_add_handle(mcurl, curl);
- do {
- CURLMcode mc = curl_multi_perform(mcurl, &still_running);
+ do {
+ CURLMcode mc = curl_multi_perform(mcurl, &still_running);
- if(still_running)
- /* wait for activity, timeout or "nothing" */
- mc = curl_multi_poll(mcurl, NULL, 0, 1000, NULL);
+ if(still_running)
+ /* wait for activity, timeout or "nothing" */
+ mc = curl_multi_poll(mcurl, NULL, 0, 1000, NULL);
- if(mc)
- break;
- } while(still_running);
+ if(mc)
+ break;
+ } while(still_running);
+
+ /* Always cleanup */
+ curl_multi_remove_handle(mcurl, curl);
+ curl_multi_cleanup(mcurl);
+ }
+ curl_easy_cleanup(curl);
+ }
- /* Always cleanup */
- curl_multi_remove_handle(mcurl, curl);
- curl_multi_cleanup(mcurl);
- curl_easy_cleanup(curl);
curl_global_cleanup();
return 0;
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
+ CURLcode res;
unsigned i;
int total_failed = 0;
char errbuf[CURL_ERROR_SIZE] = { 0, };
transfer[1].bodyfile = "400.txt";
transfer[1].logfile = "400_transfer_log.txt";
- if(curl_global_init(CURL_GLOBAL_DEFAULT)) {
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res) {
fprintf(stderr, "curl_global_init failed\n");
- return 1;
+ return (int)res;
}
/* You could enable global tracing for extra verbosity when verbosity is
printf("\n");
}
+ curl_global_cleanup();
+
return total_failed ? 1 : 0;
}
int main(void)
{
CURL *curl;
- CURLcode res;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
/* always cleanup */
curl_easy_cleanup(curl);
}
+
+ curl_global_cleanup();
+
return 0;
}
CURLMsg *msg; /* for picking up messages with the transfer status */
int msgs_left; /* how many messages are left */
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
/* Allocate one curl handle per transfer */
for(i = 0; i < HANDLECOUNT; i++)
handles[i] = curl_easy_init();
}
curl_multi_cleanup(multi_handle);
+ curl_global_cleanup();
return 0;
}
int still_running = 0; /* keep number of running handles */
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
http_handle = curl_easy_init();
/* set the options (I left out a few, you get the point anyway) */
curl_easy_cleanup(http_handle);
+ curl_global_cleanup();
+
return 0;
}
int still_running = 1; /* keep number of running handles */
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
http_handle = curl_easy_init();
http_handle2 = curl_easy_init();
curl_easy_cleanup(http_handle);
curl_easy_cleanup(http_handle2);
+ curl_global_cleanup();
+
return 0;
}
int main(int argc, char **argv)
{
+ CURLcode res;
+
if(argc <= 1)
return 0;
- if(curl_global_init(CURL_GLOBAL_ALL)) {
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res) {
fprintf(stderr, "Could not init curl\n");
- return 1;
+ return (int)res;
}
base = event_base_new();
struct curl_slist *headerlist = NULL;
static const char buf[] = "Expect:";
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
CURL_IGNORE_DEPRECATION(
/* Fill in the file upload field. This makes libcurl load data from
the given file name when curl_easy_perform() is called. */
/* free slist */
curl_slist_free_all(headerlist);
}
+ curl_global_cleanup();
return 0;
}
CURLMsg *msg; /* for picking up messages with the transfer status */
int msgs_left; /* how many messages are left */
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
/* Allocate one curl handle per transfer */
for(i = 0; i < HANDLECOUNT; i++)
handles[i] = curl_easy_init();
for(i = 0; i < HANDLECOUNT; i++)
curl_easy_cleanup(handles[i]);
+ curl_global_cleanup();
+
return 0;
}
struct curl_slist *headerlist = NULL;
static const char buf[] = "Expect:";
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
curl = curl_easy_init();
multi_handle = curl_multi_init();
/* free slist */
curl_slist_free_all(headerlist);
}
+ curl_global_cleanup();
return 0;
}
CURLM *multi_handle;
int still_running = 1; /* keep number of running handles */
- curl_global_init(CURL_GLOBAL_DEFAULT);
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
http_handle = curl_easy_init();
int main(int argc, char **argv)
{
+ CURLcode res;
struct datauv uv = { 0 };
int running_handles;
if(argc <= 1)
return 0;
- curl_global_init(CURL_GLOBAL_ALL);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
uv.loop = uv_default_loop();
uv_timer_init(uv.loop, &uv.timeout);
curl_multi_socket_action(uv.multi, CURL_SOCKET_TIMEOUT, 0, &running_handles);
uv_run(uv.loop, UV_RUN_DEFAULT);
curl_multi_cleanup(uv.multi);
+ curl_global_cleanup();
curl_global_cleanup();
int main(void)
{
+ CURLcode res;
pthread_t tid[NUMT];
int i;
/* Must initialize libcurl before any threads are started */
- curl_global_init(CURL_GLOBAL_ALL);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
for(i = 0; i < NUMT; i++) {
int error = pthread_create(&tid[i],
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res;
- curl_global_init(CURL_GLOBAL_ALL);
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_global_cleanup();
- return 0;
+ return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
+ CURLcode res;
CURL *curl;
- CURLM *mcurl;
- int still_running = 1;
- curl_global_init(CURL_GLOBAL_DEFAULT);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
- if(!curl)
- return 1;
+ if(curl) {
+ CURLM *mcurl;
- mcurl = curl_multi_init();
- if(!mcurl)
- return 2;
+ mcurl = curl_multi_init();
+ if(mcurl) {
+ int still_running = 1;
- /* Set username and password */
- curl_easy_setopt(curl, CURLOPT_USERNAME, "user");
- curl_easy_setopt(curl, CURLOPT_PASSWORD, "secret");
+ /* Set username and password */
+ curl_easy_setopt(curl, CURLOPT_USERNAME, "user");
+ curl_easy_setopt(curl, CURLOPT_PASSWORD, "secret");
- /* This retrieves message 1 from the user's mailbox */
- curl_easy_setopt(curl, CURLOPT_URL, "pop3://pop.example.com/1");
+ /* This retrieves message 1 from the user's mailbox */
+ 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);
+ /* Tell the multi stack about our easy handle */
+ curl_multi_add_handle(mcurl, curl);
- do {
- CURLMcode mc = curl_multi_perform(mcurl, &still_running);
+ do {
+ CURLMcode mc = curl_multi_perform(mcurl, &still_running);
- if(still_running)
- /* wait for activity, timeout or "nothing" */
- mc = curl_multi_poll(mcurl, NULL, 0, 1000, NULL);
+ if(still_running)
+ /* wait for activity, timeout or "nothing" */
+ mc = curl_multi_poll(mcurl, NULL, 0, 1000, NULL);
- if(mc)
- break;
+ if(mc)
+ break;
- } while(still_running);
+ } while(still_running);
+
+ /* Always cleanup */
+ curl_multi_remove_handle(mcurl, curl);
+ curl_multi_cleanup(mcurl);
+ }
+ curl_easy_cleanup(curl);
+ }
- /* Always cleanup */
- curl_multi_remove_handle(mcurl, curl);
- curl_multi_cleanup(mcurl);
- curl_easy_cleanup(curl);
curl_global_cleanup();
return 0;
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
if(res != CURLE_OK) {
fprintf(stderr, "curl_global_init() failed: %s\n",
curl_easy_strerror(res));
- return 1;
+ return (int)res;
}
/* get a curl handle */
struct MemoryStruct chunk;
static const char *postthis = "Field=1&Field=2&Field=3";
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
chunk.memory = malloc(1); /* grown as needed by realloc above */
chunk.size = 0; /* no data at this point */
- curl_global_init(CURL_GLOBAL_ALL);
curl = curl_easy_init();
if(curl) {
curl_easy_setopt(curl, CURLOPT_URL, "https://www.example.org/");
struct curl_slist *headerlist = NULL;
static const char buf[] = "Expect:";
- curl_global_init(CURL_GLOBAL_ALL);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
CURL_IGNORE_DEPRECATION(
/* Fill in the file upload field */
struct curl_slist *headerlist = NULL;
static const char buf[] = "Expect:";
- curl_global_init(CURL_GLOBAL_ALL);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
struct myprogress prog;
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
curl = curl_easy_init();
if(curl) {
prog.lastruntime = 0;
/* always cleanup */
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
return (int)res;
}
curl_version_info_data *ver;
const char *const *ptr;
- curl_global_init(CURL_GLOBAL_ALL);
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
ver = curl_version_info(CURLVERSION_NOW);
printf("Protocols:\n");
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
/* Each single name resolve string should be written using the format
HOST:PORT:ADDRESS where HOST is the name libcurl tries to resolve, PORT
struct curl_slist *host = curl_slist_append(NULL,
"example.com:443:127.0.0.1");
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
curl = curl_easy_init();
if(curl) {
curl_easy_setopt(curl, CURLOPT_RESOLVE, host);
}
curl_slist_free_all(host);
+ curl_global_cleanup();
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
/* always cleanup */
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
return 0;
}
const char *request = "GET / HTTP/1.0\r\nHost: example.com\r\n\r\n";
size_t request_len = strlen(request);
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
/* A general note of caution here: if you are using curl_easy_recv() or
curl_easy_send() to implement HTTP or _any_ other protocol libcurl
supports "natively", you are doing it wrong and you should stop.
curl = curl_easy_init();
if(curl) {
- CURLcode res;
curl_socket_t sockfd;
size_t nsent_total = 0;
/* always cleanup */
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
return 0;
}
int main(void)
{
- CURLcode res;
CURL *curl_handle;
- static const char *headerfilename = "head.out";
- FILE *headerfile;
- static const char *bodyfilename = "body.out";
- FILE *bodyfile;
- curl_global_init(CURL_GLOBAL_ALL);
+ 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) {
+ 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");
+
+ /* no progress meter please */
+ curl_easy_setopt(curl_handle, CURLOPT_NOPROGRESS, 1L);
+
+ /* send all data to this function */
+ curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, write_data);
+
+ /* open the header file */
+ headerfile = fopen(headerfilename, "wb");
+ if(!headerfile) {
+ curl_easy_cleanup(curl_handle);
+ curl_global_cleanup();
+ return -1;
+ }
+
+ /* open the body file */
+ bodyfile = fopen(bodyfilename, "wb");
+ if(!bodyfile) {
+ curl_easy_cleanup(curl_handle);
+ 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);
+
+ /* we want the body be written to this file handle instead of stdout */
+ curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, bodyfile);
+
+ /* get it! */
+ res = curl_easy_perform(curl_handle);
+
+ /* close the header file */
+ fclose(headerfile);
- /* set URL to get */
- curl_easy_setopt(curl_handle, CURLOPT_URL, "https://example.com");
-
- /* no progress meter please */
- curl_easy_setopt(curl_handle, CURLOPT_NOPROGRESS, 1L);
-
- /* send all data to this function */
- curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, write_data);
+ /* close the body file */
+ fclose(bodyfile);
- /* open the header file */
- headerfile = fopen(headerfilename, "wb");
- if(!headerfile) {
+ /* cleanup curl stuff */
curl_easy_cleanup(curl_handle);
- return -1;
- }
-
- /* open the body file */
- bodyfile = fopen(bodyfilename, "wb");
- if(!bodyfile) {
- curl_easy_cleanup(curl_handle);
- fclose(headerfile);
- return -1;
}
- /* we want the headers be written to this file handle */
- curl_easy_setopt(curl_handle, CURLOPT_HEADERDATA, headerfile);
-
- /* we want the body be written to this file handle instead of stdout */
- curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, bodyfile);
-
- /* get it! */
- res = curl_easy_perform(curl_handle);
-
- /* close the header file */
- fclose(headerfile);
-
- /* close the body file */
- fclose(bodyfile);
-
- /* cleanup curl stuff */
- curl_easy_cleanup(curl_handle);
-
curl_global_cleanup();
return (int)res;
int main(void)
{
- CURLcode res = CURLE_OK;
-
- curl_global_init(CURL_GLOBAL_DEFAULT);
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
int main(void)
{
CURL *curl;
- CURLcode res;
struct FtpFile ftpfile = {
"yourfile.bin", /* name to store the file as if successful */
NULL
};
- curl_global_init(CURL_GLOBAL_DEFAULT);
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_global_cleanup();
- return 0;
+ return (int)res;
}
const char *filename = "filename";
CURL *curlhandle = NULL;
- curl_global_init(CURL_GLOBAL_ALL);
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
curlhandle = curl_easy_init();
if(!sftpResumeUpload(curlhandle, remote, filename)) {
CURLSH *share;
int i;
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
share = curl_share_init();
curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_CONNECT);
for(i = 0; i < 3; i++) {
CURL *curl = curl_easy_init();
if(curl) {
- CURLcode res;
-
curl_easy_setopt(curl, CURLOPT_URL, "https://curl.se/");
/* use the share object */
}
curl_share_cleanup(share);
- return 0;
+ curl_global_cleanup();
+ return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
/* always cleanup */
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
return 0;
}
int main(void)
{
+ static const char *postthis = "moo mooo moo moo";
+
CURL *curl;
- CURLcode res;
- static const char *postthis = "moo mooo moo moo";
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
/* always cleanup */
curl_easy_cleanup(curl);
}
- return 0;
+ curl_global_cleanup();
+ return (int)res;
}
if(!headerfile)
return 1;
- curl_global_init(CURL_GLOBAL_DEFAULT);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res) {
+ fclose(headerfile);
+ return (int)res;
+ }
curl = curl_easy_init();
if(curl) {
GtkWidget *top_window, *outside_frame, *inside_frame, *progress_bar;
/* Must initialize libcurl before any threads are started */
- curl_global_init(CURL_GLOBAL_ALL);
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
/* Init thread */
g_thread_init(NULL);
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
struct curl_slist *recipients = NULL;
struct upload_status upload_ctx = { 0 };
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
curl = curl_easy_init();
if(curl) {
/* This is the URL for your mailserver. In this example we connect to the
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res;
struct curl_slist *recipients = NULL;
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
curl = curl_easy_init();
if(curl) {
/* This is the URL for your mailserver */
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return 0;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
struct curl_slist *recipients = NULL;
struct upload_status upload_ctx = { 0 };
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
curl = curl_easy_init();
if(curl) {
/* This is the URL for your mailserver */
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
curl_mime_free(mime);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLM *mcurl;
- int still_running = 1;
- struct curl_slist *recipients = NULL;
- struct upload_status upload_ctx = { 0 };
- curl_global_init(CURL_GLOBAL_DEFAULT);
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
- if(!curl)
- return 1;
-
- mcurl = curl_multi_init();
- if(!mcurl)
- return 2;
-
- /* This is the URL for your mailserver */
- curl_easy_setopt(curl, CURLOPT_URL, "smtp://mail.example.com");
-
- /* Note that this option is not strictly required, omitting it results in
- * libcurl sending the MAIL FROM command with empty sender data. All
- * autoresponses should have an empty reverse-path, and should be directed
- * to the address in the reverse-path which triggered them. Otherwise, they
- * could cause an endless loop. See RFC 5321 Section 4.5.5 for more details.
- */
- curl_easy_setopt(curl, CURLOPT_MAIL_FROM, FROM_MAIL);
-
- /* Add two recipients, in this particular case they correspond to the
- * To: and Cc: addressees in the header, but they could be any kind of
- * recipient. */
- recipients = curl_slist_append(recipients, TO_MAIL);
- recipients = curl_slist_append(recipients, CC_MAIL);
- curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, recipients);
-
- /* 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_READDATA, &upload_ctx);
- curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
-
- /* Tell the multi stack about our easy handle */
- curl_multi_add_handle(mcurl, curl);
-
- do {
- CURLMcode mc = curl_multi_perform(mcurl, &still_running);
-
- if(still_running)
- /* wait for activity, timeout or "nothing" */
- mc = curl_multi_poll(mcurl, NULL, 0, 1000, NULL);
-
- if(mc)
- break;
-
- } while(still_running);
-
- /* Free the list of recipients */
- curl_slist_free_all(recipients);
-
- /* Always cleanup */
- curl_multi_remove_handle(mcurl, curl);
- curl_multi_cleanup(mcurl);
- curl_easy_cleanup(curl);
+ if(curl) {
+ CURLM *mcurl;
+
+ mcurl = curl_multi_init();
+ if(mcurl) {
+ int still_running = 1;
+ struct curl_slist *recipients = NULL;
+ struct upload_status upload_ctx = { 0 };
+
+ /* This is the URL for your mailserver */
+ curl_easy_setopt(curl, CURLOPT_URL, "smtp://mail.example.com");
+
+ /* Note that this option is not strictly required, omitting it results
+ * in libcurl sending the MAIL FROM command with empty sender data. All
+ * autoresponses should have an empty reverse-path, and should be
+ * directed to the address in the reverse-path which triggered them.
+ * Otherwise, they could cause an endless loop. See RFC 5321 Section
+ * 4.5.5 for more details.
+ */
+ curl_easy_setopt(curl, CURLOPT_MAIL_FROM, FROM_MAIL);
+
+ /* Add two recipients, in this particular case they correspond to the
+ * To: and Cc: addressees in the header, but they could be any kind of
+ * recipient. */
+ recipients = curl_slist_append(recipients, TO_MAIL);
+ recipients = curl_slist_append(recipients, CC_MAIL);
+ curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, recipients);
+
+ /* 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_READDATA, &upload_ctx);
+ curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
+
+ /* Tell the multi stack about our easy handle */
+ curl_multi_add_handle(mcurl, curl);
+
+ do {
+ CURLMcode mc = curl_multi_perform(mcurl, &still_running);
+
+ if(still_running)
+ /* wait for activity, timeout or "nothing" */
+ mc = curl_multi_poll(mcurl, NULL, 0, 1000, NULL);
+
+ if(mc)
+ break;
+
+ } while(still_running);
+
+ /* Free the list of recipients */
+ curl_slist_free_all(recipients);
+
+ /* Always cleanup */
+ curl_multi_remove_handle(mcurl, curl);
+ curl_multi_cleanup(mcurl);
+ }
+ curl_easy_cleanup(curl);
+ }
+
curl_global_cleanup();
return 0;
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
struct curl_slist *recipients = NULL;
struct upload_status upload_ctx = { 0 };
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
curl = curl_easy_init();
if(curl) {
/* Set username and password */
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res = CURLE_OK;
struct curl_slist *recipients = NULL;
struct upload_status upload_ctx = { 0 };
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
curl = curl_easy_init();
if(curl) {
/* Set username and password */
curl_easy_cleanup(curl);
}
+ curl_global_cleanup();
+
return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res;
struct curl_slist *recipients = NULL;
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
curl = curl_easy_init();
if(curl) {
/* This is the URL for your mailserver */
curl_easy_cleanup(curl);
}
- return 0;
+ curl_global_cleanup();
+
+ return (int)res;
}
int main(int argc, char *argv[])
{
+ CURLcode res;
CURL *curl;
struct conf conf[1];
int RetValue;
snprintf(conf->timeserver, MAX_STRING, "%s", DefaultTimeServer[0]);
/* Init CURL before usage */
- curl_global_init(CURL_GLOBAL_ALL);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
curl = curl_easy_init();
if(curl) {
struct tm *lt;
int main(int argc, char **argv)
{
+ CURLcode res;
pthread_t tid[NUMT];
int i;
(void)argc;
(void)argv;
/* Must initialize libcurl before any threads are started */
- curl_global_init(CURL_GLOBAL_ALL);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
for(i = 0; i < NUMT; i++) {
int error = pthread_create(&tid[i],
int main(void)
{
CURL *curl;
- CURLcode res;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
/* always cleanup */
curl_easy_cleanup(curl);
}
- return 0;
+ curl_global_cleanup();
+ return (int)res;
}
int main(int argc, char *argv[])
{
- CURLcode res = CURLE_OK;
-
+ CURLcode res;
CURL *curl_handle;
static const char *pagefilename = "page.out";
FILE *pagefile;
return 1;
}
- curl_global_init(CURL_GLOBAL_ALL);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res) {
+ fprintf(stderr, "Could not init curl\n");
+ return (int)res;
+ }
/* init the curl session */
curl_handle = curl_easy_init();
int main(void)
{
CURL *curl;
- CURLcode res;
CURLU *urlp;
CURLUcode uc;
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
/* get a curl handle */
curl = curl_easy_init();
cleanup:
curl_url_cleanup(urlp);
curl_easy_cleanup(curl);
- return 0;
+ curl_global_cleanup();
+ return (int)res;
}
int main(void)
{
CURL *ch;
- CURLcode rv;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl_global_init(CURL_GLOBAL_ALL);
ch = curl_easy_init();
curl_easy_setopt(ch, CURLOPT_SSLKEYTYPE, "PEM");
/* first try: retrieve page without user certificate and key -> fails */
- rv = curl_easy_perform(ch);
- if(rv == CURLE_OK)
+ res = curl_easy_perform(ch);
+ if(res == CURLE_OK)
printf("*** transfer succeeded ***\n");
else
printf("*** transfer failed ***\n");
* "modifications" to the SSL CONTEXT just before link init
*/
curl_easy_setopt(ch, CURLOPT_SSL_CTX_FUNCTION, sslctx_function);
- rv = curl_easy_perform(ch);
- if(rv == CURLE_OK)
+ res = curl_easy_perform(ch);
+ if(res == CURLE_OK)
printf("*** transfer succeeded ***\n");
else
printf("*** transfer failed ***\n");
curl_easy_cleanup(ch);
curl_global_cleanup();
- return (int)rv;
+ return (int)res;
}
int main(void)
{
CURL *curl;
- CURLcode res;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
if(curl) {
/* always cleanup */
curl_easy_cleanup(curl);
}
- return 0;
+ curl_global_cleanup();
+ return (int)res;
}
{
CURL *easy;
struct read_ctx rctx;
- CURLcode res;
const char *payload = "Hello, friend!";
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
memset(&rctx, 0, sizeof(rctx));
easy = curl_easy_init();
- if(!easy)
- return 1;
-
- if(argc == 2)
- curl_easy_setopt(easy, CURLOPT_URL, argv[1]);
- else
- curl_easy_setopt(easy, CURLOPT_URL, "wss://example.com");
+ if(easy) {
+ if(argc == 2)
+ curl_easy_setopt(easy, CURLOPT_URL, argv[1]);
+ else
+ curl_easy_setopt(easy, 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);
- /* tell curl that we want to send the payload */
- rctx.easy = easy;
- 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(easy, CURLOPT_WRITEFUNCTION, writecb);
+ curl_easy_setopt(easy, CURLOPT_WRITEDATA, easy);
+ curl_easy_setopt(easy, CURLOPT_READFUNCTION, readcb);
+ /* tell curl that we want to send the payload */
+ rctx.easy = easy;
+ rctx.blen = strlen(payload);
+ memcpy(rctx.buf, payload, rctx.blen);
+ curl_easy_setopt(easy, CURLOPT_READDATA, &rctx);
+ curl_easy_setopt(easy, CURLOPT_UPLOAD, 1L);
- /* Perform the request, res gets the return code */
- res = curl_easy_perform(easy);
- /* Check for errors */
- if(res != CURLE_OK)
- fprintf(stderr, "curl_easy_perform() failed: %s\n",
- curl_easy_strerror(res));
+ /* Perform the request, res gets the return code */
+ res = curl_easy_perform(easy);
+ /* 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);
- return 0;
+ /* always cleanup */
+ curl_easy_cleanup(easy);
+ }
+ curl_global_cleanup();
+ return (int)res;
}
int main(int argc, const char *argv[])
{
CURL *curl;
- CURLcode res;
+
+ CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
curl = curl_easy_init();
- if(!curl) {
- return 1; /* memory failure */
- }
- if(argc == 2)
- curl_easy_setopt(curl, CURLOPT_URL, argv[1]);
- else
- curl_easy_setopt(curl, CURLOPT_URL, "wss://example.com");
+ if(curl) {
+ if(argc == 2)
+ curl_easy_setopt(curl, CURLOPT_URL, argv[1]);
+ else
+ curl_easy_setopt(curl, CURLOPT_URL, "wss://example.com");
- curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, 2L); /* websocket style */
+ curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, 2L); /* websocket style */
- /* Perform the request, res gets the return code */
- res = curl_easy_perform(curl);
- /* Check for errors */
- if(res != CURLE_OK)
- fprintf(stderr, "curl_easy_perform() failed: %s\n",
- curl_easy_strerror(res));
- else {
- /* connected and ready */
- res = websocket(curl);
- }
+ /* Perform the request, res gets the return code */
+ res = curl_easy_perform(curl);
+ /* Check for errors */
+ if(res != CURLE_OK)
+ fprintf(stderr, "curl_easy_perform() failed: %s\n",
+ curl_easy_strerror(res));
+ else {
+ /* connected and ready */
+ res = websocket(curl);
+ }
- /* always cleanup */
- curl_easy_cleanup(curl);
+ /* always cleanup */
+ curl_easy_cleanup(curl);
+ }
+ curl_global_cleanup();
return (int)res;
}
XML_SetElementHandler(parser, startElement, endElement);
XML_SetCharacterDataHandler(parser, characterDataHandler);
+ res = curl_global_init(CURL_GLOBAL_ALL);
+ if(res)
+ return (int)res;
+
/* Initialize a libcurl handle. */
- curl_global_init(CURL_GLOBAL_DEFAULT);
curl_handle = curl_easy_init();
curl_easy_setopt(curl_handle, CURLOPT_URL,
"https://www.w3schools.com/xml/simple.xml");
curl_easy_cleanup(curl_handle);
curl_global_cleanup();
- return 0;
+ return (int)res;
}
projects / thirdparty / curl.git / commitdiff
