| /*************************************************************************** |
| * _ _ ____ _ |
| * 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 <curl/curl.h> |
| |
| #include <assert.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <stdlib.h> |
| |
| #ifndef _MSC_VER |
| /* somewhat Unix-specific */ |
| #include <unistd.h> /* getopt() */ |
| #endif |
| |
| #ifndef _MSC_VER |
| #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); |
| } |
| |
| static void usage(const char *msg) |
| { |
| if(msg) |
| fprintf(stderr, "%s\n", msg); |
| fprintf(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 |
| { |
| int idx; |
| int paused; |
| int resumed; |
| int errored; |
| int fail_write; |
| CURL *h; |
| }; |
| |
| 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->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); |
| assert(handle->paused == 1); |
| return CURL_WRITEFUNC_PAUSE; |
| } |
| if(handle->fail_write) { |
| ++handle->errored; |
| fprintf(stderr, "INFO: [%d] FAIL write of %lu bytes, %d time\n", |
| handle->idx, (long)realsize, handle->errored); |
| return CURL_WRITEFUNC_ERROR; |
| } |
| fprintf(stderr, "INFO: [%d] write, accepting %lu bytes\n", |
| handle->idx, (long)realsize); |
| return realsize; |
| } |
| #endif /* !_MSC_VER */ |
| |
| int main(int argc, char *argv[]) |
| { |
| #ifndef _MSC_VER |
| 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; |
| int http_version = CURL_HTTP_VERSION_2_0; |
| int ch; |
| |
| while((ch = getopt(argc, argv, "hV:")) != -1) { |
| switch(ch) { |
| case 'h': |
| usage(NULL); |
| return 2; |
| case 'V': { |
| if(!strcmp("http/1.1", optarg)) |
| http_version = CURL_HTTP_VERSION_1_1; |
| else if(!strcmp("h2", optarg)) |
| http_version = CURL_HTTP_VERSION_2_0; |
| else if(!strcmp("h3", optarg)) |
| http_version = CURL_HTTP_VERSION_3ONLY; |
| else { |
| usage("invalid http version"); |
| return 1; |
| } |
| break; |
| } |
| default: |
| usage("invalid option"); |
| return 1; |
| } |
| } |
| argc -= optind; |
| argv += optind; |
| |
| if(argc != 1) { |
| fprintf(stderr, "ERROR: need URL as argument\n"); |
| return 2; |
| } |
| url = argv[0]; |
| |
| curl_global_init(CURL_GLOBAL_DEFAULT); |
| curl_global_trace("ids,time,http/2,http/3"); |
| |
| 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].errored = 0; |
| handles[i].fail_write = 1; |
| 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_PIPEWAIT, 1L) || |
| curl_easy_setopt(handles[i].h, CURLOPT_URL, url) != CURLE_OK) { |
| err(); |
| } |
| curl_easy_setopt(handles[i].h, CURLOPT_HTTP_VERSION, (long)http_version); |
| } |
| |
| 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; |
| } |
| else if(handles[i].errored != 1) { |
| fprintf(stderr, "ERROR: [%d] NOT errored once, %d instead!\n", |
| i, handles[i].errored); |
| 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(); |
| |
| /* !checksrc! disable EQUALSNULL 1 */ |
| while((msg = curl_multi_info_read(multi_handle, &msgs_left)) != NULL) { |
| 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 + 2; |
| } |
| } |
| 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; |
| #else |
| (void)argc; |
| (void)argv; |
| fprintf(stderr, "Not supported with this compiler.\n"); |
| return 1; |
| #endif /* !_MSC_VER */ |
| } |
