quickjs-tart

quickjs-based runtime for wallet-core logic
Log | Files | Refs | README | LICENSE

lib1592.c (4737B)

      1 /***************************************************************************
      2  *                                  _   _ ____  _
      3  *  Project                     ___| | | |  _ \| |
      4  *                             / __| | | | |_) | |
      5  *                            | (__| |_| |  _ <| |___
      6  *                             \___|\___/|_| \_\_____|
      7  *
      8  * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
      9  *
     10  * This software is licensed as described in the file COPYING, which
     11  * you should have received as part of this distribution. The terms
     12  * are also available at https://curl.se/docs/copyright.html.
     13  *
     14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
     15  * copies of the Software, and permit persons to whom the Software is
     16  * furnished to do so, under the terms of the COPYING file.
     17  *
     18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
     19  * KIND, either express or implied.
     20  *
     21  * SPDX-License-Identifier: curl
     22  *
     23  ***************************************************************************/
     24 /*
     25  * See https://github.com/curl/curl/issues/3371
     26  *
     27  * This test case checks whether curl_multi_remove_handle() cancels
     28  * asynchronous DNS resolvers without blocking where possible.  Obviously, it
     29  * only tests whichever resolver cURL is actually built with.
     30  */
     31 
     32 /* We're willing to wait a very generous two seconds for the removal.  This is
     33    as low as we can go while still easily supporting SIGALRM timing for the
     34    non-threaded blocking resolver.  It doesn't matter that much because when
     35    the test passes, we never wait this long. We set it much higher via
     36    the default TEST_HANG_TIMEOUT to avoid issues when running on overloaded
     37    CI machines. */
     38 
     39 #include "first.h"
     40 
     41 static CURLcode test_lib1592(char *URL)
     42 {
     43   int stillRunning;
     44   CURLM *multiHandle = NULL;
     45   CURL *curl = NULL;
     46   CURLcode res = CURLE_OK;
     47   CURLMcode mres;
     48   long timeout;
     49 
     50   global_init(CURL_GLOBAL_ALL);
     51 
     52   multi_init(multiHandle);
     53 
     54   easy_init(curl);
     55 
     56   easy_setopt(curl, CURLOPT_VERBOSE, 1L);
     57   easy_setopt(curl, CURLOPT_URL, URL);
     58 
     59   /* Set a DNS server that hopefully will not respond when using c-ares. */
     60   if(curl_easy_setopt(curl, CURLOPT_DNS_SERVERS, "0.0.0.0") == CURLE_OK)
     61     /* Since we could set the DNS server, presume we are working with a
     62        resolver that can be cancelled (i.e. c-ares).  Thus,
     63        curl_multi_remove_handle() should not block even when the resolver
     64        request is outstanding.  So, set a request timeout _longer_ than the
     65        test hang timeout so we will fail if the handle removal call incorrectly
     66        blocks. */
     67     timeout = TEST_HANG_TIMEOUT * 2;
     68   else {
     69     /* If we can't set the DNS server, presume that we are configured to use a
     70        resolver that can't be cancelled (i.e. the threaded resolver or the
     71        non-threaded blocking resolver).  So, we just test that the
     72        curl_multi_remove_handle() call does finish well within our test
     73        timeout.
     74 
     75        But, it is very unlikely that the resolver request will take any time at
     76        all because we haven't been able to configure the resolver to use an
     77        non-responsive DNS server.  At least we exercise the flow.
     78        */
     79     curl_mfprintf(stderr,
     80                   "CURLOPT_DNS_SERVERS not supported; "
     81                   "assuming curl_multi_remove_handle() will block\n");
     82     timeout = TEST_HANG_TIMEOUT / 2;
     83   }
     84 
     85   /* Setting a timeout on the request should ensure that even if we have to
     86      wait for the resolver during curl_multi_remove_handle(), it won't take
     87      longer than this, because the resolver request inherits its timeout from
     88      this. */
     89   easy_setopt(curl, CURLOPT_TIMEOUT_MS, timeout);
     90 
     91   multi_add_handle(multiHandle, curl);
     92 
     93   /* This should move the handle from INIT => CONNECT => WAITRESOLVE. */
     94   curl_mfprintf(stderr, "curl_multi_perform()...\n");
     95   multi_perform(multiHandle, &stillRunning);
     96   curl_mfprintf(stderr, "curl_multi_perform() succeeded\n");
     97 
     98   /* Start measuring how long it takes to remove the handle. */
     99   curl_mfprintf(stderr, "curl_multi_remove_handle()...\n");
    100   start_test_timing();
    101   mres = curl_multi_remove_handle(multiHandle, curl);
    102   if(mres) {
    103     curl_mfprintf(stderr,
    104                   "curl_multi_remove_handle() failed, with code %d\n", mres);
    105     res = TEST_ERR_MULTI;
    106     goto test_cleanup;
    107   }
    108   curl_mfprintf(stderr, "curl_multi_remove_handle() succeeded\n");
    109 
    110   /* Fail the test if it took too long to remove.  This happens after the fact,
    111      and says "it seems that it would have run forever", which isn't true, but
    112      it's close enough, and simple to do. */
    113   abort_on_test_timeout();
    114 
    115 test_cleanup:
    116   curl_easy_cleanup(curl);
    117   curl_multi_cleanup(multiHandle);
    118   curl_global_cleanup();
    119 
    120   return res;
    121 }