Improve cleanup in case of initialization failure.
int test(char *URL)
{
CURLcode res;
- CURL *curl = curl_easy_init();
+ CURL *curl;
+
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
+
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
+
curl_easy_setopt(curl, CURLOPT_URL, URL);
curl_easy_setopt(curl, CURLOPT_HEADER, TRUE);
+
res = curl_easy_perform(curl);
+
curl_easy_cleanup(curl);
+ curl_global_cleanup();
+
return (int)res;
}
int test(char *URL)
{
CURLcode res;
- CURL *curl = curl_easy_init();
+ CURL *curl;
(void)URL; /* we don't use this */
+
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
+
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
+
curl_easy_setopt(curl, CURLOPT_HEADER, TRUE);
+
res = curl_easy_perform(curl);
+
curl_easy_cleanup(curl);
- return res;
+ curl_global_cleanup();
+
+ return (int)res;
}
#include "test.h"
+#include "timeval.h"
+
+#define MULTI_PERFORM_HANG_TIMEOUT 30 * 1000
+
/*
* Get a single URL without select().
*/
{
CURL *c;
CURLM *m;
- CURLMcode res;
+ int res = 0;
int running=1;
+ struct timeval mp_start;
+ char mp_timedout = FALSE;
+
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
+
+ if ((c = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
- curl_global_init(CURL_GLOBAL_ALL);
- c = curl_easy_init();
curl_easy_setopt(c, CURLOPT_URL, URL);
- m = curl_multi_init();
- res = curl_multi_add_handle(m, c);
+ if ((m = curl_multi_init()) == NULL) {
+ fprintf(stderr, "curl_multi_init() failed\n");
+ curl_easy_cleanup(c);
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
+
+ if ((res = (int)curl_multi_add_handle(m, c)) != CURLM_OK) {
+ fprintf(stderr, "curl_multi_add_handle() failed, "
+ "with code %d\n", res);
+ curl_multi_cleanup(m);
+ curl_easy_cleanup(c);
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
+
+ mp_timedout = FALSE;
+ mp_start = curlx_tvnow();
+
while (running) {
- res = curl_multi_perform(m, &running);
+ res = (int)curl_multi_perform(m, &running);
+ if (curlx_tvdiff(curlx_tvnow(), mp_start) >
+ MULTI_PERFORM_HANG_TIMEOUT) {
+ mp_timedout = TRUE;
+ break;
+ }
if (running <= 0) {
fprintf(stderr, "nothing left running.\n");
break;
}
}
+
+ if (mp_timedout) {
+ if (mp_timedout) fprintf(stderr, "mp_timedout\n");
+ fprintf(stderr, "ABORTING TEST, since it seems "
+ "that it would have run forever.\n");
+ res = TEST_ERR_RUNS_FOREVER;
+ }
+
curl_multi_remove_handle(m, c);
curl_easy_cleanup(c);
curl_multi_cleanup(m);
+ curl_global_cleanup();
return res;
}
char ml_timedout = FALSE;
char mp_timedout = FALSE;
- curl_global_init(CURL_GLOBAL_ALL);
- c = curl_easy_init();
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
+
+ if ((c = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
+
curl_easy_setopt(c, CURLOPT_PROXY, arg2); /* set in first.c */
curl_easy_setopt(c, CURLOPT_URL, URL);
curl_easy_setopt(c, CURLOPT_USERPWD, "test:ing");
curl_easy_setopt(c, CURLOPT_HTTPPROXYTUNNEL, 1);
curl_easy_setopt(c, CURLOPT_HEADER, 1);
+ if ((m = curl_multi_init()) == NULL) {
+ fprintf(stderr, "curl_multi_init() failed\n");
+ curl_easy_cleanup(c);
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
- m = curl_multi_init();
-
- res = (int)curl_multi_add_handle(m, c);
+ if ((res = (int)curl_multi_add_handle(m, c)) != CURLM_OK) {
+ fprintf(stderr, "curl_multi_add_handle() failed, "
+ "with code %d\n", res);
+ curl_multi_cleanup(m);
+ curl_easy_cleanup(c);
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
ml_timedout = FALSE;
ml_start = curlx_tvnow();
if (mp_timedout) fprintf(stderr, "mp_timedout\n");
fprintf(stderr, "ABORTING TEST, since it seems "
"that it would have run forever.\n");
- res = 77;
+ res = TEST_ERR_RUNS_FOREVER;
}
curl_multi_remove_handle(m, c);
curl_easy_cleanup(c);
curl_multi_cleanup(m);
-
curl_global_cleanup();
+
return res;
}
CURLM *m;
fd_set rd, wr, exc;
CURLMcode res;
+ char done = FALSE;
int running;
int max_fd;
int rc;
char ml_timedout = FALSE;
char mp_timedout = FALSE;
- curl_global_init(CURL_GLOBAL_ALL);
- c = curl_easy_init();
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
+
+ if ((c = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
/* the point here being that there must not run anything on the given
proxy port */
curl_easy_setopt(c, CURLOPT_URL, URL);
curl_easy_setopt(c, CURLOPT_VERBOSE, 1);
- m = curl_multi_init();
+ if ((m = curl_multi_init()) == NULL) {
+ fprintf(stderr, "curl_multi_init() failed\n");
+ curl_easy_cleanup(c);
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
- res = curl_multi_add_handle(m, c);
- if(res && (res != CURLM_CALL_MULTI_PERFORM))
- ; /* major failure */
- else {
+ if ((res = (int)curl_multi_add_handle(m, c)) != CURLM_OK) {
+ fprintf(stderr, "curl_multi_add_handle() failed, "
+ "with code %d\n", res);
+ curl_multi_cleanup(m);
+ curl_easy_cleanup(c);
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
- ml_timedout = FALSE;
- ml_start = curlx_tvnow();
+ ml_timedout = FALSE;
+ ml_start = curlx_tvnow();
- do {
- struct timeval interval;
+ while (!done) {
+ struct timeval interval;
- interval.tv_sec = 1;
- interval.tv_usec = 0;
+ interval.tv_sec = 1;
+ interval.tv_usec = 0;
- if (curlx_tvdiff(curlx_tvnow(), ml_start) >
- MAIN_LOOP_HANG_TIMEOUT) {
- ml_timedout = TRUE;
- break;
- }
+ if (curlx_tvdiff(curlx_tvnow(), ml_start) >
+ MAIN_LOOP_HANG_TIMEOUT) {
+ ml_timedout = TRUE;
+ break;
+ }
+ mp_timedout = FALSE;
+ mp_start = curlx_tvnow();
- fprintf(stderr, "curl_multi_perform()\n");
+ fprintf(stderr, "curl_multi_perform()\n");
- mp_timedout = FALSE;
- mp_start = curlx_tvnow();
+ res = CURLM_CALL_MULTI_PERFORM;
- do {
- res = curl_multi_perform(m, &running);
- if (curlx_tvdiff(curlx_tvnow(), mp_start) >
- MULTI_PERFORM_HANG_TIMEOUT) {
- mp_timedout = TRUE;
- break;
- }
- } while (res == CURLM_CALL_MULTI_PERFORM);
- if (mp_timedout)
- break;
- if(!running) {
- /* This is where this code is expected to reach */
- int numleft;
- CURLMsg *msg = curl_multi_info_read(m, &numleft);
- fprintf(stderr, "Expected: not running\n");
- if(msg && !numleft)
- ret = 100; /* this is where we should be */
- else
- ret = 99; /* not correct */
+ while (res == CURLM_CALL_MULTI_PERFORM) {
+ res = (int)curl_multi_perform(m, &running);
+ if (curlx_tvdiff(curlx_tvnow(), mp_start) >
+ MULTI_PERFORM_HANG_TIMEOUT) {
+ mp_timedout = TRUE;
break;
}
- fprintf(stderr, "running == %d, res == %d\n", running, res);
+ }
+ if (mp_timedout)
+ break;
+
+ if(!running) {
+ /* This is where this code is expected to reach */
+ int numleft;
+ CURLMsg *msg = curl_multi_info_read(m, &numleft);
+ fprintf(stderr, "Expected: not running\n");
+ if(msg && !numleft)
+ ret = 100; /* this is where we should be */
+ else
+ ret = 99; /* not correct */
+ break;
+ }
+ fprintf(stderr, "running == %d, res == %d\n", running, res);
- if (res != CURLM_OK) {
- ret = 2;
- break;
- }
+ if (res != CURLM_OK) {
+ ret = 2;
+ break;
+ }
- FD_ZERO(&rd);
- FD_ZERO(&wr);
- FD_ZERO(&exc);
- max_fd = 0;
+ FD_ZERO(&rd);
+ FD_ZERO(&wr);
+ FD_ZERO(&exc);
+ max_fd = 0;
- fprintf(stderr, "curl_multi_fdset()\n");
- if (curl_multi_fdset(m, &rd, &wr, &exc, &max_fd) != CURLM_OK) {
- fprintf(stderr, "unexpected failured of fdset.\n");
- ret = 3;
- break;
- }
- rc = select_test(max_fd+1, &rd, &wr, &exc, &interval);
- fprintf(stderr, "select returned %d\n", rc);
-
- } while(1);
- if (ml_timedout || mp_timedout) {
- if (ml_timedout) fprintf(stderr, "ml_timedout\n");
- if (mp_timedout) fprintf(stderr, "mp_timedout\n");
- fprintf(stderr, "ABORTING TEST, since it seems "
- "that it would have run forever.\n");
- ret = 77;
+ fprintf(stderr, "curl_multi_fdset()\n");
+ if (curl_multi_fdset(m, &rd, &wr, &exc, &max_fd) != CURLM_OK) {
+ fprintf(stderr, "unexpected failured of fdset.\n");
+ ret = 3;
+ break;
}
+ rc = select_test(max_fd+1, &rd, &wr, &exc, &interval);
+ fprintf(stderr, "select returned %d\n", rc);
+ }
+
+ if (ml_timedout || mp_timedout) {
+ if (ml_timedout) fprintf(stderr, "ml_timedout\n");
+ if (mp_timedout) fprintf(stderr, "mp_timedout\n");
+ fprintf(stderr, "ABORTING TEST, since it seems "
+ "that it would have run forever.\n");
+ ret = TEST_ERR_RUNS_FOREVER;
}
curl_multi_remove_handle(m, c);
curl_easy_cleanup(c);
curl_multi_cleanup(m);
+ curl_global_cleanup();
return ret;
}
FILE *hd_src ;
int hd ;
struct_stat file_info;
+ struct curl_slist *hl;
struct curl_slist *headerlist=NULL;
const char *buf_1 = "RNFR 505";
return -2; /* if this happens things are major weird */
}
- /* In windows, this will init the winsock stuff */
- curl_global_init(CURL_GLOBAL_ALL);
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ fclose(hd_src);
+ return TEST_ERR_MAJOR_BAD;
+ }
/* get a curl handle */
- curl = curl_easy_init();
- if(curl) {
- struct curl_slist *hl;
- /* build a list of commands to pass to libcurl */
- hl = curl_slist_append(headerlist, buf_1);
- if(hl) {
- headerlist = curl_slist_append(hl, buf_2);
- if(hl)
- headerlist = hl;
- }
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ fclose(hd_src);
+ return TEST_ERR_MAJOR_BAD;
+ }
- /* enable uploading */
- curl_easy_setopt(curl, CURLOPT_UPLOAD, TRUE) ;
+ /* build a list of commands to pass to libcurl */
- /* enable verbose */
- curl_easy_setopt(curl, CURLOPT_VERBOSE, TRUE) ;
+ if ((hl = curl_slist_append(headerlist, buf_1)) == NULL) {
+ fprintf(stderr, "curl_slist_append() failed\n");
+ curl_easy_cleanup(curl);
+ curl_global_cleanup();
+ fclose(hd_src);
+ return TEST_ERR_MAJOR_BAD;
+ }
+ if ((headerlist = curl_slist_append(hl, buf_2)) == NULL) {
+ fprintf(stderr, "curl_slist_append() failed\n");
+ curl_slist_free_all(hl);
+ curl_easy_cleanup(curl);
+ curl_global_cleanup();
+ fclose(hd_src);
+ return TEST_ERR_MAJOR_BAD;
+ }
+ headerlist = hl;
- /* specify target */
- curl_easy_setopt(curl,CURLOPT_URL, URL);
+ /* enable uploading */
+ curl_easy_setopt(curl, CURLOPT_UPLOAD, TRUE) ;
- /* pass in that last of FTP commands to run after the transfer */
- curl_easy_setopt(curl, CURLOPT_POSTQUOTE, headerlist);
+ /* enable verbose */
+ curl_easy_setopt(curl, CURLOPT_VERBOSE, TRUE) ;
- /* now specify which file to upload */
- curl_easy_setopt(curl, CURLOPT_INFILE, hd_src);
+ /* specify target */
+ curl_easy_setopt(curl,CURLOPT_URL, URL);
- /* and give the size of the upload (optional) */
- curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE,
- (curl_off_t)file_info.st_size);
+ /* pass in that last of FTP commands to run after the transfer */
+ curl_easy_setopt(curl, CURLOPT_POSTQUOTE, headerlist);
- /* Now run off and do what you've been told! */
- res = curl_easy_perform(curl);
+ /* now specify which file to upload */
+ curl_easy_setopt(curl, CURLOPT_INFILE, hd_src);
- /* clean up the FTP commands list */
- curl_slist_free_all (headerlist);
+ /* and give the size of the upload (optional) */
+ curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE,
+ (curl_off_t)file_info.st_size);
- /* always cleanup */
- curl_easy_cleanup(curl);
- }
- fclose(hd_src); /* close the local file */
+ /* Now run off and do what you've been told! */
+ res = curl_easy_perform(curl);
+
+ /* clean up the FTP commands list */
+ curl_slist_free_all(headerlist);
+ /* close the local file */
+ fclose(hd_src);
+
+ curl_easy_cleanup(curl);
curl_global_cleanup();
+
return res;
}
CURLcode code;
struct curl_slist *headers;
struct Tdata *tdata = (struct Tdata*)ptr;
- CURL *curl = curl_easy_init();
+ CURL *curl;
int i=0;
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ return NULL;
+ }
+
headers = sethost(NULL);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, (void*)headers);
user.counter = 0;
printf( "GLOBAL_INIT\n" );
- curl_global_init( CURL_GLOBAL_ALL );
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
/* prepare share */
printf( "SHARE_INIT\n" );
- share = curl_share_init();
+ if ((share = curl_share_init()) == NULL) {
+ fprintf(stderr, "curl_share_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
if ( CURLSHE_OK == scode ) {
printf( "CURLSHOPT_LOCKFUNC\n" );
}
if ( CURLSHE_OK != scode ) {
+ fprintf(stderr, "curl_share_setopt() failed\n");
curl_share_cleanup(share);
- return 2;
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
}
/* fetch a another one and save cookies */
printf( "*** run %d\n", i );
- curl = curl_easy_init();
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_share_cleanup(share);
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
url = suburl( URL, i );
headers = sethost( NULL );
char ml_timedout = FALSE;
char mp_timedout = FALSE;
- multi = curl_multi_init();
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
+
+ if ((multi = curl_multi_init()) == NULL) {
+ fprintf(stderr, "curl_multi_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
+
+ if ((curls = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_multi_cleanup(multi);
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
- curls=curl_easy_init();
curl_easy_setopt(curls, CURLOPT_URL, URL);
- curl_multi_add_handle(multi, curls);
+
+ if ((res = (int)curl_multi_add_handle(multi, curls)) != CURLM_OK) {
+ fprintf(stderr, "curl_multi_add_handle() failed, "
+ "with code %d\n", res);
+ curl_easy_cleanup(curls);
+ curl_multi_cleanup(multi);
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
mp_timedout = FALSE;
mp_start = curlx_tvnow();
if (mp_timedout) fprintf(stderr, "mp_timedout\n");
fprintf(stderr, "ABORTING TEST, since it seems "
"that it would have run forever.\n");
- i = 77;
+ i = TEST_ERR_RUNS_FOREVER;
}
else {
msg = curl_multi_info_read(multi, &still_running);
curl_multi_cleanup(multi);
curl_easy_cleanup(curls);
+ curl_global_cleanup();
return i; /* return the final return code */
}
pooh.readptr = data;
pooh.sizeleft = strlen(data);
- curl = curl_easy_init();
- if(curl) {
- /* First set the URL that is about to receive our POST. */
- curl_easy_setopt(curl, CURLOPT_URL, URL);
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
- /* Now specify we want to POST data */
- curl_easy_setopt(curl, CURLOPT_POST, TRUE);
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
- /* Set the expected POST size */
- curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long)pooh.sizeleft);
+ /* First set the URL that is about to receive our POST. */
+ curl_easy_setopt(curl, CURLOPT_URL, URL);
- /* we want to use our own read function */
- curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
+ /* Now specify we want to POST data */
+ curl_easy_setopt(curl, CURLOPT_POST, TRUE);
- /* pointer to pass to our read function */
- curl_easy_setopt(curl, CURLOPT_INFILE, &pooh);
+ /* Set the expected POST size */
+ curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long)pooh.sizeleft);
- /* get verbose debug output please */
- curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
+ /* we want to use our own read function */
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
- /* include headers in the output */
- curl_easy_setopt(curl, CURLOPT_HEADER, TRUE);
+ /* pointer to pass to our read function */
+ curl_easy_setopt(curl, CURLOPT_INFILE, &pooh);
- /* Perform the request, res will get the return code */
- res = curl_easy_perform(curl);
+ /* get verbose debug output please */
+ curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
+
+ /* include headers in the output */
+ curl_easy_setopt(curl, CURLOPT_HEADER, TRUE);
+
+ /* Perform the request, res will get the return code */
+ res = curl_easy_perform(curl);
+
+ /* always cleanup */
+ curl_easy_cleanup(curl);
+ curl_global_cleanup();
- /* always cleanup */
- curl_easy_cleanup(curl);
- }
return res;
}
{
CURLM* multi;
sslctxparm p;
-
+ CURLMcode res;
+ int running;
+ char done = FALSE;
int i = 0;
CURLMsg *msg;
portnum = atoi(arg2);
}
- curl_global_init(CURL_GLOBAL_ALL);
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
- p.curl = curl_easy_init();
+ if ((p.curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
p.accessinfoURL = (unsigned char *) strdup(URL);
p.accesstype = OBJ_obj2nid(OBJ_txt2obj("AD_DVCS",0)) ;
curl_easy_setopt(p.curl, CURLOPT_SSL_VERIFYPEER, FALSE);
curl_easy_setopt(p.curl, CURLOPT_SSL_VERIFYHOST, 1);
- fprintf(stderr, "Going to perform %s\n", (char *)p.accessinfoURL);
-
- {
- CURLMcode res;
- int running;
- char done=FALSE;
+ if ((multi = curl_multi_init()) == NULL) {
+ fprintf(stderr, "curl_multi_init() failed\n");
+ curl_easy_cleanup(p.curl);
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
- multi = curl_multi_init();
+ if ((res = curl_multi_add_handle(multi, p.curl)) != CURLM_OK) {
+ fprintf(stderr, "curl_multi_add_handle() failed, "
+ "with code %d\n", res);
+ curl_multi_cleanup(multi);
+ curl_easy_cleanup(p.curl);
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
- res = curl_multi_add_handle(multi, p.curl);
+ fprintf(stderr, "Going to perform %s\n", (char *)p.accessinfoURL);
- ml_timedout = FALSE;
- ml_start = curlx_tvnow();
+ ml_timedout = FALSE;
+ ml_start = curlx_tvnow();
- while (!done) {
- fd_set rd, wr, exc;
- int max_fd;
- struct timeval interval;
+ while (!done) {
+ fd_set rd, wr, exc;
+ int max_fd;
+ struct timeval interval;
- interval.tv_sec = 1;
- interval.tv_usec = 0;
+ interval.tv_sec = 1;
+ interval.tv_usec = 0;
- if (curlx_tvdiff(curlx_tvnow(), ml_start) >
- MAIN_LOOP_HANG_TIMEOUT) {
- ml_timedout = TRUE;
+ if (curlx_tvdiff(curlx_tvnow(), ml_start) >
+ MAIN_LOOP_HANG_TIMEOUT) {
+ ml_timedout = TRUE;
+ break;
+ }
+ mp_timedout = FALSE;
+ mp_start = curlx_tvnow();
+
+ while (res == CURLM_CALL_MULTI_PERFORM) {
+ res = curl_multi_perform(multi, &running);
+ if (curlx_tvdiff(curlx_tvnow(), mp_start) >
+ MULTI_PERFORM_HANG_TIMEOUT) {
+ mp_timedout = TRUE;
break;
}
- mp_timedout = FALSE;
- mp_start = curlx_tvnow();
-
- while (res == CURLM_CALL_MULTI_PERFORM) {
- res = curl_multi_perform(multi, &running);
- if (curlx_tvdiff(curlx_tvnow(), mp_start) >
- MULTI_PERFORM_HANG_TIMEOUT) {
- mp_timedout = TRUE;
- break;
- }
- fprintf(stderr, "running=%d res=%d\n",running,res);
- if (running <= 0) {
- done = TRUE;
- break;
- }
- }
- if (mp_timedout || done)
- break;
-
- if (res != CURLM_OK) {
- fprintf(stderr, "not okay???\n");
- i = 80;
+ fprintf(stderr, "running=%d res=%d\n",running,res);
+ if (running <= 0) {
+ done = TRUE;
break;
}
+ }
+ if (mp_timedout || done)
+ break;
- FD_ZERO(&rd);
- FD_ZERO(&wr);
- FD_ZERO(&exc);
- max_fd = 0;
+ if (res != CURLM_OK) {
+ fprintf(stderr, "not okay???\n");
+ i = 80;
+ break;
+ }
- if (curl_multi_fdset(multi, &rd, &wr, &exc, &max_fd) != CURLM_OK) {
- fprintf(stderr, "unexpected failured of fdset.\n");
- i = 89;
- break;
- }
+ FD_ZERO(&rd);
+ FD_ZERO(&wr);
+ FD_ZERO(&exc);
+ max_fd = 0;
- if (select_test(max_fd+1, &rd, &wr, &exc, &interval) == -1) {
- fprintf(stderr, "bad select??\n");
- i =95;
- break;
- }
-
- res = CURLM_CALL_MULTI_PERFORM;
+ if (curl_multi_fdset(multi, &rd, &wr, &exc, &max_fd) != CURLM_OK) {
+ fprintf(stderr, "unexpected failured of fdset.\n");
+ i = 89;
+ break;
}
- if (ml_timedout || mp_timedout) {
- if (ml_timedout) fprintf(stderr, "ml_timedout\n");
- if (mp_timedout) fprintf(stderr, "mp_timedout\n");
- fprintf(stderr, "ABORTING TEST, since it seems "
- "that it would have run forever.\n");
- i = 77;
- }
- else {
- msg = curl_multi_info_read(multi, &running);
- /* this should now contain a result code from the easy handle, get it */
- if(msg)
- i = msg->data.result;
+ if (select_test(max_fd+1, &rd, &wr, &exc, &interval) == -1) {
+ fprintf(stderr, "bad select??\n");
+ i =95;
+ break;
}
+
+ res = CURLM_CALL_MULTI_PERFORM;
}
- if ((!ml_timedout) && (!mp_timedout)) {
+ if (ml_timedout || mp_timedout) {
+ if (ml_timedout) fprintf(stderr, "ml_timedout\n");
+ if (mp_timedout) fprintf(stderr, "mp_timedout\n");
+ fprintf(stderr, "ABORTING TEST, since it seems "
+ "that it would have run forever.\n");
+ i = TEST_ERR_RUNS_FOREVER;
+ }
+ else {
+ msg = curl_multi_info_read(multi, &running);
+ /* this should now contain a result code from the easy handle, get it */
+ if(msg)
+ i = msg->data.result;
fprintf(stderr, "all done\n");
}
struct WriteThis pooh;
pooh.counter = 0;
- slist = curl_slist_append(slist, "Transfer-Encoding: chunked");
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
- curl = curl_easy_init();
- if(curl) {
- /* First set the URL that is about to receive our POST. */
- curl_easy_setopt(curl, CURLOPT_URL, URL);
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
- /* Now specify we want to POST data */
- curl_easy_setopt(curl, CURLOPT_POST, TRUE);
+ slist = curl_slist_append(slist, "Transfer-Encoding: chunked");
+ if (slist == NULL) {
+ fprintf(stderr, "curl_slist_append() failed\n");
+ curl_easy_cleanup(curl);
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
- /* we want to use our own read function */
- curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
+ /* First set the URL that is about to receive our POST. */
+ curl_easy_setopt(curl, CURLOPT_URL, URL);
- /* pointer to pass to our read function */
- curl_easy_setopt(curl, CURLOPT_INFILE, &pooh);
+ /* Now specify we want to POST data */
+ curl_easy_setopt(curl, CURLOPT_POST, TRUE);
- /* get verbose debug output please */
- curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
+ /* we want to use our own read function */
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
- /* include headers in the output */
- curl_easy_setopt(curl, CURLOPT_HEADER, TRUE);
+ /* pointer to pass to our read function */
+ curl_easy_setopt(curl, CURLOPT_INFILE, &pooh);
- /* enforce chunked transfer by setting the header */
- curl_easy_setopt(curl, CURLOPT_HTTPHEADER, slist);
+ /* get verbose debug output please */
+ curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
- /* Perform the request, res will get the return code */
- res = curl_easy_perform(curl);
+ /* include headers in the output */
+ curl_easy_setopt(curl, CURLOPT_HEADER, TRUE);
- /* always cleanup */
- curl_easy_cleanup(curl);
+ /* enforce chunked transfer by setting the header */
+ curl_easy_setopt(curl, CURLOPT_HTTPHEADER, slist);
- }
+ /* Perform the request, res will get the return code */
+ res = curl_easy_perform(curl);
+ /* clean up the headers list */
if(slist)
- /* clean up the headers list */
curl_slist_free_all(slist);
+ /* always cleanup */
+ curl_easy_cleanup(curl);
+ curl_global_cleanup();
+
return res;
}
int test(char *URL)
{
CURLcode res;
- CURL *curl = curl_easy_init();
+ CURL *curl;
+
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
+
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
+
curl_easy_setopt(curl, CURLOPT_URL, URL);
curl_easy_setopt(curl, CURLOPT_FILETIME, 1);
curl_easy_setopt(curl, CURLOPT_NOBODY, 1);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
+
res = curl_easy_perform(curl);
+
curl_easy_cleanup(curl);
+ curl_global_cleanup();
+
return (int)res;
}
}
else
rc = 4;
+
+ curl_global_cleanup();
}
else
rc = 5;
CURL *curl;
CURLcode res=CURLE_OK;
- curl = curl_easy_init();
- if(curl) {
- /* First set the URL that is about to receive our POST. */
- curl_easy_setopt(curl, CURLOPT_URL, URL);
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
- /* Now specify we want to POST data */
- curl_easy_setopt(curl, CURLOPT_POST, TRUE);
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
- /* Set the expected POST size */
- curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, 1);
+ /* First set the URL that is about to receive our POST. */
+ curl_easy_setopt(curl, CURLOPT_URL, URL);
- /* we want to use our own read function */
- curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
+ /* Now specify we want to POST data */
+ curl_easy_setopt(curl, CURLOPT_POST, TRUE);
- /* pointer to pass to our read function */
- curl_easy_setopt(curl, CURLOPT_INFILE, NULL);
+ /* Set the expected POST size */
+ curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, 1);
- /* get verbose debug output please */
- curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
+ /* we want to use our own read function */
+ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
- /* include headers in the output */
- curl_easy_setopt(curl, CURLOPT_HEADER, TRUE);
+ /* pointer to pass to our read function */
+ curl_easy_setopt(curl, CURLOPT_INFILE, NULL);
- /* Perform the request, res will get the return code */
- res = curl_easy_perform(curl);
+ /* get verbose debug output please */
+ curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
+
+ /* include headers in the output */
+ curl_easy_setopt(curl, CURLOPT_HEADER, TRUE);
+
+ /* Perform the request, res will get the return code */
+ res = curl_easy_perform(curl);
+
+ /* always cleanup */
+ curl_easy_cleanup(curl);
+ curl_global_cleanup();
- /* always cleanup */
- curl_easy_cleanup(curl);
- }
return (int)res;
}
CURL *curl;
CURLcode res=CURLE_OK;
- curl = curl_easy_init();
- if(curl) {
- /* First set the URL that is about to receive our POST. */
- curl_easy_setopt(curl, CURLOPT_URL, URL);
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
- /* Based on a bug report by Niels van Tongeren on June 29, 2004:
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
- A weird situation occurs when request 1 is a POST request and the request
- 2 is a HEAD request. For the POST request we set the CURLOPT_POSTFIELDS,
- CURLOPT_POSTFIELDSIZE and CURLOPT_POST options. For the HEAD request we
- set the CURLOPT_NOBODY option to '1'.
+ /* First set the URL that is about to receive our POST. */
+ curl_easy_setopt(curl, CURLOPT_URL, URL);
- */
+ /* Based on a bug report by Niels van Tongeren on June 29, 2004:
- curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "moo");
- curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, 3);
- curl_easy_setopt(curl, CURLOPT_POST, 1);
+ A weird situation occurs when request 1 is a POST request and the request
+ 2 is a HEAD request. For the POST request we set the CURLOPT_POSTFIELDS,
+ CURLOPT_POSTFIELDSIZE and CURLOPT_POST options. For the HEAD request we
+ set the CURLOPT_NOBODY option to '1'.
- /* this is where transfer 1 would take place, but skip that and change
- options right away instead */
+ */
- curl_easy_setopt(curl, CURLOPT_NOBODY, 1);
+ curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "moo");
+ curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, 3);
+ curl_easy_setopt(curl, CURLOPT_POST, 1);
- curl_easy_setopt(curl, CURLOPT_VERBOSE, 1); /* show verbose for debug */
- curl_easy_setopt(curl, CURLOPT_HEADER, 1); /* include header */
+ /* this is where transfer 1 would take place, but skip that and change
+ options right away instead */
- /* Now, we should be making a fine HEAD request */
+ curl_easy_setopt(curl, CURLOPT_NOBODY, 1);
- /* Perform the request 2, res will get the return code */
- res = curl_easy_perform(curl);
+ curl_easy_setopt(curl, CURLOPT_VERBOSE, 1); /* show verbose for debug */
+ curl_easy_setopt(curl, CURLOPT_HEADER, 1); /* include header */
+
+ /* Now, we should be making a fine HEAD request */
+
+ /* Perform the request 2, res will get the return code */
+ res = curl_easy_perform(curl);
+
+ /* always cleanup */
+ curl_easy_cleanup(curl);
+ curl_global_cleanup();
- /* always cleanup */
- curl_easy_cleanup(curl);
- }
return (int)res;
}
CURL *curl;
CURLcode res=CURLE_OK;
- curl = curl_easy_init();
- if(curl) {
- /* First set the URL that is about to receive our POST. */
- curl_easy_setopt(curl, CURLOPT_URL, URL);
- curl_easy_setopt(curl, CURLOPT_POSTFIELDS, NULL);
- curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, 0);
- curl_easy_setopt(curl, CURLOPT_VERBOSE, 1); /* show verbose for debug */
- curl_easy_setopt(curl, CURLOPT_HEADER, 1); /* include header */
-
- /* Now, we should be making a zero byte POST request */
- res = curl_easy_perform(curl);
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
- /* always cleanup */
- curl_easy_cleanup(curl);
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
}
+
+ /* First set the URL that is about to receive our POST. */
+ curl_easy_setopt(curl, CURLOPT_URL, URL);
+ curl_easy_setopt(curl, CURLOPT_POSTFIELDS, NULL);
+ curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, 0);
+ curl_easy_setopt(curl, CURLOPT_VERBOSE, 1); /* show verbose for debug */
+ curl_easy_setopt(curl, CURLOPT_HEADER, 1); /* include header */
+
+ /* Now, we should be making a zero byte POST request */
+ res = curl_easy_perform(curl);
+
+ /* always cleanup */
+ curl_easy_cleanup(curl);
+ curl_global_cleanup();
+
return (int)res;
}
CURL *curl;
CURLcode res=CURLE_OK;
- curl = curl_easy_init();
- if(curl) {
- /* First set the URL that is about to receive our POST. */
- curl_easy_setopt(curl, CURLOPT_URL, URL);
- curl_easy_setopt(curl, CURLOPT_HTTPPOST, NULL);
- curl_easy_setopt(curl, CURLOPT_VERBOSE, 1); /* show verbose for debug */
- curl_easy_setopt(curl, CURLOPT_HEADER, 1); /* include header */
-
- /* Now, we should be making a zero byte POST request */
- res = curl_easy_perform(curl);
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
- /* always cleanup */
- curl_easy_cleanup(curl);
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
}
+
+ /* First set the URL that is about to receive our POST. */
+ curl_easy_setopt(curl, CURLOPT_URL, URL);
+ curl_easy_setopt(curl, CURLOPT_HTTPPOST, NULL);
+ curl_easy_setopt(curl, CURLOPT_VERBOSE, 1); /* show verbose for debug */
+ curl_easy_setopt(curl, CURLOPT_HEADER, 1); /* include header */
+
+ /* Now, we should be making a zero byte POST request */
+ res = curl_easy_perform(curl);
+
+ /* always cleanup */
+ curl_easy_cleanup(curl);
+ curl_global_cleanup();
+
return (int)res;
}
static int fd[NUM_OPEN];
+/*
+ * our_errno() returns the NOT *socket-related* errno (or equivalent)
+ * on this platform to hide platform specific for the calling function.
+ */
+
+static int our_errno(void)
+{
+#ifdef WIN32
+ return (int)GetLastError();
+#else
+ return errno;
+#endif
+}
+
static int rlimit(void)
{
int i;
/* open a dummy descriptor */
fd[0] = open(DEV_NULL, O_RDONLY);
if (fd[0] == -1) {
- fprintf(stderr, "open: failed to open %s\n", DEV_NULL);
+ fprintf(stderr, "open: failed to open %s "
+ "with errno %d\n", DEV_NULL, our_errno());
return -4;
}
for (i = 1; i < NUM_OPEN; i++) {
fd[i] = dup(fd[0]);
if (fd[i] == -1) {
- fprintf(stderr, "dup: attempt #%i failed\n", i);
+ fprintf(stderr, "dup: attempt #%d failed "
+ "with errno %d\n", i, our_errno());
for (i--; i >= 0; i--)
close(fd[i]);
return -5;
/* failure */
return 100;
- curl = curl_easy_init();
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
+
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
+
curl_easy_setopt(curl, CURLOPT_URL, URL);
curl_easy_setopt(curl, CURLOPT_HEADER, TRUE);
res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
+ curl_global_cleanup();
/* we never close the file descriptors */
int test(char *URL)
{
CURLcode res;
- CURL *curl = curl_easy_init();
+ CURL *curl;
+
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
+
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
+
curl_easy_setopt(curl, CURLOPT_URL, URL);
curl_easy_setopt(curl, CURLOPT_USERPWD, "monster:underbed");
curl_easy_setopt(curl, CURLOPT_HEADER, TRUE);
curl_easy_setopt(curl, CURLOPT_VERBOSE, TRUE);
+
/* get first page */
res = curl_easy_perform(curl);
curl_easy_setopt(curl, CURLOPT_USERPWD, "anothermonster:inwardrobe");
+
/* get second page */
res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
+ curl_global_cleanup();
+
return (int)res;
}
int test(char *URL)
{
CURLcode res;
- CURL *curl = curl_easy_init();
+ CURL *curl;
+
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
+
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
+
curl_easy_setopt(curl, CURLOPT_URL, URL);
curl_easy_setopt(curl, CURLOPT_FILETIME, 1);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
+
res = curl_easy_perform(curl);
+
curl_easy_cleanup(curl);
+ curl_global_cleanup();
+
return (int)res;
}
int test(char *URL)
{
CURLcode res;
- CURL *curl = curl_easy_init();
+ CURL *curl;
+
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
+
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
+
curl_easy_setopt(curl, CURLOPT_URL, URL);
curl_easy_setopt(curl, CURLOPT_PORT, atoi(arg2));
curl_easy_setopt(curl, CURLOPT_USERPWD, "xxx:yyy");
curl_easy_setopt(curl, CURLOPT_VERBOSE, TRUE);
res = curl_easy_perform(curl);
+
curl_easy_cleanup(curl);
+ curl_global_cleanup();
+
return (int)res;
}
int test(char *URL)
{
CURLcode res;
- CURL *curl = curl_easy_init();
+ CURL *curl;
+
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
+
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
+
curl_easy_setopt(curl, CURLOPT_PROXY, arg2);
curl_easy_setopt(curl, CURLOPT_URL, URL);
curl_easy_setopt(curl, CURLOPT_PORT, 19999);
curl_easy_setopt(curl, CURLOPT_VERBOSE, TRUE);
res = curl_easy_perform(curl);
+
curl_easy_cleanup(curl);
+ curl_global_cleanup();
+
return (int)res;
}
int test(char *URL)
{
CURLcode res;
- CURL *curl = curl_easy_init();
+ CURL *curl;
+
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
+
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
+
curl_easy_setopt(curl, CURLOPT_URL, URL);
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
curl_easy_setopt(curl, CURLOPT_VERBOSE, TRUE);
res = curl_easy_perform(curl);
+
curl_easy_cleanup(curl);
+ curl_global_cleanup();
+
return (int)res;
}
an example! */
hd_src = fopen(arg2, "rb");
- /* In windows, this will init the winsock stuff */
- curl_global_init(CURL_GLOBAL_ALL);
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ fclose(hd_src);
+ return TEST_ERR_MAJOR_BAD;
+ }
- /* get a curl handle */
- curl = curl_easy_init();
- if(!curl) {
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
fclose(hd_src);
curl_global_cleanup();
- return 100; /* major bad */
+ return TEST_ERR_MAJOR_BAD;
}
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE,
(curl_off_t)file_info.st_size);
- m = curl_multi_init();
+ if ((m = curl_multi_init()) == NULL) {
+ fprintf(stderr, "curl_multi_init() failed\n");
+ curl_easy_cleanup(curl);
+ curl_global_cleanup();
+ fclose(hd_src);
+ return TEST_ERR_MAJOR_BAD;
+ }
- res = (int)curl_multi_add_handle(m, curl);
+ if ((res = (int)curl_multi_add_handle(m, curl)) != CURLM_OK) {
+ fprintf(stderr, "curl_multi_add_handle() failed, "
+ "with code %d\n", res);
+ curl_multi_cleanup(m);
+ curl_easy_cleanup(curl);
+ curl_global_cleanup();
+ fclose(hd_src);
+ return TEST_ERR_MAJOR_BAD;
+ }
ml_timedout = FALSE;
ml_start = curlx_tvnow();
if (mp_timedout) fprintf(stderr, "mp_timedout\n");
fprintf(stderr, "ABORTING TEST, since it seems "
"that it would have run forever.\n");
- res = 77;
+ res = TEST_ERR_RUNS_FOREVER;
}
#ifdef LIB529
char done=FALSE;
CURLM *m;
int current=0;
- int i;
+ int i, j;
struct timeval ml_start;
struct timeval mp_start;
char ml_timedout = FALSE;
char mp_timedout = FALSE;
- /* In windows, this will init the winsock stuff */
- curl_global_init(CURL_GLOBAL_ALL);
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
/* get NUM_HANDLES easy handles */
for(i=0; i < NUM_HANDLES; i++) {
curl[i] = curl_easy_init();
if(!curl[i]) {
+ fprintf(stderr, "curl_easy_init() failed "
+ "on handle #%d\n", i);
+ for (j=i-1; j >= 0; j--) {
+ curl_easy_cleanup(curl[j]);
+ }
curl_global_cleanup();
- return 100 + i; /* major bad */
+ return TEST_ERR_MAJOR_BAD + i;
}
curl_easy_setopt(curl[i], CURLOPT_URL, URL);
curl_easy_setopt(curl[i], CURLOPT_VERBOSE, 1);
}
- m = curl_multi_init();
+ if ((m = curl_multi_init()) == NULL) {
+ fprintf(stderr, "curl_multi_init() failed\n");
+ for(i=0; i < NUM_HANDLES; i++) {
+ curl_easy_cleanup(curl[i]);
+ }
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
- res = (int)curl_multi_add_handle(m, curl[current]);
+ if ((res = (int)curl_multi_add_handle(m, curl[current])) != CURLM_OK) {
+ fprintf(stderr, "curl_multi_add_handle() failed, "
+ "with code %d\n", res);
+ curl_multi_cleanup(m);
+ for(i=0; i < NUM_HANDLES; i++) {
+ curl_easy_cleanup(curl[i]);
+ }
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
ml_timedout = FALSE;
ml_start = curlx_tvnow();
if (mp_timedout) fprintf(stderr, "mp_timedout\n");
fprintf(stderr, "ABORTING TEST, since it seems "
"that it would have run forever.\n");
- res = 77;
+ res = TEST_ERR_RUNS_FOREVER;
}
#ifndef LIB527
int running;
char done=FALSE;
CURLM *m;
- int i;
+ int i, j;
struct timeval ml_start;
struct timeval mp_start;
char ml_timedout = FALSE;
char mp_timedout = FALSE;
- /* In windows, this will init the winsock stuff */
- curl_global_init(CURL_GLOBAL_ALL);
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
- m = curl_multi_init();
+ if ((m = curl_multi_init()) == NULL) {
+ fprintf(stderr, "curl_multi_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
/* get NUM_HANDLES easy handles */
for(i=0; i < NUM_HANDLES; i++) {
curl[i] = curl_easy_init();
if(!curl[i]) {
+ fprintf(stderr, "curl_easy_init() failed "
+ "on handle #%d\n", i);
+ for (j=i-1; j >= 0; j--) {
+ curl_multi_remove_handle(m, curl[j]);
+ curl_easy_cleanup(curl[j]);
+ }
+ curl_multi_cleanup(m);
curl_global_cleanup();
- return 100 + i; /* major bad */
+ return TEST_ERR_MAJOR_BAD + i;
}
curl_easy_setopt(curl[i], CURLOPT_URL, URL);
/* include headers */
curl_easy_setopt(curl[i], CURLOPT_HEADER, 1);
- res = (int)curl_multi_add_handle(m, curl[i]);
+ /* add handle to multi */
+ if ((res = (int)curl_multi_add_handle(m, curl[i])) != CURLM_OK) {
+ fprintf(stderr, "curl_multi_add_handle() failed, "
+ "on handle #%d with code %d\n", i, res);
+ curl_easy_cleanup(curl[i]);
+ for (j=i-1; j >= 0; j--) {
+ curl_multi_remove_handle(m, curl[j]);
+ curl_easy_cleanup(curl[j]);
+ }
+ curl_multi_cleanup(m);
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD + i;
+ }
}
curl_multi_setopt(m, CURLMOPT_PIPELINING, 1);
if (mp_timedout) fprintf(stderr, "mp_timedout\n");
fprintf(stderr, "ABORTING TEST, since it seems "
"that it would have run forever.\n");
- res = 77;
+ res = TEST_ERR_RUNS_FOREVER;
}
- /* get NUM_HANDLES easy handles */
+ /* cleanup NUM_HANDLES easy handles */
for(i=0; i < NUM_HANDLES; i++) {
curl_multi_remove_handle(m, curl[i]);
curl_easy_cleanup(curl[i]);
}
curl_multi_cleanup(m);
-
curl_global_cleanup();
+
return res;
}
char ml_timedout = FALSE;
char mp_timedout = FALSE;
- /* In windows, this will init the winsock stuff */
- curl_global_init(CURL_GLOBAL_ALL);
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
- curl = curl_easy_init();
- if(!curl) {
+ if ((curl = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
curl_global_cleanup();
- return 100; /* major bad */
+ return TEST_ERR_MAJOR_BAD;
}
curl_easy_setopt(curl, CURLOPT_URL, URL);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1);
- m = curl_multi_init();
+ if ((m = curl_multi_init()) == NULL) {
+ fprintf(stderr, "curl_multi_init() failed\n");
+ curl_easy_cleanup(curl);
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
- res = (int)curl_multi_add_handle(m, curl);
+ if ((res = (int)curl_multi_add_handle(m, curl)) != CURLM_OK) {
+ fprintf(stderr, "curl_multi_add_handle() failed, "
+ "with code %d\n", res);
+ curl_multi_cleanup(m);
+ curl_easy_cleanup(curl);
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
ml_timedout = FALSE;
ml_start = curlx_tvnow();
if (mp_timedout) fprintf(stderr, "mp_timedout\n");
fprintf(stderr, "ABORTING TEST, since it seems "
"that it would have run forever.\n");
- res = 77;
+ res = TEST_ERR_RUNS_FOREVER;
}
curl_easy_cleanup(curl);
curl_multi_cleanup(m);
-
curl_global_cleanup();
+
return res;
}
int test(char *URL)
{
- CURLM *multi = curl_multi_init();
- CURL *easy = curl_easy_init();
+ CURLM *multi;
+ CURL *easy;
+
+ if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
+ fprintf(stderr, "curl_global_init() failed\n");
+ return TEST_ERR_MAJOR_BAD;
+ }
+
+ if ((multi = curl_multi_init()) == NULL) {
+ fprintf(stderr, "curl_multi_init() failed\n");
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
+
+ if ((easy = curl_easy_init()) == NULL) {
+ fprintf(stderr, "curl_easy_init() failed\n");
+ curl_multi_cleanup(multi);
+ curl_global_cleanup();
+ return TEST_ERR_MAJOR_BAD;
+ }
curl_multi_setopt(multi, CURLMOPT_PIPELINING, 1);
curl_multi_remove_handle(multi, easy);
curl_easy_cleanup(easy);
curl_multi_cleanup(multi);
+ curl_global_cleanup();
printf("Finished!\n");
#define TRUE 1
#endif
+#define TEST_ERR_MAJOR_BAD 100
+#define TEST_ERR_RUNS_FOREVER 99
+
extern char *arg2; /* set by first.c to the argv[2] or NULL */
int select_test (int num_fds, fd_set *rd, fd_set *wr, fd_set *exc,
projects / curl / commitdiff