tests/libtest/cli_h2_pausing.c - third_party/curl - Git at Google

 /***************************************************************************
  *                                  _   _ ____  _
  *  Project                     ___| | | |  _ \| |
  *                             / __| | | | |_) | |
  *                            | (__| |_| |  _ <| |___
  *                             \___|\___/|_| \_\_____|
  *
  * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
  *
  * This software is licensed as described in the file COPYING, which
  * you should have received as part of this distribution. The terms
  * are also available at https://curl.se/docs/copyright.html.
  *
  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  * copies of the Software, and permit persons to whom the Software is
  * furnished to do so, under the terms of the COPYING file.
  *
  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  * KIND, either express or implied.
  *
  * SPDX-License-Identifier: curl
  *
  ***************************************************************************/
 /* This is based on the PoC client of issue #11982
  */
 #include "first.h"

 #include "testtrace.h"

 static void usage_h2_pausing(const char *msg)
 {
   if(msg)
     curl_mfprintf(stderr, "%s\n", msg);
   curl_mfprintf(stderr,
     "usage: [options] url\n"
     "  pause downloads with following options:\n"
     "  -V http_version (http/1.1, h2, h3) http version to use\n"
   );
 }

 struct handle {
   size_t idx;
   int paused;
   int resumed;
   int errored;
   int fail_write;
   CURL *curl;
 };

 static size_t cb(char *data, size_t size, size_t nmemb, void *clientp)
 {
   size_t realsize = size * nmemb;
   struct handle *handle = (struct handle *)clientp;
   curl_off_t totalsize;

   (void)data;
   if(curl_easy_getinfo(handle->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T,
                        &totalsize) == CURLE_OK)
     curl_mfprintf(stderr, "INFO: [%zu] write, "
                   "Content-Length %" CURL_FORMAT_CURL_OFF_T "\n",
                   handle->idx, totalsize);

   if(!handle->resumed) {
     ++handle->paused;
     curl_mfprintf(stderr, "INFO: [%zu] write, PAUSING %d time on %zu bytes\n",
                   handle->idx, handle->paused, realsize);
     assert(handle->paused == 1);
     return CURL_WRITEFUNC_PAUSE;
   }
   if(handle->fail_write) {
     ++handle->errored;
     curl_mfprintf(stderr, "INFO: [%zu] FAIL write of %zu bytes, %d time\n",
                   handle->idx, realsize, handle->errored);
     return CURL_WRITEFUNC_ERROR;
   }
   curl_mfprintf(stderr, "INFO: [%zu] write, accepting %zu bytes\n",
                 handle->idx, realsize);
   return realsize;
 }

 static CURLcode test_cli_h2_pausing(const char *URL)
 {
   struct handle handles[2];
   CURLM *multi = NULL;
   int still_running = 1, msgs_left, numfds;
   size_t i;
   CURLMsg *msg;
   int rounds = 0;
   CURLcode result = CURLE_OK;
   CURLU *cu;
   struct curl_slist *resolve = NULL;
   char resolve_buf[1024];
   const char *url;
   char *host = NULL, *port = NULL;
   int all_paused = 0;
   int resume_round = -1;
   long http_version = CURL_HTTP_VERSION_2_0;
   int ch;

   (void)URL;

   while((ch = cgetopt(test_argc, test_argv, "hV:")) != -1) {
     switch(ch) {
     case 'h':
       usage_h2_pausing(NULL);
       return (CURLcode)2;
     case 'V': {
       if(!strcmp("http/1.1", coptarg))
         http_version = CURL_HTTP_VERSION_1_1;
       else if(!strcmp("h2", coptarg))
         http_version = CURL_HTTP_VERSION_2_0;
       else if(!strcmp("h3", coptarg))
         http_version = CURL_HTTP_VERSION_3ONLY;
       else {
         usage_h2_pausing("invalid http version");
         return (CURLcode)1;
       }
       break;
     }
     default:
       usage_h2_pausing("invalid option");
       return (CURLcode)1;
     }
   }
   test_argc -= coptind;
   test_argv += coptind;

   if(test_argc != 1) {
     curl_mfprintf(stderr, "ERROR: need URL as argument\n");
     return (CURLcode)2;
   }
   url = test_argv[0];

   if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
     curl_mfprintf(stderr, "curl_global_init() failed\n");
     return (CURLcode)3;
   }

   curl_global_trace("ids,time,http/2,http/3");

   memset(handles, 0, sizeof(handles));

   cu = curl_url();
   if(!cu) {
     curl_mfprintf(stderr, "out of memory\n");
     result = (CURLcode)1;
     goto cleanup;
   }
   if(curl_url_set(cu, CURLUPART_URL, url, 0)) {
     curl_mfprintf(stderr, "not a URL: '%s'\n", url);
     result = (CURLcode)1;
     goto cleanup;
   }
   if(curl_url_get(cu, CURLUPART_HOST, &host, 0)) {
     curl_mfprintf(stderr, "could not get host of '%s'\n", url);
     result = (CURLcode)1;
     goto cleanup;
   }
   if(curl_url_get(cu, CURLUPART_PORT, &port, 0)) {
     curl_mfprintf(stderr, "could not get port of '%s'\n", url);
     result = (CURLcode)1;
     goto cleanup;
   }
   memset(&resolve, 0, sizeof(resolve));
   curl_msnprintf(resolve_buf, sizeof(resolve_buf) - 1, "%s:%s:127.0.0.1",
                  host, port);
   resolve = curl_slist_append(resolve, resolve_buf);

   for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
     handles[i].idx = i;
     handles[i].paused = 0;
     handles[i].resumed = 0;
     handles[i].errored = 0;
     handles[i].fail_write = 1;
     handles[i].curl = curl_easy_init();
     if(!handles[i].curl ||
        curl_easy_setopt(handles[i].curl, CURLOPT_WRITEFUNCTION, cb)
          != CURLE_OK ||
        curl_easy_setopt(handles[i].curl, CURLOPT_WRITEDATA, &handles[i])
          != CURLE_OK ||
        curl_easy_setopt(handles[i].curl, CURLOPT_FOLLOWLOCATION, 1L)
          != CURLE_OK ||
        curl_easy_setopt(handles[i].curl, CURLOPT_VERBOSE, 1L) != CURLE_OK ||
        curl_easy_setopt(handles[i].curl, CURLOPT_DEBUGFUNCTION, cli_debug_cb)
          != CURLE_OK ||
        curl_easy_setopt(handles[i].curl, CURLOPT_SSL_VERIFYPEER, 0L)
          != CURLE_OK ||
        curl_easy_setopt(handles[i].curl, CURLOPT_RESOLVE, resolve)
          != CURLE_OK ||
        curl_easy_setopt(handles[i].curl, CURLOPT_PIPEWAIT, 1L) != CURLE_OK ||
        curl_easy_setopt(handles[i].curl, CURLOPT_URL, url) != CURLE_OK) {
        curl_mfprintf(stderr, "failed configuring easy handle - bailing out\n");
       result = (CURLcode)2;
       goto cleanup;
     }
     curl_easy_setopt(handles[i].curl, CURLOPT_HTTP_VERSION, http_version);
   }

   multi = curl_multi_init();
   if(!multi) {
     curl_mfprintf(stderr, "curl_multi_init() failed - bailing out\n");
     result = (CURLcode)2;
     goto cleanup;
   }

   for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
     if(curl_multi_add_handle(multi, handles[i].curl) != CURLM_OK) {
       curl_mfprintf(stderr, "curl_multi_add_handle() failed - bailing out\n");
       result = (CURLcode)2;
       goto cleanup;
     }
   }

   for(rounds = 0;; rounds++) {
     curl_mfprintf(stderr, "INFO: multi_perform round %d\n", rounds);
     if(curl_multi_perform(multi, &still_running) != CURLM_OK) {
       curl_mfprintf(stderr, "curl_multi_perform() failed - bailing out\n");
       result = (CURLcode)2;
       goto cleanup;
     }

     if(!still_running) {
       int as_expected = 1;
       curl_mfprintf(stderr, "INFO: no more handles running\n");
       for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
         if(!handles[i].paused) {
           curl_mfprintf(stderr, "ERROR: [%zu] NOT PAUSED\n", i);
           as_expected = 0;
         }
         else if(handles[i].paused != 1) {
           curl_mfprintf(stderr, "ERROR: [%zu] PAUSED %d times!\n",
                         i, handles[i].paused);
           as_expected = 0;
         }
         else if(!handles[i].resumed) {
           curl_mfprintf(stderr, "ERROR: [%zu] NOT resumed!\n", i);
           as_expected = 0;
         }
         else if(handles[i].errored != 1) {
           curl_mfprintf(stderr, "ERROR: [%zu] NOT errored once, %d instead!\n",
                         i, handles[i].errored);
           as_expected = 0;
         }
       }
       if(!as_expected) {
         curl_mfprintf(stderr, "ERROR: handles not in expected state "
                       "after %d rounds\n", rounds);
         result = (CURLcode)1;
       }
       break;
     }

     if(curl_multi_poll(multi, NULL, 0, 100, &numfds) != CURLM_OK) {
       curl_mfprintf(stderr, "curl_multi_poll() failed - bailing out\n");
       result = (CURLcode)2;
       goto cleanup;
     }

     /* !checksrc! disable EQUALSNULL 1 */
     while((msg = curl_multi_info_read(multi, &msgs_left)) != NULL) {
       if(msg->msg == CURLMSG_DONE) {
         for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
           if(msg->easy_handle == handles[i].curl) {
             if(handles[i].paused != 1 || !handles[i].resumed) {
               curl_mfprintf(stderr, "ERROR: [%zu] done, paused=%d, "
                             "resumed=%d, result %d - wtf?\n", i,
                             handles[i].paused,
                             handles[i].resumed, msg->data.result);
               result = (CURLcode)1;
               goto cleanup;
             }
           }
         }
       }
     }

     /* Successfully paused? */
     if(!all_paused) {
       for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
         if(!handles[i].paused) {
           break;
         }
       }
       all_paused = (i == CURL_ARRAYSIZE(handles));
       if(all_paused) {
         curl_mfprintf(stderr, "INFO: all transfers paused\n");
         /* give transfer some rounds to mess things up */
         resume_round = rounds + 2;
       }
     }
     if(resume_round > 0 && rounds == resume_round) {
       /* time to resume */
       for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
         curl_mfprintf(stderr, "INFO: [%zu] resumed\n", i);
         handles[i].resumed = 1;
         curl_easy_pause(handles[i].curl, CURLPAUSE_CONT);
       }
     }
   }

 cleanup:

   for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
     curl_multi_remove_handle(multi, handles[i].curl);
     curl_easy_cleanup(handles[i].curl);
   }

   curl_slist_free_all(resolve);
   curl_free(host);
   curl_free(port);
   curl_url_cleanup(cu);
   curl_multi_cleanup(multi);
   curl_global_cleanup();

   return result;
 }
	/***************************************************************************
	* _ _ ____ _
	* Project ___\| \| \| \| _ \\| \|
	* / __\| \| \| \| \|_) \| \|
	* \| (__\| \|_\| \| _ <\| \|___
	* \___\|\___/\|_\| \_\_____\|
	*
	* Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
	*
	* This software is licensed as described in the file COPYING, which
	* you should have received as part of this distribution. The terms
	* are also available at https://curl.se/docs/copyright.html.
	*
	* You may opt to use, copy, modify, merge, publish, distribute and/or sell
	* copies of the Software, and permit persons to whom the Software is
	* furnished to do so, under the terms of the COPYING file.
	*
	* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
	* KIND, either express or implied.
	*
	* SPDX-License-Identifier: curl
	*
	***************************************************************************/
	/* This is based on the PoC client of issue #11982
	*/
	#include "first.h"

	#include "testtrace.h"

	static void usage_h2_pausing(const char *msg)
	{
	if(msg)
	curl_mfprintf(stderr, "%s\n", msg);
	curl_mfprintf(stderr,
	"usage: [options] url\n"
	" pause downloads with following options:\n"
	" -V http_version (http/1.1, h2, h3) http version to use\n"
	);
	}

	struct handle {
	size_t idx;
	int paused;
	int resumed;
	int errored;
	int fail_write;
	CURL *curl;
	};

	static size_t cb(char data, size_t size, size_t nmemb, void clientp)
	{
	size_t realsize = size * nmemb;
	struct handle handle = (struct handle )clientp;
	curl_off_t totalsize;

	(void)data;
	if(curl_easy_getinfo(handle->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T,
	&totalsize) == CURLE_OK)
	curl_mfprintf(stderr, "INFO: [%zu] write, "
	"Content-Length %" CURL_FORMAT_CURL_OFF_T "\n",
	handle->idx, totalsize);

	if(!handle->resumed) {
	++handle->paused;
	curl_mfprintf(stderr, "INFO: [%zu] write, PAUSING %d time on %zu bytes\n",
	handle->idx, handle->paused, realsize);
	assert(handle->paused == 1);
	return CURL_WRITEFUNC_PAUSE;
	}
	if(handle->fail_write) {
	++handle->errored;
	curl_mfprintf(stderr, "INFO: [%zu] FAIL write of %zu bytes, %d time\n",
	handle->idx, realsize, handle->errored);
	return CURL_WRITEFUNC_ERROR;
	}
	curl_mfprintf(stderr, "INFO: [%zu] write, accepting %zu bytes\n",
	handle->idx, realsize);
	return realsize;
	}

	static CURLcode test_cli_h2_pausing(const char *URL)
	{
	struct handle handles[2];
	CURLM *multi = NULL;
	int still_running = 1, msgs_left, numfds;
	size_t i;
	CURLMsg *msg;
	int rounds = 0;
	CURLcode result = CURLE_OK;
	CURLU *cu;
	struct curl_slist *resolve = NULL;
	char resolve_buf[1024];
	const char *url;
	char host = NULL, port = NULL;
	int all_paused = 0;
	int resume_round = -1;
	long http_version = CURL_HTTP_VERSION_2_0;
	int ch;

	(void)URL;

	while((ch = cgetopt(test_argc, test_argv, "hV:")) != -1) {
	switch(ch) {
	case 'h':
	usage_h2_pausing(NULL);
	return (CURLcode)2;
	case 'V': {
	if(!strcmp("http/1.1", coptarg))
	http_version = CURL_HTTP_VERSION_1_1;
	else if(!strcmp("h2", coptarg))
	http_version = CURL_HTTP_VERSION_2_0;
	else if(!strcmp("h3", coptarg))
	http_version = CURL_HTTP_VERSION_3ONLY;
	else {
	usage_h2_pausing("invalid http version");
	return (CURLcode)1;
	}
	break;
	}
	default:
	usage_h2_pausing("invalid option");
	return (CURLcode)1;
	}
	}
	test_argc -= coptind;
	test_argv += coptind;

	if(test_argc != 1) {
	curl_mfprintf(stderr, "ERROR: need URL as argument\n");
	return (CURLcode)2;
	}
	url = test_argv[0];

	if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
	curl_mfprintf(stderr, "curl_global_init() failed\n");
	return (CURLcode)3;
	}

	curl_global_trace("ids,time,http/2,http/3");

	memset(handles, 0, sizeof(handles));

	cu = curl_url();
	if(!cu) {
	curl_mfprintf(stderr, "out of memory\n");
	result = (CURLcode)1;
	goto cleanup;
	}
	if(curl_url_set(cu, CURLUPART_URL, url, 0)) {
	curl_mfprintf(stderr, "not a URL: '%s'\n", url);
	result = (CURLcode)1;
	goto cleanup;
	}
	if(curl_url_get(cu, CURLUPART_HOST, &host, 0)) {
	curl_mfprintf(stderr, "could not get host of '%s'\n", url);
	result = (CURLcode)1;
	goto cleanup;
	}
	if(curl_url_get(cu, CURLUPART_PORT, &port, 0)) {
	curl_mfprintf(stderr, "could not get port of '%s'\n", url);
	result = (CURLcode)1;
	goto cleanup;
	}
	memset(&resolve, 0, sizeof(resolve));
	curl_msnprintf(resolve_buf, sizeof(resolve_buf) - 1, "%s:%s:127.0.0.1",
	host, port);
	resolve = curl_slist_append(resolve, resolve_buf);

	for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
	handles[i].idx = i;
	handles[i].paused = 0;
	handles[i].resumed = 0;
	handles[i].errored = 0;
	handles[i].fail_write = 1;
	handles[i].curl = curl_easy_init();
	if(!handles[i].curl \|\|
	curl_easy_setopt(handles[i].curl, CURLOPT_WRITEFUNCTION, cb)
	!= CURLE_OK \|\|
	curl_easy_setopt(handles[i].curl, CURLOPT_WRITEDATA, &handles[i])
	!= CURLE_OK \|\|
	curl_easy_setopt(handles[i].curl, CURLOPT_FOLLOWLOCATION, 1L)
	!= CURLE_OK \|\|
	curl_easy_setopt(handles[i].curl, CURLOPT_VERBOSE, 1L) != CURLE_OK \|\|
	curl_easy_setopt(handles[i].curl, CURLOPT_DEBUGFUNCTION, cli_debug_cb)
	!= CURLE_OK \|\|
	curl_easy_setopt(handles[i].curl, CURLOPT_SSL_VERIFYPEER, 0L)
	!= CURLE_OK \|\|
	curl_easy_setopt(handles[i].curl, CURLOPT_RESOLVE, resolve)
	!= CURLE_OK \|\|
	curl_easy_setopt(handles[i].curl, CURLOPT_PIPEWAIT, 1L) != CURLE_OK \|\|
	curl_easy_setopt(handles[i].curl, CURLOPT_URL, url) != CURLE_OK) {
	curl_mfprintf(stderr, "failed configuring easy handle - bailing out\n");
	result = (CURLcode)2;
	goto cleanup;
	}
	curl_easy_setopt(handles[i].curl, CURLOPT_HTTP_VERSION, http_version);
	}

	multi = curl_multi_init();
	if(!multi) {
	curl_mfprintf(stderr, "curl_multi_init() failed - bailing out\n");
	result = (CURLcode)2;
	goto cleanup;
	}

	for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
	if(curl_multi_add_handle(multi, handles[i].curl) != CURLM_OK) {
	curl_mfprintf(stderr, "curl_multi_add_handle() failed - bailing out\n");
	result = (CURLcode)2;
	goto cleanup;
	}
	}

	for(rounds = 0;; rounds++) {
	curl_mfprintf(stderr, "INFO: multi_perform round %d\n", rounds);
	if(curl_multi_perform(multi, &still_running) != CURLM_OK) {
	curl_mfprintf(stderr, "curl_multi_perform() failed - bailing out\n");
	result = (CURLcode)2;
	goto cleanup;
	}

	if(!still_running) {
	int as_expected = 1;
	curl_mfprintf(stderr, "INFO: no more handles running\n");
	for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
	if(!handles[i].paused) {
	curl_mfprintf(stderr, "ERROR: [%zu] NOT PAUSED\n", i);
	as_expected = 0;
	}
	else if(handles[i].paused != 1) {
	curl_mfprintf(stderr, "ERROR: [%zu] PAUSED %d times!\n",
	i, handles[i].paused);
	as_expected = 0;
	}
	else if(!handles[i].resumed) {
	curl_mfprintf(stderr, "ERROR: [%zu] NOT resumed!\n", i);
	as_expected = 0;
	}
	else if(handles[i].errored != 1) {
	curl_mfprintf(stderr, "ERROR: [%zu] NOT errored once, %d instead!\n",
	i, handles[i].errored);
	as_expected = 0;
	}
	}
	if(!as_expected) {
	curl_mfprintf(stderr, "ERROR: handles not in expected state "
	"after %d rounds\n", rounds);
	result = (CURLcode)1;
	}
	break;
	}

	if(curl_multi_poll(multi, NULL, 0, 100, &numfds) != CURLM_OK) {
	curl_mfprintf(stderr, "curl_multi_poll() failed - bailing out\n");
	result = (CURLcode)2;
	goto cleanup;
	}

	/* !checksrc! disable EQUALSNULL 1 */
	while((msg = curl_multi_info_read(multi, &msgs_left)) != NULL) {
	if(msg->msg == CURLMSG_DONE) {
	for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
	if(msg->easy_handle == handles[i].curl) {
	if(handles[i].paused != 1 \|\| !handles[i].resumed) {
	curl_mfprintf(stderr, "ERROR: [%zu] done, paused=%d, "
	"resumed=%d, result %d - wtf?\n", i,
	handles[i].paused,
	handles[i].resumed, msg->data.result);
	result = (CURLcode)1;
	goto cleanup;
	}
	}
	}
	}
	}

	/* Successfully paused? */
	if(!all_paused) {
	for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
	if(!handles[i].paused) {
	break;
	}
	}
	all_paused = (i == CURL_ARRAYSIZE(handles));
	if(all_paused) {
	curl_mfprintf(stderr, "INFO: all transfers paused\n");
	/* give transfer some rounds to mess things up */
	resume_round = rounds + 2;
	}
	}
	if(resume_round > 0 && rounds == resume_round) {
	/* time to resume */
	for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
	curl_mfprintf(stderr, "INFO: [%zu] resumed\n", i);
	handles[i].resumed = 1;
	curl_easy_pause(handles[i].curl, CURLPAUSE_CONT);
	}
	}
	}

	cleanup:

	for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
	curl_multi_remove_handle(multi, handles[i].curl);
	curl_easy_cleanup(handles[i].curl);
	}

	curl_slist_free_all(resolve);
	curl_free(host);
	curl_free(port);
	curl_url_cleanup(cu);
	curl_multi_cleanup(multi);
	curl_global_cleanup();

	return result;
	}