curl-w32/tests/http/clients/h2-pausing.c

340 lines
9.4 KiB
C
Raw Normal View History

/***************************************************************************
* _ _ ____ _
* 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
*
***************************************************************************/
/* <DESC>
* HTTP/2 download pausing
* </DESC>
*/
/* This is based on the poc client of issue #11982
*/
#include <stdio.h>
#include <string.h>
#include <sys/time.h>
#include <unistd.h>
#include <stdlib.h>
#include <curl/curl.h>
#include <curl/mprintf.h>
#define HANDLECOUNT 2
static void log_line_start(FILE *log, const char *idsbuf, curl_infotype type)
{
/*
* This is the trace look that is similar to what libcurl makes on its
* own.
*/
static const char * const s_infotype[] = {
"* ", "< ", "> ", "{ ", "} ", "{ ", "} "
};
if(idsbuf && *idsbuf)
fprintf(log, "%s%s", idsbuf, s_infotype[type]);
else
fputs(s_infotype[type], log);
}
#define TRC_IDS_FORMAT_IDS_1 "[%" CURL_FORMAT_CURL_OFF_T "-x] "
#define TRC_IDS_FORMAT_IDS_2 "[%" CURL_FORMAT_CURL_OFF_T "-%" \
CURL_FORMAT_CURL_OFF_T "] "
/*
** callback for CURLOPT_DEBUGFUNCTION
*/
static int debug_cb(CURL *handle, curl_infotype type,
char *data, size_t size,
void *userdata)
{
FILE *output = stderr;
static int newl = 0;
static int traced_data = 0;
char idsbuf[60];
curl_off_t xfer_id, conn_id;
(void)handle; /* not used */
(void)userdata;
if(!curl_easy_getinfo(handle, CURLINFO_XFER_ID, &xfer_id) && xfer_id >= 0) {
if(!curl_easy_getinfo(handle, CURLINFO_CONN_ID, &conn_id) &&
conn_id >= 0) {
curl_msnprintf(idsbuf, sizeof(idsbuf), TRC_IDS_FORMAT_IDS_2,
xfer_id, conn_id);
}
else {
curl_msnprintf(idsbuf, sizeof(idsbuf), TRC_IDS_FORMAT_IDS_1, xfer_id);
}
}
else
idsbuf[0] = 0;
switch(type) {
case CURLINFO_HEADER_OUT:
if(size > 0) {
size_t st = 0;
size_t i;
for(i = 0; i < size - 1; i++) {
if(data[i] == '\n') { /* LF */
if(!newl) {
log_line_start(output, idsbuf, type);
}
(void)fwrite(data + st, i - st + 1, 1, output);
st = i + 1;
newl = 0;
}
}
if(!newl)
log_line_start(output, idsbuf, type);
(void)fwrite(data + st, i - st + 1, 1, output);
}
newl = (size && (data[size - 1] != '\n')) ? 1 : 0;
traced_data = 0;
break;
case CURLINFO_TEXT:
case CURLINFO_HEADER_IN:
if(!newl)
log_line_start(output, idsbuf, type);
(void)fwrite(data, size, 1, output);
newl = (size && (data[size - 1] != '\n')) ? 1 : 0;
traced_data = 0;
break;
case CURLINFO_DATA_OUT:
case CURLINFO_DATA_IN:
case CURLINFO_SSL_DATA_IN:
case CURLINFO_SSL_DATA_OUT:
if(!traced_data) {
if(!newl)
log_line_start(output, idsbuf, type);
fprintf(output, "[%ld bytes data]\n", (long)size);
newl = 0;
traced_data = 1;
}
break;
default: /* nada */
newl = 0;
traced_data = 1;
break;
}
return 0;
}
static int err(void)
{
fprintf(stderr, "something unexpected went wrong - bailing out!\n");
exit(2);
}
struct handle
{
int idx;
int paused;
int resumed;
CURL *h;
};
static size_t cb(void *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->h, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T,
&totalsize) == CURLE_OK)
fprintf(stderr, "INFO: [%d] write, Content-Length %"CURL_FORMAT_CURL_OFF_T
"\n", handle->idx, totalsize);
if(!handle->resumed) {
++handle->paused;
fprintf(stderr, "INFO: [%d] write, PAUSING %d time on %lu bytes\n",
handle->idx, handle->paused, (long)realsize);
return CURL_WRITEFUNC_PAUSE;
}
fprintf(stderr, "INFO: [%d] write, accepting %lu bytes\n",
handle->idx, (long)realsize);
return realsize;
}
int main(int argc, char *argv[])
{
struct handle handles[HANDLECOUNT];
CURLM *multi_handle;
int i, still_running = 1, msgs_left, numfds;
CURLMsg *msg;
int rounds = 0;
int rc = 0;
CURLU *cu;
struct curl_slist *resolve = NULL;
char resolve_buf[1024];
char *url, *host = NULL, *port = NULL;
int all_paused = 0;
int resume_round = -1;
if(argc != 2) {
fprintf(stderr, "ERROR: need URL as argument\n");
return 2;
}
url = argv[1];
curl_global_init(CURL_GLOBAL_DEFAULT);
curl_global_trace("ids,time,http/2");
cu = curl_url();
if(!cu) {
fprintf(stderr, "out of memory\n");
exit(1);
}
if(curl_url_set(cu, CURLUPART_URL, url, 0)) {
fprintf(stderr, "not a URL: '%s'\n", url);
exit(1);
}
if(curl_url_get(cu, CURLUPART_HOST, &host, 0)) {
fprintf(stderr, "could not get host of '%s'\n", url);
exit(1);
}
if(curl_url_get(cu, CURLUPART_PORT, &port, 0)) {
fprintf(stderr, "could not get port of '%s'\n", url);
exit(1);
}
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<HANDLECOUNT; i++) {
handles[i].idx = i;
handles[i].paused = 0;
handles[i].resumed = 0;
handles[i].h = curl_easy_init();
if(!handles[i].h ||
curl_easy_setopt(handles[i].h, CURLOPT_WRITEFUNCTION, cb) != CURLE_OK ||
curl_easy_setopt(handles[i].h, CURLOPT_WRITEDATA, &handles[i])
!= CURLE_OK ||
curl_easy_setopt(handles[i].h, CURLOPT_FOLLOWLOCATION, 1L) != CURLE_OK ||
curl_easy_setopt(handles[i].h, CURLOPT_VERBOSE, 1L) != CURLE_OK ||
curl_easy_setopt(handles[i].h, CURLOPT_DEBUGFUNCTION, debug_cb)
!= CURLE_OK ||
curl_easy_setopt(handles[i].h, CURLOPT_SSL_VERIFYPEER, 0L) != CURLE_OK ||
curl_easy_setopt(handles[i].h, CURLOPT_RESOLVE, resolve) != CURLE_OK ||
curl_easy_setopt(handles[i].h, CURLOPT_URL, url) != CURLE_OK) {
err();
}
}
multi_handle = curl_multi_init();
if(!multi_handle)
err();
for(i = 0; i<HANDLECOUNT; i++) {
if(curl_multi_add_handle(multi_handle, handles[i].h) != CURLM_OK)
err();
}
for(rounds = 0;; rounds++) {
fprintf(stderr, "INFO: multi_perform round %d\n", rounds);
if(curl_multi_perform(multi_handle, &still_running) != CURLM_OK)
err();
if(!still_running) {
int as_expected = 1;
fprintf(stderr, "INFO: no more handles running\n");
for(i = 0; i<HANDLECOUNT; i++) {
if(!handles[i].paused) {
fprintf(stderr, "ERROR: [%d] NOT PAUSED\n", i);
as_expected = 0;
}
else if(handles[i].paused != 1) {
fprintf(stderr, "ERROR: [%d] PAUSED %d times!\n",
i, handles[i].paused);
as_expected = 0;
}
else if(!handles[i].resumed) {
fprintf(stderr, "ERROR: [%d] NOT resumed!\n", i);
as_expected = 0;
}
}
if(!as_expected) {
fprintf(stderr, "ERROR: handles not in expected state "
"after %d rounds\n", rounds);
rc = 1;
}
break;
}
if(curl_multi_poll(multi_handle, NULL, 0, 100, &numfds) != CURLM_OK)
err();
while((msg = curl_multi_info_read(multi_handle, &msgs_left))) {
if(msg->msg == CURLMSG_DONE) {
for(i = 0; i<HANDLECOUNT; i++) {
if(msg->easy_handle == handles[i].h) {
if(handles[i].paused != 1 || !handles[i].resumed) {
fprintf(stderr, "ERROR: [%d] done, pauses=%d, resumed=%d, "
"result %d - wtf?\n", i, handles[i].paused,
handles[i].resumed, msg->data.result);
rc = 1;
goto out;
}
}
}
}
}
/* Successfully paused? */
if(!all_paused) {
for(i = 0; i<HANDLECOUNT; i++) {
if(!handles[i].paused) {
break;
}
}
all_paused = (i == HANDLECOUNT);
if(all_paused) {
fprintf(stderr, "INFO: all transfers paused\n");
/* give transfer some rounds to mess things up */
resume_round = rounds + 3;
}
}
if(resume_round > 0 && rounds == resume_round) {
/* time to resume */
for(i = 0; i<HANDLECOUNT; i++) {
fprintf(stderr, "INFO: [%d] resumed\n", i);
handles[i].resumed = 1;
curl_easy_pause(handles[i].h, CURLPAUSE_CONT);
}
}
}
out:
for(i = 0; i<HANDLECOUNT; i++) {
curl_multi_remove_handle(multi_handle, handles[i].h);
curl_easy_cleanup(handles[i].h);
}
curl_slist_free_all(resolve);
curl_free(host);
curl_free(port);
curl_url_cleanup(cu);
curl_multi_cleanup(multi_handle);
curl_global_cleanup();
return rc;
}