diff --git a/CHANGELOG.rst b/CHANGELOG.rst index e3431f286c..f5241dcfb7 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -18,6 +18,13 @@ v34.9.3 (2024-12-31) * Add SCANCODEIO_RQ_REDIS_SSL setting to enable SSL. https://github.com/aboutcode-org/scancode.io/issues/1465 +- Add support to map binaries to source files using symbols + for rust binaries and source files. This adds also using + ``rust-inspector`` to extract symbols from rust binaries. + This is a new optional ``Rust`` step in the + ``map_deploy_to_develop`` pipeline. + https://github.com/aboutcode-org/scancode.io/issues/1435 + v34.9.2 (2024-12-10) -------------------- diff --git a/docs/scanpipe-pipes.rst b/docs/scanpipe-pipes.rst index d5248d6408..3db7bc8a51 100644 --- a/docs/scanpipe-pipes.rst +++ b/docs/scanpipe-pipes.rst @@ -110,6 +110,11 @@ SPDX .. automodule:: scanpipe.pipes.spdx :members: +Symbolmap +--------- +.. automodule:: scanpipe.pipes.symbolmap + :members: + Symbols ------- .. automodule:: scanpipe.pipes.symbols diff --git a/scanpipe/pipelines/deploy_to_develop.py b/scanpipe/pipelines/deploy_to_develop.py index ea74f93e8e..f2a8d35719 100644 --- a/scanpipe/pipelines/deploy_to_develop.py +++ b/scanpipe/pipelines/deploy_to_develop.py @@ -25,6 +25,7 @@ from scanpipe.pipelines import Pipeline from scanpipe.pipes import d2d from scanpipe.pipes import flag +from scanpipe.pipes import input from scanpipe.pipes import matchcode from scanpipe.pipes import purldb from scanpipe.pipes import scancode @@ -72,6 +73,7 @@ def steps(cls): cls.map_javascript, cls.map_elf, cls.map_go, + cls.map_rust, cls.match_directories_to_purldb, cls.match_resources_to_purldb, cls.map_javascript_post_purldb_match, @@ -129,7 +131,10 @@ def extract_inputs_to_codebase_directory(self): for input_files, codebase_path in inputs_with_codebase_path_destination: for input_file_path in input_files: - self.extract_archive(input_file_path, codebase_path) + if input.is_archive(input_file_path): + self.extract_archive(input_file_path, codebase_path) + else: + input.copy_input(input_file_path, codebase_path) # Reload the project env post-extraction as the scancode-config.yml file # may be located in one of the extracted archives. @@ -198,9 +203,14 @@ def map_elf(self): @optional_step("Go") def map_go(self): - """Map Go binaries to their sources.""" + """Map Go binaries to their sources using paths.""" d2d.map_go_paths(project=self.project, logger=self.log) + @optional_step("Rust") + def map_rust(self): + """Map Rust binaries to their sources using symbols.""" + d2d.map_rust_paths(project=self.project, logger=self.log) + def match_directories_to_purldb(self): """Match selected directories in PurlDB.""" if not purldb.is_available(): diff --git a/scanpipe/pipes/d2d.py b/scanpipe/pipes/d2d.py index 7de904c3e6..5ad3913e78 100644 --- a/scanpipe/pipes/d2d.py +++ b/scanpipe/pipes/d2d.py @@ -42,6 +42,7 @@ from extractcode import EXTRACT_SUFFIX from go_inspector.plugin import collect_and_parse_symbols from packagedcode.npm import NpmPackageJsonHandler +from rust_inspector.binary import collect_and_parse_rust_symbols from summarycode.classify import LEGAL_STARTS_ENDS from aboutcode.pipeline import LoopProgress @@ -57,6 +58,8 @@ from scanpipe.pipes import purldb from scanpipe.pipes import resolve from scanpipe.pipes import scancode +from scanpipe.pipes import symbolmap +from scanpipe.pipes import symbols FROM = "from/" TO = "to/" @@ -1794,8 +1797,14 @@ def map_elfs(project, logger=None): try: paths = get_elf_file_dwarf_paths(resource.location_path) resource.update_extra_data(paths) - except Exception as e: - logger(f"Can not parse {resource.location_path!r} {e!r}") + except Exception as exception: + project.add_warning( + exception=exception, + object_instance=resource, + description=f"Cannot parse binary at {resource.path}", + model="map_elfs", + details={"path": resource.path}, + ) if logger: logger( @@ -1860,8 +1869,14 @@ def map_go_paths(project, logger=None): try: paths = get_go_file_paths(resource.location_path) resource.update_extra_data(paths) - except Exception as e: - logger(f"Can not parse {resource.location_path!r} {e!r}") + except Exception as exception: + project.add_warning( + exception=exception, + object_instance=resource, + description=f"Cannot parse binary at {resource.path}", + model="map_go_paths", + details={"path": resource.path}, + ) if logger: logger( @@ -1886,3 +1901,54 @@ def map_go_paths(project, logger=None): map_types=["go_file_paths"], logger=logger, ) + + +def map_rust_paths(project, logger=None): + """Map Rust binaries to their source in ``project``.""" + from_resources = project.codebaseresources.files().from_codebase() + to_resources = ( + project.codebaseresources.files() + .to_codebase() + .has_no_relation() + .executable_binaries() + ) + + # Collect source symbols from rust source files + rust_from_resources = from_resources.filter(extension=".rs") + symbols.collect_and_store_tree_sitter_symbols_and_strings( + project=project, + logger=logger, + project_files=rust_from_resources, + ) + + # Collect binary symbols from rust binaries + for resource in to_resources: + try: + binary_symbols = collect_and_parse_rust_symbols(resource.location_path) + resource.update_extra_data(binary_symbols) + except Exception as e: + logger(f"Can not parse {resource.location_path!r} {e!r}") + + if logger: + logger( + f"Mapping {to_resources.count():,d} to/ resources using symbols " + f"with {rust_from_resources.count():,d} from/ resources." + ) + + resource_iterator = to_resources.iterator(chunk_size=2000) + progress = LoopProgress(to_resources.count(), logger) + for to_resource in progress.iter(resource_iterator): + binary_symbols = to_resource.extra_data.get("rust_symbols") + if not binary_symbols: + continue + + if logger: + logger(f"Mapping source files to binary at {to_resource.path}") + + symbolmap.map_resources_with_symbols( + to_resource=to_resource, + from_resources=rust_from_resources, + binary_symbols=binary_symbols, + map_type="rust_symbols", + logger=logger, + ) diff --git a/scanpipe/pipes/flag.py b/scanpipe/pipes/flag.py index 555d18e9df..89a99ef85b 100644 --- a/scanpipe/pipes/flag.py +++ b/scanpipe/pipes/flag.py @@ -49,6 +49,7 @@ ABOUT_MAPPED = "about-mapped" MAPPED = "mapped" +MAPPED_BY_SYMBOL = "mapped-by-symbol" ARCHIVE_PROCESSED = "archive-processed" MATCHED_TO_PURLDB_PACKAGE = "matched-to-purldb-package" MATCHED_TO_PURLDB_RESOURCE = "matched-to-purldb-resource" diff --git a/scanpipe/pipes/input.py b/scanpipe/pipes/input.py index 0ca8c0cb20..44ca288b9d 100644 --- a/scanpipe/pipes/input.py +++ b/scanpipe/pipes/input.py @@ -19,6 +19,8 @@ # # ScanCode.io is a free software code scanning tool from nexB Inc. and others. # Visit https://github.com/aboutcode-org/scancode.io for support and download. + +import os import shutil from pathlib import Path @@ -41,11 +43,14 @@ def copy_input(input_location, dest_path): """Copy the ``input_location`` (file or directory) to the ``dest_path``.""" input_path = Path(input_location) - destination = Path(dest_path) / input_path.name + destination_dir = Path(dest_path) + destination = destination_dir / input_path.name if input_path.is_dir(): shutil.copytree(input_location, destination) else: + if not os.path.exists(destination_dir): + os.makedirs(destination_dir) shutil.copyfile(input_location, destination) return destination diff --git a/scanpipe/pipes/matchcode.py b/scanpipe/pipes/matchcode.py index 668f61df4b..61b724a028 100644 --- a/scanpipe/pipes/matchcode.py +++ b/scanpipe/pipes/matchcode.py @@ -188,6 +188,10 @@ def fingerprint_codebase_directories(project, to_codebase_only=False): resources = project.codebaseresources.all() if to_codebase_only: resources = resources.to_codebase() + + if not resources.directories(): + return + virtual_codebase = codebase.get_basic_virtual_codebase(resources) virtual_codebase = compute_codebase_directory_fingerprints(virtual_codebase) save_directory_fingerprints( diff --git a/scanpipe/pipes/symbolmap.py b/scanpipe/pipes/symbolmap.py new file mode 100644 index 0000000000..346a698f18 --- /dev/null +++ b/scanpipe/pipes/symbolmap.py @@ -0,0 +1,164 @@ +# SPDX-License-Identifier: Apache-2.0 +# +# http://nexb.com and https://github.com/aboutcode-org/scancode.io +# The ScanCode.io software is licensed under the Apache License version 2.0. +# Data generated with ScanCode.io is provided as-is without warranties. +# ScanCode is a trademark of nexB Inc. +# +# You may not use this software except in compliance with the License. +# You may obtain a copy of the License at: http://apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software distributed +# under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +# CONDITIONS OF ANY KIND, either express or implied. See the License for the +# specific language governing permissions and limitations under the License. +# +# Data Generated with ScanCode.io is provided on an "AS IS" BASIS, WITHOUT WARRANTIES +# OR CONDITIONS OF ANY KIND, either express or implied. No content created from +# ScanCode.io should be considered or used as legal advice. Consult an Attorney +# for any legal advice. +# +# ScanCode.io is a free software code scanning tool from nexB Inc. and others. +# Visit https://github.com/aboutcode-org/scancode.io for support and download. + +from collections import Counter + +from aboutcode.pipeline import LoopProgress +from scanpipe.models import CodebaseRelation +from scanpipe.pipes import flag + +""" +Path matching using source and binary symbols. + +The approach is to create a set of symbols obtained from the rust binary for +each of them and match them to the symbols obtained from the source +""" + +MATCHING_RATIO_RUST = 0.5 +SMALL_FILE_SYMBOLS_THRESHOLD = 20 +MATCHING_RATIO_RUST_SMALL_FILE = 0.4 + + +def map_resources_with_symbols( + to_resource, from_resources, binary_symbols, map_type, logger=None +): + """ + Map paths found in the ``to_resource`` extra_data to paths of the ``from_resources`` + CodebaseResource queryset using the precomputed ``from_resources_index`` path index. + """ + if not binary_symbols: + return + + # Accumulate unique relation objects for bulk creation + relations_to_create = {} + + # These are of type string + paths_not_mapped = to_resource.extra_data[f"{map_type}_not_mapped"] = [] + for item in match_source_paths_to_binary( + to_resource=to_resource, + from_resources=from_resources, + binary_symbols=binary_symbols, + map_type=map_type, + logger=logger, + ): + if isinstance(item, str): + paths_not_mapped.append(item) + else: + rel_key, relation = item + if rel_key not in relations_to_create: + relations_to_create[rel_key] = relation + + # If there are any non-test files in the rust source files which + # are not mapped, we mark the binary as REQUIRES_REVIEW + has_non_test_unmapped_files = any( + [True for path in paths_not_mapped if "/tests/" not in path] + ) + if paths_not_mapped and has_non_test_unmapped_files: + to_resource.update(status=flag.REQUIRES_REVIEW) + if logger: + logger( + f"WARNING: #{len(paths_not_mapped)} {map_type} paths NOT mapped for: " + f"{to_resource.path!r}" + ) + + if relations_to_create: + rels = CodebaseRelation.objects.bulk_create(relations_to_create.values()) + from_resources.has_relation().update(status=flag.MAPPED_BY_SYMBOL) + if logger: + logger( + f"Created {len(rels)} mappings using " + f"{map_type} for: {to_resource.path!r}" + ) + + elif logger: + logger(f"No mappings using {map_type} for: " f"{to_resource.path!r}") + + +def match_source_symbols_to_binary(source_symbols, binary_symbols): + binary_symbols_set = set(binary_symbols) + source_symbols_set = set(source_symbols) + source_symbols_count = len(source_symbols) + source_symbols_unique_count = len(source_symbols_set) + + source_symbols_counter = Counter(source_symbols) + + common_symbols = source_symbols_set.intersection(binary_symbols_set) + common_symbols_count = sum( + [source_symbols_counter.get(symbol) for symbol in common_symbols] + ) + common_symbols_ratio = common_symbols_count / source_symbols_count + common_symbols_unique_count = len(common_symbols) + common_symbols_unique_ratio = ( + common_symbols_unique_count / source_symbols_unique_count + ) + stats = { + "common_symbols_unique_ratio": common_symbols_unique_ratio, + "common_symbols_ratio": common_symbols_ratio, + } + + if ( + common_symbols_ratio > MATCHING_RATIO_RUST + or common_symbols_unique_ratio > MATCHING_RATIO_RUST + ): + return True, stats + elif source_symbols_count > SMALL_FILE_SYMBOLS_THRESHOLD and ( + common_symbols_ratio > MATCHING_RATIO_RUST_SMALL_FILE + or common_symbols_unique_ratio > MATCHING_RATIO_RUST_SMALL_FILE + ): + return True, stats + else: + return False, stats + + +def match_source_paths_to_binary( + to_resource, + from_resources, + binary_symbols, + map_type, + logger=None, +): + resource_iterator = from_resources.iterator(chunk_size=2000) + progress = LoopProgress(from_resources.count(), logger) + + for resource in progress.iter(resource_iterator): + source_symbols = resource.extra_data.get("source_symbols") + if not source_symbols: + yield resource.path + continue + + is_source_matched, match_stats = match_source_symbols_to_binary( + source_symbols=source_symbols, + binary_symbols=binary_symbols, + ) + if not is_source_matched: + yield resource.path + continue + + rel_key = (resource.path, to_resource.path, map_type) + relation = CodebaseRelation( + project=resource.project, + from_resource=resource, + to_resource=to_resource, + map_type=map_type, + extra_data=match_stats, + ) + yield rel_key, relation diff --git a/scanpipe/pipes/symbols.py b/scanpipe/pipes/symbols.py index f27f3cb53f..515e848df1 100644 --- a/scanpipe/pipes/symbols.py +++ b/scanpipe/pipes/symbols.py @@ -110,14 +110,19 @@ def _collect_and_store_pygments_symbols_and_strings(resource): ) -def collect_and_store_tree_sitter_symbols_and_strings(project, logger=None): +def collect_and_store_tree_sitter_symbols_and_strings( + project, logger=None, project_files=None +): """ Collect symbols from codebase files using tree-sitter and store them in the extra data field. + + Collect from `project_files` instead of all codebase files if specified. """ from source_inspector import symbols_tree_sitter - project_files = project.codebaseresources.files() + if not project_files: + project_files = project.codebaseresources.files() language_qs = Q() @@ -131,6 +136,11 @@ def collect_and_store_tree_sitter_symbols_and_strings(project, logger=None): ).filter(language_qs) resources_count = resources.count() + if logger: + logger( + f"Getting source symbols and strings from {resources_count:,d}" + " from/ resources using tree-sitter." + ) resource_iterator = resources.iterator(chunk_size=2000) progress = LoopProgress(resources_count, logger) diff --git a/scanpipe/tests/data/d2d-rust/from-trustier-source.tar.gz b/scanpipe/tests/data/d2d-rust/from-trustier-source.tar.gz new file mode 100644 index 0000000000..6f4ee19a28 Binary files /dev/null and b/scanpipe/tests/data/d2d-rust/from-trustier-source.tar.gz differ diff --git a/scanpipe/tests/data/d2d-rust/to-trustier-binary-linux.tar.gz b/scanpipe/tests/data/d2d-rust/to-trustier-binary-linux.tar.gz new file mode 100644 index 0000000000..db7a74108b Binary files /dev/null and b/scanpipe/tests/data/d2d-rust/to-trustier-binary-linux.tar.gz differ diff --git a/scanpipe/tests/data/d2d-rust/trustier-binary-symbols.json b/scanpipe/tests/data/d2d-rust/trustier-binary-symbols.json new file mode 100644 index 0000000000..d983336592 --- /dev/null +++ b/scanpipe/tests/data/d2d-rust/trustier-binary-symbols.json @@ -0,0 +1,4739 @@ +{ + "source": "Run rust-inspector to get binary symbols", + "binary-link": "https://github.com/devops-kung-fu/trustier/releases/download/v0.1.0/trustier-x86_64-unknown-linux-gnu.tar.gz", + "rust_symbols": [ + "Abbreviation", + "Abbreviations", + "AbbreviationsCache", + "AcAutomaton", + "AccessError", + "AccessMode", + "AcquireSlow", + "ActiveStates", + "Adapter", + "Add", + "Adler32", + "Advisories", + "Advisory", + "AgentBuilder", + "AgentContext", + "AggregateType", + "AhoCorasick", + "AhoCorasickBuilder", + "Algorithm", + "Alignment", + "Alternation", + "Annotation", + "Annotations", + "Annotator", + "Any", + "Any$u2b$core", + "Any+core", + "AnyValue", + "AnyValueId", + "AnyValueParser", + "ApproximateByteSet", + "ArangeHeader", + "Arc", + "ArcInner", + "Arg", + "ArgGroup", + "ArgMatcher", + "ArgMatches", + "Args", + "ArgsOs", + "Arguments", + "Array", + "AsRef", + "Ast", + "AsyncBufRead", + "AsyncRead", + "AsyncSignal", + "AsyncWrite", + "AtomicBool", + "AttachedText", + "Attachment", + "Attribute", + "AttributeValue", + "Attributes", + "Authority", + "AutoHelp", + "AutoStream", + "AutomaticDecompression", + "Automaton", + "BIG5_ASTRALNESS", + "BIG5_INIT", + "BIG5_LOW_BITS", + "BTreeMap", + "Backtrace", + "BacktraceFrame", + "BacktraceFrameFmt", + "BacktraceLock", + "BacktraceSymbol", + "BalancingContext", + "Big32x40", + "Big5Decoder", + "BlockOnWaker", + "Blocking", + "Body", + "Bom", + "BomError", + "BomFormat", + "BomReference", + "BomReferencesContext", + "Bomb", + "BoolValueParser", + "BoolVisitor", + "Borrow", + "BorrowError", + "BorrowMutError", + "BorrowedFd", + "Bound", + "Bounded", + "BoundedBacktracker", + "BoundedBacktrackerCache", + "Box", + "Bucket", + "Buf", + "BufGuard", + "BufMut", + "BufReader", + "BufWriter", + "BuildError", + "BuildHasher", + "Builder", + "Byte", + "ByteClassSet", + "ByteClasses", + "ByteSet", + "Bytes", + "BytesMut", + "CACHED_POW10", + "CP949_LEFT_HANGUL_OFFSETS", + "CP949_LEFT_HANGUL_POINTERS", + "CP949_TOP_HANGUL_OFFSETS", + "CP949_TOP_HANGUL_POINTERS", + "CSWTCH.102", + "CSWTCH.176", + "CSWTCH.272", + "CSWTCH.273", + "CSWTCH.294", + "CSWTCH.50", + "CStr", + "CString", + "Cache", + "Cache$u2b$core", + "CacheError", + "CacheLine", + "Callsite", + "Callstack", + "CanonicalCombiningClassMap", + "Capture", + "CaptureName", + "Captures", + "CartableOptionPointer", + "CaseFoldError", + "Cell", + "Chain", + "Chan", + "Channel", + "Char16TrieIterator", + "CharSearcher", + "CharacterAndClass", + "Chars", + "Checksum", + "ChildGraph", + "Choice", + "Class", + "ClassAsciiKind", + "ClassBracketed", + "ClassBytes", + "ClassBytesIter", + "ClassBytesRange", + "ClassQuery", + "ClassSet", + "ClassSetBinaryOp", + "ClassSetItem", + "ClassSetUnion", + "ClassState", + "ClassUnicode", + "ClassUnicodeIter", + "ClassUnicodeKind", + "ClassUnicodeRange", + "Classification", + "Client", + "ClientCertificate", + "Clone", + "Cloned", + "CodePointMapDataBorrowed", + "CodePointTrie", + "Collection", + "CollectionAllocErr", + "Color", + "ColorChoice", + "ColoredString", + "Colorize", + "Colorizer", + "Command", + "CommandFactory", + "Commit", + "Commits", + "Compiler", + "Component", + "ComponentData", + "ComponentDataType", + "ComponentEvidence", + "Components", + "ComposingNormalizer", + "Composition", + "Compositions", + "Compound", + "Concat", + "ConcurrentQueue", + "Condition", + "Condvar", + "ConfidenceInterval", + "Config", + "Conflicts", + "Connection", + "Considerations", + "Content", + "ContentDeserializer", + "ContentRefDeserializer", + "ContentVisitor", + "Context", + "ContextKind", + "ContextValue", + "ConvertVec", + "Copied", + "Copyright", + "CopyrightTexts", + "Core", + "Cow", + "CowBytes", + "CowStrVisitor", + "Credentials", + "Curl_HMAC_SHA256", + "Curl_HMAC_init", + "Curl_add_custom_headers", + "Curl_addr2string", + "Curl_addrinfo_callback", + "Curl_all_content_encodings", + "Curl_alpn_set_negotiated", + "Curl_alpn_to_proto_buf", + "Curl_alpn_to_proto_str", + "Curl_alpnid2str", + "Curl_altsvc_cleanup", + "Curl_altsvc_ctrl", + "Curl_altsvc_init", + "Curl_altsvc_load", + "Curl_altsvc_lookup", + "Curl_altsvc_parse", + "Curl_altsvc_save", + "Curl_attach_connection", + "Curl_auth_allowed_to_host", + "Curl_auth_create_digest_http_message", + "Curl_auth_decode_digest_http_message", + "Curl_auth_digest_cleanup", + "Curl_auth_digest_get_pair", + "Curl_auth_is_digest_supported", + "Curl_base64_decode", + "Curl_base64_encode", + "Curl_base64url_encode", + "Curl_bufcp_free", + "Curl_bufcp_init", + "Curl_bufq_cread", + "Curl_bufq_cwrite", + "Curl_bufq_free", + "Curl_bufq_init", + "Curl_bufq_init2", + "Curl_bufq_initp", + "Curl_bufq_is_empty", + "Curl_bufq_is_full", + "Curl_bufq_len", + "Curl_bufq_pass", + "Curl_bufq_peek", + "Curl_bufq_read", + "Curl_bufq_reset", + "Curl_bufq_sipn", + "Curl_bufq_skip", + "Curl_bufq_slurp", + "Curl_bufq_space", + "Curl_bufq_unwrite", + "Curl_bufq_write", + "Curl_bufq_write_pass", + "Curl_build_unencoding_stack", + "Curl_bump_headersize", + "Curl_cache_addr", + "Curl_ccalloc", + "Curl_cert_hostcheck", + "Curl_cf_create", + "Curl_cf_def_adjust_pollset", + "Curl_cf_def_cntrl", + "Curl_cf_def_conn_is_alive", + "Curl_cf_def_conn_keep_alive", + "Curl_cf_def_data_pending", + "Curl_cf_def_get_host", + "Curl_cf_def_query", + "Curl_cf_def_recv", + "Curl_cf_def_send", + "Curl_cf_def_shutdown", + "Curl_cf_h1_proxy_insert_after", + "Curl_cf_h2_proxy_insert_after", + "Curl_cf_haproxy_insert_after", + "Curl_cf_http_proxy_get_host", + "Curl_cf_http_proxy_insert_after", + "Curl_cf_https_setup", + "Curl_cf_recv", + "Curl_cf_send", + "Curl_cf_setup_insert_after", + "Curl_cf_socks_proxy_insert_after", + "Curl_cf_ssl_insert_after", + "Curl_cf_ssl_proxy_insert_after", + "Curl_cf_tcp_create", + "Curl_cf_unix_create", + "Curl_cfree", + "Curl_cft_h1_proxy", + "Curl_cft_h2_proxy", + "Curl_cft_happy_eyeballs", + "Curl_cft_haproxy", + "Curl_cft_http_connect", + "Curl_cft_http_proxy", + "Curl_cft_nghttp2", + "Curl_cft_setup", + "Curl_cft_socks_proxy", + "Curl_cft_ssl", + "Curl_cft_ssl_proxy", + "Curl_cft_tcp", + "Curl_cft_unix", + "Curl_checkProxyheaders", + "Curl_check_noproxy", + "Curl_checkheaders", + "Curl_client_cleanup", + "Curl_client_read", + "Curl_client_reset", + "Curl_client_start", + "Curl_client_write", + "Curl_close", + "Curl_cmalloc", + "Curl_compareheader", + "Curl_conn_adjust_pollset", + "Curl_conn_cf_add", + "Curl_conn_cf_adjust_pollset", + "Curl_conn_cf_close", + "Curl_conn_cf_cntrl", + "Curl_conn_cf_connect", + "Curl_conn_cf_discard_all", + "Curl_conn_cf_discard_chain", + "Curl_conn_cf_discard_sub", + "Curl_conn_cf_get_ip_info", + "Curl_conn_cf_get_socket", + "Curl_conn_cf_insert_after", + "Curl_conn_cf_is_ssl", + "Curl_conn_cf_needs_flush", + "Curl_conn_cf_recv", + "Curl_conn_cf_send", + "Curl_conn_close", + "Curl_conn_connect", + "Curl_conn_data_pending", + "Curl_conn_ev_data_attach", + "Curl_conn_ev_data_detach", + "Curl_conn_ev_data_done", + "Curl_conn_ev_data_done_send", + "Curl_conn_ev_data_idle", + "Curl_conn_ev_data_pause", + "Curl_conn_ev_data_setup", + "Curl_conn_flush", + "Curl_conn_free", + "Curl_conn_get_max_concurrent", + "Curl_conn_get_socket", + "Curl_conn_get_stream_error", + "Curl_conn_is_alive", + "Curl_conn_is_connected", + "Curl_conn_is_http2", + "Curl_conn_is_ip_connected", + "Curl_conn_is_multiplex", + "Curl_conn_is_ssl", + "Curl_conn_may_http3", + "Curl_conn_needs_flush", + "Curl_conn_recv", + "Curl_conn_seems_dead", + "Curl_conn_send", + "Curl_conn_setup", + "Curl_conn_shutdown", + "Curl_conn_shutdown_timeleft", + "Curl_conncontrol", + "Curl_connect", + "Curl_connect_only_attach", + "Curl_cookie_add", + "Curl_cookie_cleanup", + "Curl_cookie_clearall", + "Curl_cookie_clearsess", + "Curl_cookie_getlist", + "Curl_cookie_init", + "Curl_cookie_list", + "Curl_cookie_loadfiles", + "Curl_copy_header_value", + "Curl_cpool_add_conn", + "Curl_cpool_add_pollfds", + "Curl_cpool_check_limits", + "Curl_cpool_conn_now_idle", + "Curl_cpool_destroy", + "Curl_cpool_disconnect", + "Curl_cpool_do_by_id", + "Curl_cpool_do_locked", + "Curl_cpool_find", + "Curl_cpool_get_conn", + "Curl_cpool_init", + "Curl_cpool_multi_perform", + "Curl_cpool_prune_dead", + "Curl_cpool_xfer_init", + "Curl_creader_add", + "Curl_creader_client_length", + "Curl_creader_create", + "Curl_creader_def_close", + "Curl_creader_def_done", + "Curl_creader_def_init", + "Curl_creader_def_is_paused", + "Curl_creader_def_needs_rewind", + "Curl_creader_def_resume_from", + "Curl_creader_def_rewind", + "Curl_creader_def_total_length", + "Curl_creader_def_unpause", + "Curl_creader_done", + "Curl_creader_free", + "Curl_creader_get_by_type", + "Curl_creader_is_paused", + "Curl_creader_needs_rewind", + "Curl_creader_read", + "Curl_creader_resume_from", + "Curl_creader_set", + "Curl_creader_set_buf", + "Curl_creader_set_fread", + "Curl_creader_set_mime", + "Curl_creader_set_null", + "Curl_creader_set_rewind", + "Curl_creader_total_length", + "Curl_creader_unpause", + "Curl_creader_will_rewind", + "Curl_crealloc", + "Curl_cstrdup", + "Curl_cw_out_done", + "Curl_cw_out_is_paused", + "Curl_cw_out_unpause", + "Curl_cwriter_add", + "Curl_cwriter_count", + "Curl_cwriter_create", + "Curl_cwriter_def_close", + "Curl_cwriter_def_init", + "Curl_cwriter_def_write", + "Curl_cwriter_free", + "Curl_cwriter_get_by_name", + "Curl_cwriter_get_by_type", + "Curl_cwriter_is_paused", + "Curl_cwriter_unpause", + "Curl_cwriter_write", + "Curl_cwt_out", + "Curl_data_priority_add_child", + "Curl_data_priority_clear_state", + "Curl_debug", + "Curl_detach_connection", + "Curl_doh", + "Curl_doh_cleanup", + "Curl_doh_close", + "Curl_doh_is_resolved", + "Curl_doh_trc", + "Curl_dyn_add", + "Curl_dyn_addf", + "Curl_dyn_addn", + "Curl_dyn_free", + "Curl_dyn_init", + "Curl_dyn_len", + "Curl_dyn_ptr", + "Curl_dyn_reset", + "Curl_dyn_setlen", + "Curl_dyn_tail", + "Curl_dyn_uptr", + "Curl_dyn_vprintf", + "Curl_dynhds_add", + "Curl_dynhds_add_custom", + "Curl_dynhds_cadd", + "Curl_dynhds_cget", + "Curl_dynhds_count", + "Curl_dynhds_free", + "Curl_dynhds_get", + "Curl_dynhds_getn", + "Curl_dynhds_h1_add_line", + "Curl_dynhds_h1_add_line.part.0", + "Curl_dynhds_h1_cadd_line", + "Curl_dynhds_h1_dprint", + "Curl_dynhds_init", + "Curl_dynhds_reset", + "Curl_dynhds_set_opts", + "Curl_dynhds_to_nva", + "Curl_expire", + "Curl_expire_clear", + "Curl_expire_done", + "Curl_failf", + "Curl_fetch_addr", + "Curl_flush_cookies", + "Curl_fopen", + "Curl_freeaddrinfo", + "Curl_freeset", + "Curl_get_line", + "Curl_get_scheme_handler", + "Curl_getaddrinfo", + "Curl_getaddrinfo_ex", + "Curl_getconnectinfo", + "Curl_getdate_capped", + "Curl_getformdata", + "Curl_getformdata.part.0", + "Curl_getinfo", + "Curl_getn_scheme_handler", + "Curl_gmtime", + "Curl_h1_req_parse_free", + "Curl_h1_req_parse_init", + "Curl_h1_req_parse_read", + "Curl_h1_req_write_head", + "Curl_h2_http_1_1_error", + "Curl_handler_file", + "Curl_handler_http", + "Curl_handler_https", + "Curl_handler_mqtt", + "Curl_handler_ws", + "Curl_handler_wss", + "Curl_hash_add", + "Curl_hash_add2", + "Curl_hash_clean", + "Curl_hash_clean_with_criterium", + "Curl_hash_count", + "Curl_hash_delete", + "Curl_hash_destroy", + "Curl_hash_init", + "Curl_hash_next_element", + "Curl_hash_offt_get", + "Curl_hash_offt_init", + "Curl_hash_offt_remove", + "Curl_hash_offt_set", + "Curl_hash_pick", + "Curl_hash_start_iterate", + "Curl_hash_str", + "Curl_headers_cleanup", + "Curl_headers_init", + "Curl_headers_push", + "Curl_hexencode", + "Curl_hmacit", + "Curl_host_is_ipnum", + "Curl_hostcache_clean", + "Curl_hostcache_prune", + "Curl_hsts", + "Curl_hsts_cleanup", + "Curl_hsts_init", + "Curl_hsts_loadcb", + "Curl_hsts_loadfile", + "Curl_hsts_loadfiles", + "Curl_hsts_parse", + "Curl_hsts_save", + "Curl_http", + "Curl_http2_may_switch", + "Curl_http2_request_upgrade", + "Curl_http2_switch", + "Curl_http2_switch_at", + "Curl_http2_upgrade", + "Curl_http_auth_act", + "Curl_http_auth_cleanup_digest", + "Curl_http_connect", + "Curl_http_cookies", + "Curl_http_decode_status", + "Curl_http_done", + "Curl_http_exp100_got100", + "Curl_http_firstwrite", + "Curl_http_getsock_do", + "Curl_http_header", + "Curl_http_host", + "Curl_http_input_auth", + "Curl_http_method", + "Curl_http_output_auth", + "Curl_http_proxy_create_CONNECT", + "Curl_http_proxy_get_destination", + "Curl_http_range", + "Curl_http_req_complete", + "Curl_http_req_free", + "Curl_http_req_make", + "Curl_http_req_make2", + "Curl_http_req_set_reader", + "Curl_http_req_to_h2", + "Curl_http_resp_free", + "Curl_http_resp_make", + "Curl_http_setup_conn", + "Curl_http_size", + "Curl_http_statusline", + "Curl_http_target", + "Curl_http_write_resp", + "Curl_http_write_resp_hd", + "Curl_http_write_resp_hds.part.0", + "Curl_httpchunk_add_reader", + "Curl_httpchunk_encoder", + "Curl_httpchunk_free", + "Curl_httpchunk_init", + "Curl_httpchunk_is_done", + "Curl_httpchunk_read", + "Curl_httpchunk_reset", + "Curl_httpchunk_unencoder", + "Curl_idnconvert_hostname", + "Curl_if2ip", + "Curl_inet_ntop", + "Curl_inet_pton", + "Curl_infof", + "Curl_init_CONNECT", + "Curl_init_dnscache", + "Curl_init_do", + "Curl_init_userdefined", + "Curl_initinfo", + "Curl_input_digest", + "Curl_ip2addr", + "Curl_ipv6_scope", + "Curl_ipv6works", + "Curl_ipvalid", + "Curl_is_ASCII_name", + "Curl_is_absolute_url", + "Curl_is_absolute_url.part.0", + "Curl_is_in_callback", + "Curl_llist_append", + "Curl_llist_count", + "Curl_llist_destroy", + "Curl_llist_head", + "Curl_llist_init", + "Curl_llist_insert_next", + "Curl_loadhostpairs", + "Curl_md5it", + "Curl_meets_timecondition", + "Curl_memdup", + "Curl_memdup0", + "Curl_memrchr", + "Curl_mime_add_header", + "Curl_mime_cleanpart", + "Curl_mime_duppart", + "Curl_mime_duppart.cold", + "Curl_mime_initpart", + "Curl_mime_prepare_headers", + "Curl_mime_set_subparts", + "Curl_month", + "Curl_multi_add_perform", + "Curl_multi_closed", + "Curl_multi_connchanged", + "Curl_multi_get_handle", + "Curl_multi_handle", + "Curl_multi_max_concurrent_streams", + "Curl_multi_pollset_ev", + "Curl_multi_xfer_buf_borrow", + "Curl_multi_xfer_buf_release", + "Curl_multi_xfer_ulbuf_borrow", + "Curl_multi_xfer_ulbuf_release", + "Curl_multiplex_wanted", + "Curl_netrc_cleanup", + "Curl_netrc_init", + "Curl_node_elem", + "Curl_node_llist", + "Curl_node_next", + "Curl_node_remove", + "Curl_node_uremove", + "Curl_none_cert_status_request", + "Curl_none_check_cxn", + "Curl_none_cleanup", + "Curl_none_close_all", + "Curl_none_data_pending", + "Curl_none_engines_list", + "Curl_none_false_start", + "Curl_none_set_engine", + "Curl_none_set_engine_default", + "Curl_none_shutdown", + "Curl_now", + "Curl_on_disconnect", + "Curl_once_resolved", + "Curl_open", + "Curl_oss_check_peer_cert", + "Curl_ossl_ctx_init", + "Curl_output_aws_sigv4", + "Curl_output_digest", + "Curl_parse_interface", + "Curl_parse_login_details", + "Curl_parsenetrc", + "Curl_pgrsDone", + "Curl_pgrsLimitWaitTime", + "Curl_pgrsResetTransferSizes", + "Curl_pgrsSetDownloadCounter", + "Curl_pgrsSetDownloadSize", + "Curl_pgrsSetUploadCounter", + "Curl_pgrsSetUploadSize", + "Curl_pgrsStartNow", + "Curl_pgrsTime", + "Curl_pgrsTimeWas", + "Curl_pgrsUpdate", + "Curl_pgrsUpdate_nometer", + "Curl_pin_peer_pubkey", + "Curl_poll", + "Curl_poll.part.0", + "Curl_pollfds_add_ps", + "Curl_pollfds_add_sock", + "Curl_pollfds_cleanup", + "Curl_pollfds_init", + "Curl_pollset_add_socks", + "Curl_pollset_change", + "Curl_pollset_change.part.0", + "Curl_pollset_check", + "Curl_pollset_reset", + "Curl_pollset_set", + "Curl_pretransfer", + "Curl_printable_address", + "Curl_rand_alnum", + "Curl_rand_bytes", + "Curl_rand_hex", + "Curl_range", + "Curl_ratelimit", + "Curl_raw_tolower", + "Curl_raw_toupper", + "Curl_rename", + "Curl_req_abort_sending", + "Curl_req_done", + "Curl_req_done_sending", + "Curl_req_free", + "Curl_req_hard_reset", + "Curl_req_init", + "Curl_req_send", + "Curl_req_send_more", + "Curl_req_sendbuf_empty", + "Curl_req_set_upload_done", + "Curl_req_soft_reset", + "Curl_req_start", + "Curl_req_stop_send_recv", + "Curl_req_want_send", + "Curl_resolv", + "Curl_resolv_check", + "Curl_resolv_getsock", + "Curl_resolv_timeout", + "Curl_resolv_unlink", + "Curl_resolver_cancel", + "Curl_resolver_cleanup", + "Curl_resolver_duphandle", + "Curl_resolver_error", + "Curl_resolver_getaddrinfo", + "Curl_resolver_getsock", + "Curl_resolver_global_init", + "Curl_resolver_init", + "Curl_resolver_is_resolved", + "Curl_resolver_kill", + "Curl_resolver_wait_resolv", + "Curl_retry_request", + "Curl_safecmp", + "Curl_saferealloc", + "Curl_senddata", + "Curl_sendrecv", + "Curl_set_in_callback", + "Curl_setblobopt", + "Curl_setstropt", + "Curl_setup_conn", + "Curl_sha256it", + "Curl_sha512_256it", + "Curl_share_lock", + "Curl_share_unlock", + "Curl_shutdown_clear", + "Curl_shutdown_start", + "Curl_shutdown_started", + "Curl_shutdown_timeleft", + "Curl_slist_append_nodup", + "Curl_slist_duplicate", + "Curl_socket_check", + "Curl_socketpair", + "Curl_speedcheck", + "Curl_speedinit", + "Curl_splay", + "Curl_splayget", + "Curl_splaygetbest", + "Curl_splayinsert", + "Curl_splayremove", + "Curl_splayset", + "Curl_ssl", + "Curl_ssl_adjust_pollset", + "Curl_ssl_backend", + "Curl_ssl_cert_status_request", + "Curl_ssl_cf_get_config", + "Curl_ssl_cf_get_primary_config", + "Curl_ssl_cf_is_proxy", + "Curl_ssl_close_all", + "Curl_ssl_conn_config_cleanup", + "Curl_ssl_conn_config_init", + "Curl_ssl_conn_config_match", + "Curl_ssl_conn_config_update", + "Curl_ssl_delsessionid", + "Curl_ssl_easy_config_complete", + "Curl_ssl_easy_config_init", + "Curl_ssl_engines_list", + "Curl_ssl_false_start", + "Curl_ssl_free_certinfo", + "Curl_ssl_get_internals", + "Curl_ssl_getsessionid", + "Curl_ssl_init", + "Curl_ssl_init_certinfo", + "Curl_ssl_initsessions", + "Curl_ssl_multi", + "Curl_ssl_openssl", + "Curl_ssl_peer_init", + "Curl_ssl_push_certinfo_len", + "Curl_ssl_random", + "Curl_ssl_sessionid_lock", + "Curl_ssl_sessionid_unlock", + "Curl_ssl_set_engine", + "Curl_ssl_set_engine_default", + "Curl_ssl_set_sessionid", + "Curl_ssl_setup_x509_store", + "Curl_ssl_supports", + "Curl_ssl_version", + "Curl_str2addr", + "Curl_str_key_compare", + "Curl_strdup", + "Curl_strerror", + "Curl_strntolower", + "Curl_strntoupper", + "Curl_strtok_r", + "Curl_thread_create", + "Curl_thread_destroy", + "Curl_thread_join", + "Curl_timediff", + "Curl_timediff_ceil", + "Curl_timediff_us", + "Curl_timeleft", + "Curl_timestrcmp", + "Curl_tls_keylog_close", + "Curl_tls_keylog_enabled", + "Curl_tls_keylog_open", + "Curl_tls_keylog_write_line", + "Curl_transferencode", + "Curl_trc_cf_infof", + "Curl_trc_feat_read", + "Curl_trc_feat_write", + "Curl_trc_feat_ws", + "Curl_trc_init", + "Curl_trc_read", + "Curl_trc_write", + "Curl_trc_ws", + "Curl_uc_to_curlcode", + "Curl_unix2addr", + "Curl_update_timer", + "Curl_update_timer.part.0", + "Curl_updatesocket", + "Curl_url_set_authority", + "Curl_urldecode", + "Curl_verboseconnect", + "Curl_vsetopt", + "Curl_wait_ms", + "Curl_wkday", + "Curl_ws_accept", + "Curl_ws_request", + "Curl_xfer_flush", + "Curl_xfer_is_blocked", + "Curl_xfer_needs_flush", + "Curl_xfer_recv", + "Curl_xfer_send", + "Curl_xfer_send_close", + "Curl_xfer_send_shutdown", + "Curl_xfer_setup1", + "Curl_xfer_setup_nop", + "Curl_xfer_write_done", + "Curl_xfer_write_resp", + "Curl_xfer_write_resp_hd", + "Cursor", + "DEBUG_PATH_EXISTS.0", + "DLSYM.2", + "DOUBLE_POW5_INV_SPLIT", + "DOUBLE_POW5_SPLIT", + "Danger", + "Data", + "DataClassification", + "DataContents", + "DataFlowType", + "DataGovernance", + "DataGovernanceResponsibleParty", + "Dataset", + "Datasets", + "Date", + "Debug", + "DebugByte", + "DebugInfoUnitHeadersIter", + "DebugList", + "DebugMap", + "DebugSet", + "DebugStruct", + "DebugTuple", + "DebugValue", + "DecodeError", + "Decoder", + "Decomposition", + "DecompositionTablesV1", + "DedupSortedIter", + "Default", + "DefaultCallsite", + "DefaultFrequencyRank", + "DefaultHasher", + "DefaultHeadersInterceptor", + "Demangle", + "Dependencies", + "Dependency", + "Deref", + "Description", + "Deserialize", + "DeserializeSeed", + "Deserializer", + "DetachGuard", + "Dialer", + "Diff", + "DirBuilder", + "Direction", + "Direction; 2]", + "Dispatch", + "Dispatchers", + "Display", + "DisplayBacktrace", + "DisplayBuffer", + "DisplayValue", + "DlsymWeak", + "DnsCache", + "DoubleEndedIterator", + "Drain", + "Drop", + "DropGuard", + "Dropper", + "DtorUnwindGuard", + "Duration", + "Dwarf", + "DynInterceptor", + "ENABLED.0", + "Easy2", + "Easy2Handle", + "Edge", + "EffectiveUri", + "Empty", + "Encoding", + "EndianSlice", + "Engine", + "Entered", + "EnteredSpan", + "EntriesCursor", + "Entry", + "EnumAccess", + "EnumDeserializer", + "EnumRefDeserializer", + "EnvironmentVar", + "EnvironmentVars", + "Epsilons", + "Errno", + "Error", + "Error$u2b$core", + "ErrorCode", + "ErrorFormatter", + "ErrorImpl", + "ErrorInner", + "ErrorKind", + "Escape", + "EscapeDebug", + "EscapeDefault", + "EucJpDecoder", + "EucKrDecoder", + "Event", + "EventListener", + "EventListenerFuture", + "Events", + "Exception", + "Executor", + "Expected", + "ExpectedInMap", + "ExpectedInSeq", + "ExprNode", + "Expression", + "Extend", + "Extensions", + "ExternalReference", + "ExternalReferenceType", + "ExternalReferences", + "ExtraValue", + "Extractor", + "F1", + "F2", + "Fallibility", + "FatAVX2", + "Field", + "File", + "FileEntry", + "FileEntryFormat", + "FileOrStdin", + "FilterMap", + "Finder", + "FinderBuilder", + "FlatMap", + "FlatMapDeserializer", + "FlatSet", + "Flatten", + "Fn", + "FnMut", + "FnOnce", + "Form", + "FormatAscii", + "FormatStringPayload", + "Formatter", + "Formula", + "Frame", + "FrameIter", + "Frames", + "From", + "FromFn", + "FromIterator", + "FromStr", + "FromUtf8Error", + "Function", + "Functions", + "Future", + "Future$u2b$Output $u3d$ core", + "GB18030_INIT", + "GB18030_RANGE_OFFSETS", + "GB18030_RANGE_POINTERS", + "GB2312_HANZI", + "GB2312_OTHER_POINTERS", + "GB2312_OTHER_UNSORTED_OFFSETS", + "GB2312_PINYIN", + "GB2312_SYMBOLS", + "GB2312_SYMBOLS_AFTER_GREEK", + "GETRANDOM_AVAILABLE.0", + "GRND_INSECURE_AVAILABLE.0", + "Gb18030Decoder", + "GeneralPurpose", + "GenericPurl", + "GenericPurlBuilder", + "Get", + "Global", + "GlobalExecutorConfig", + "Graphic", + "GraphicsCollection", + "Group", + "GroupInfo", + "GroupInfoError", + "GroupInfoInner", + "GroupKind", + "GroupState", + "Guard", + "HEX0", + "HEX1", + "Handle", + "Handler", + "Hash", + "HashMap", + "Hasher", + "Hashes", + "HdrName", + "HeaderMap", + "HeaderName", + "HeaderValue", + "HeaderValues", + "Headers", + "HeapVisitor", + "HelpTemplate", + "Helper", + "HeuristicFrequencyRank", + "HexBytes", + "HexNibbles", + "Hir", + "HirFrame", + "HirKind", + "Hook", + "Host", + "HttpClient", + "HttpClientBuilder", + "Hybrid", + "HybridCache", + "HybridEngine", + "IBM866_INIT", + "ISO_2022_JP_INIT", + "ISO_8859_10_INIT", + "ISO_8859_13_INIT", + "ISO_8859_14_INIT", + "ISO_8859_15_INIT", + "ISO_8859_16_INIT", + "ISO_8859_2_INIT", + "ISO_8859_3_INIT", + "ISO_8859_4_INIT", + "ISO_8859_5_INIT", + "ISO_8859_6_INIT", + "ISO_8859_7_INIT", + "ISO_8859_8_INIT", + "ISO_8859_8_I_INIT", + "Id", + "Ident", + "IdentifiableAction", + "Identity", + "Idx", + "ImpactAnalysisJustification", + "ImpactAnalysisResponse", + "ImpactAnalysisState", + "InPlaceDrop", + "InPlaceDstDataSrcBufDrop", + "IncompleteLineProgram", + "Indented", + "Index", + "IndexMap", + "IndexMapCore", + "IndexMut", + "Infallible", + "InlineExtension", + "Inner", + "InnerHttpClient", + "InnerListener", + "Input", + "Inputs", + "Instant", + "Instrumented", + "Interceptor", + "InterceptorObj", + "Internal", + "InternalBitFlags", + "InternalBuilder", + "Interval", + "IntervalSet", + "Into", + "IntoIter", + "IntoNotification", + "InvalidHeaderName", + "InvalidHeaderValue", + "InvalidMethod", + "InvalidStatusCode", + "InvalidUri", + "InvalidUriParts", + "Invoke", + "IoRead", + "IpAddr", + "IpVersion", + "Ipv4Addr", + "Ipv6Addr", + "IsTerminal", + "IsahcClient", + "Iso2022JpDecoder", + "Issue", + "Item", + "Iter", + "Iterator", + "Iterator$u2b$Item $u3d$ clap_builder", + "JIS0208_LEVEL1_KANJI", + "JIS0208_LEVEL2_AND_ADDITIONAL_KANJI", + "JIS0208_RANGE_TRIPLES", + "JIS0208_SYMBOLS", + "JIS0208_SYMBOL_TRIPLES", + "JIS0212_ACCENTED", + "JIS0212_ACCENTED_TRIPLES", + "JIS0212_KANJI", + "JoinHandle", + "JoinInner", + "JsonReadError", + "JsonUnexpected", + "KEY_NOTUSED.0", + "KOI8_R_INIT", + "KOI8_U_INIT", + "KSX1001_BOX", + "KSX1001_HANGUL", + "KSX1001_HANJA", + "KSX1001_LOWERCASE", + "KSX1001_OTHER_POINTERS", + "KSX1001_OTHER_UNSORTED_OFFSETS", + "KSX1001_SYMBOLS", + "KSX1001_UPPERCASE", + "KeyClassifier", + "LOGGER.0", + "LOGGER.1", + "Layout", + "LayoutError", + "Lazy", + "LazyCell", + "LazyLock", + "LazyRef", + "LazyStateID", + "LazyStateIDError", + "Leaf", + "LeafOrInternal", + "Lexer", + "Library", + "License", + "LicenseChoice", + "LicenseContact", + "LicenseId", + "LicenseIdentifier", + "LicenseReq", + "LicenseType", + "Licenses", + "Licensing", + "Lifecycle", + "Lifecycles", + "LineColIterator", + "LineProgramHeader", + "LineRows", + "LineSequence", + "LineWriter", + "LineWriterShim", + "Lines", + "Link", + "List", + "ListGuard", + "ListLock", + "Listener", + "Literal", + "LiteralTrie", + "LittleEndian", + "LocalExecutor", + "LocalsMap", + "LocationRangeUnitIter", + "Log", + "LogValueSet", + "LogVisitor", + "Logger", + "LookForDecimalPoint", + "LookMatcher", + "LookSet", + "LookupHost", + "LoopingLookup", + "LowerHex", + "MAIN_ALTSTACK.0", + "MKeyMap", + "MLParameter", + "Map", + "MapAccess", + "MapDeserializer", + "Mapping", + "MapsEntry", + "MatchError", + "MatchKind", + "MatchedArg", + "MatchesError", + "MaxSizeReached", + "Memchr", + "Memchr2", + "Memchr3", + "Memmem", + "Message", + "MessageError", + "Message]", + "Metadata", + "Method", + "Methods", + "Metrics", + "Middleware", + "Mime", + "ModelCard", + "ModelParameters", + "ModelParametersApproach", + "Multi", + "MultiData", + "MultiError", + "Mut", + "Mutex", + "MutexGuard", + "NEED_ALTSTACK.0", + "NestLimiter", + "NetworkInterface", + "NoSubscriber", + "NodeRef", + "NodeType", + "NonZero", + "NopLogger", + "Notifier", + "NulError", + "ON_BROKEN_PIPE_FLAG_USED.0", + "OUTPUT_CAPTURE_USED.0", + "Object", + "Occurrence", + "Occurrences", + "Offset", + "OffsetDateTime", + "Once", + "OnceCell", + "OnceLock", + "One", + "OneOf", + "OnePass", + "OnePassCache", + "OpenOptions", + "Option", + "OptionVisitor", + "Or", + "OrganizationalContact", + "OrganizationalEntity", + "OsStr", + "OsStrExt", + "OsString", + "Output", + "Owned", + "OwnedFd", + "OwnedOrRef", + "Owner", + "PAGE_SIZE.0", + "POW10", + "POW5TO128", + "POW5TO16", + "POW5TO256", + "POW5TO32", + "POW5TO64", + "PackageUrl", + "Packed", + "Packet", + "PadAdapter", + "PanicGuard", + "PanicPayload", + "ParamName", + "ParamValue", + "Parameter", + "Parker", + "ParseError", + "ParseIntError", + "ParseOptions", + "ParseResult", + "Parsed", + "ParsedArg", + "Parser", + "ParserI", + "ParserNumber", + "PartialEq", + "Parts", + "Patch", + "PatchClassification", + "Patches", + "Path", + "PathAndQuery", + "PathBuf", + "PathBufValueParser", + "Pattern", + "PatternEpsilons", + "PatternID", + "PatternSetInsertError", + "Patterns", + "Payload", + "Pedigree", + "Pending", + "PendingArg", + "PercentDecode", + "PercentEncode", + "PerformanceMetric", + "PerformanceMetrics", + "PhantomData", + "Phase", + "PikeVM", + "PikeVMCache", + "Pin", + "PipeReader", + "PipeWriter", + "PoisonError", + "PollFn", + "Poller", + "Pool", + "PoolGuard", + "PossibleValue", + "Pre", + "PreferenceTrie", + "Prefilter", + "PrefilterI", + "Primitive", + "PrimitiveVisitor", + "Printer", + "PrivateKey", + "ProbeResult", + "ProofOfConcept", + "Properties", + "Property", + "Proxy", + "Purl", + "PurlParts", + "PurlShape", + "PushError", + "QualifierKey", + "Qualifiers", + "QuantitativeAnalysis", + "RabinKarp", + "Range", + "RangeInclusive", + "RangeTrie", + "RangedI64ValueParser", + "RangedU64ValueParser", + "RareByteOffset", + "RareByteOffsets", + "RareBytesOne", + "RareBytesThree", + "RareBytesTwo", + "RawArgs", + "RawIntoIter", + "RawMulti", + "RawMutex", + "RawSpinlock", + "RawTable", + "RawTableInner", + "RawVec", + "RawVecInner", + "Rc", + "Reactor", + "ReactorLock", + "Read", + "ReadRef", + "ReadToEndFuture", + "Reader", + "Ready", + "Rebuilder", + "Receiver", + "Record", + "Recv", + "RecvFut", + "RecvInner", + "RedirectInterceptor", + "ReentrantLockGuard", + "RefCell", + "RefMut", + "RefUnwindSafe$u2b$core", + "Regex", + "RegexI", + "RegexInfo", + "RegexInfoI", + "RegisterResult", + "Registrar", + "Remappable", + "Remapper", + "Repetition", + "Repr", + "Request", + "RequestBody", + "RequestBuilder", + "RequestExt", + "RequestHandler", + "RequestPairs", + "RequiredInputField", + "RequiredOutputField", + "ResUnit", + "ResolveMap", + "ResourceReference", + "ResourceReferences", + "Response", + "ResponseBody", + "ResponseBodyReader", + "ResponseFuture", + "ResponsePairs", + "Result", + "RetryFailError", + "ReverseAnchored", + "ReverseHybrid", + "ReverseInner", + "ReverseSearcher", + "ReverseSuffix", + "RichFormatter", + "RngListIter", + "Runnable", + "Runner", + "RwLock", + "RwLockReadGuard", + "RwLockWriteGuard", + "STATX_SAVED_STATE.0", + "STDIN_HAS_BEEN_READ.0", + "Scheme", + "Scheme2", + "SchemeType", + "Scope", + "ScopeData", + "ScopeGuard", + "ScoreMethod", + "Scores", + "Scrt1", + "Sealed", + "SearchKind", + "Searcher", + "SearcherT", + "Send", + "SendError", + "SendInner", + "Sender", + "Seq", + "SeqAccess", + "SeqDeserializer", + "Serialize", + "SerializeMap", + "SerializeStruct", + "Serializer", + "Servers", + "Service", + "ServiceData", + "Services", + "SetFlags", + "SetOpt", + "Severity", + "Shared", + "Shift", + "ShiftJisDecoder", + "ShortFlags", + "ShouldColorize", + "Signal", + "Signature", + "Signer", + "SimpleCaseFolder", + "SingleByteDecoder", + "SizeLimitExhausted", + "SizeLimitedFmtAdapter", + "Slab", + "Sleepers", + "Slice", + "SliceContains", + "SlicePartialEq", + "SliceRead", + "Slim", + "SlimAVX2", + "SlimSSSE3", + "Slots", + "SmallIndex", + "SmallIndexError", + "SmallVec", + "Socket", + "SocketAddr", + "SocketAddrV4", + "SocketAddrV6", + "Source", + "Span", + "Spans", + "SparseSet", + "SparseSets", + "SpdxExpression", + "SpdxIdentifier", + "SpecCloneIntoVec", + "SpecExtend", + "SpecFromElem", + "SpecFromIter", + "SpecFromIterNested", + "SpecNewImpl", + "SpecVersion", + "SpecWriteFmt", + "Splice", + "Split", + "SplitInternal", + "SslOption", + "StandardHeader", + "Start", + "StartByteMap", + "StartBytesOne", + "StartBytesThree", + "StartBytesTwo", + "Stash", + "State", + "StateBuilderMatches", + "StateID", + "StateIDError", + "StaticStrPayload", + "Status", + "StatusCode", + "Stderr", + "StderrLock", + "Stdin", + "StdinError", + "StdinLock", + "Stdout", + "StdoutLock", + "StdoutRaw", + "Step", + "Storage", + "Str", + "StrRead", + "StrSearcher", + "Strategy", + "Stream", + "String", + "String$u2b$core", + "StringError", + "StringValueParser", + "StringVisitor", + "String]", + "StripPrefixError", + "Style", + "StyleDisplay", + "StyledStr", + "SubCommand", + "Subscriber", + "Suffix", + "SupUnit", + "SupplementPayloadHolder", + "SupportTaskLocals", + "Swid", + "Symbol", + "SymbolName", + "Sync$u2b$core", + "SyncSignal", + "SystemTime", + "Task", + "TaskId", + "TaskLocalsWrapper", + "TaskRef", + "TaskType", + "TcpListener", + "TcpStream", + "Teddy", + "Thread", + "ThreadId", + "ThreadNameString", + "Three", + "Ticker", + "Time", + "Timeout", + "Timer", + "TimerOp", + "Timespec", + "ToHeaderValues", + "ToLowercase", + "ToSocketAddrs", + "ToStrError", + "ToString", + "ToUppercase", + "ToValue", + "Tool", + "Tools", + "ToolsReferences", + "Trailers", + "Transition", + "Translator", + "TranslatorI", + "Trigger", + "TrustyResponse", + "TryFrom", + "TryFromCharError", + "TryFromIntError", + "TryIter", + "TryLockError", + "TrySendError", + "TrySendTimeoutError", + "Two", + "TwoWaySearcher", + "Type", + "TypeId", + "TypedValueParser", + "URANDOM_READY.0", + "USER.0", + "UTF8_DATA", + "UTF_16BE", + "UTF_16BE_INIT", + "UTF_16LE", + "UTF_16LE_INIT", + "UTF_8", + "UTF_8_INIT", + "UdpSocket", + "UdpWaker", + "Unbounded", + "Unexpected", + "UnicodeWordError", + "Unit", + "UnitIndex", + "UnitOffset", + "UnitVisitor", + "UnixDatagram", + "UnixListener", + "UnixStream", + "Unparker", + "UnsafeCell", + "UnwindSafe$u2b$core", + "UpperHex", + "Uri", + "Url", + "UrnUuid", + "Usage", + "UtcOffset", + "Utf16Decoder", + "Utf8BoundedEntry", + "Utf8BoundedMap", + "Utf8Chars", + "Utf8Chunks", + "Utf8Compiler", + "Utf8Decoder", + "Utf8Error", + "Utf8Parser", + "Utf8Sequence", + "Utf8Sequences", + "Utf8State", + "Utf8SuffixMap", + "Uts46", + "VacantEntry", + "Validate", + "ValidationContext", + "ValidationError", + "ValidationErrorsKind", + "ValidationResult", + "Validator", + "Value", + "ValueParser", + "ValueParserFactory", + "ValueSet", + "ValueVisitor", + "VarError", + "VariantAccess", + "VariantDecoder", + "Vec", + "VecDeque", + "VecVisitor", + "Version", + "VersionNegotiation", + "VersionRange", + "Versions", + "Visit", + "VisitSource", + "Visitor", + "Volume", + "Vulnerabilities", + "Vulnerability", + "VulnerabilityAnalysis", + "VulnerabilityCredits", + "VulnerabilityProofOfConcept", + "VulnerabilityRating", + "VulnerabilityRatings", + "VulnerabilityReference", + "VulnerabilityReferences", + "VulnerabilitySource", + "VulnerabilityTarget", + "VulnerabilityTargets", + "WINDOWS_1250_INIT", + "WINDOWS_1251_INIT", + "WINDOWS_1252_INIT", + "WINDOWS_1253_INIT", + "WINDOWS_1254_INIT", + "WINDOWS_1255_INIT", + "WINDOWS_1256_INIT", + "WINDOWS_1257_INIT", + "WINDOWS_1258_INIT", + "WINDOWS_874_INIT", + "WaitGroup", + "WaitTimeoutResult", + "Wake", + "Waker", + "WakerExt", + "Weak", + "WithDecimalPoint", + "Workflow", + "Workspace", + "Write", + "Writer", + "YieldNow", + "Yoke", + "[A]", + "[T]", + "[addr2line", + "[alloc", + "[async_io", + "[isahc", + "[u8]", + "__FieldVisitor", + "__PRETTY_FUNCTION__.0", + "__PRETTY_FUNCTION__.1", + "__PRETTY_FUNCTION__.10", + "__PRETTY_FUNCTION__.11", + "__PRETTY_FUNCTION__.12", + "__PRETTY_FUNCTION__.13", + "__PRETTY_FUNCTION__.14", + "__PRETTY_FUNCTION__.15", + "__PRETTY_FUNCTION__.16", + "__PRETTY_FUNCTION__.17", + "__PRETTY_FUNCTION__.19", + "__PRETTY_FUNCTION__.2", + "__PRETTY_FUNCTION__.20", + "__PRETTY_FUNCTION__.21", + "__PRETTY_FUNCTION__.22", + "__PRETTY_FUNCTION__.28", + "__PRETTY_FUNCTION__.29", + "__PRETTY_FUNCTION__.3", + "__PRETTY_FUNCTION__.31", + "__PRETTY_FUNCTION__.32", + "__PRETTY_FUNCTION__.33", + "__PRETTY_FUNCTION__.34", + "__PRETTY_FUNCTION__.35", + "__PRETTY_FUNCTION__.36", + "__PRETTY_FUNCTION__.37", + "__PRETTY_FUNCTION__.4", + "__PRETTY_FUNCTION__.5", + "__PRETTY_FUNCTION__.6", + "__PRETTY_FUNCTION__.7", + "__PRETTY_FUNCTION__.8", + "__PRETTY_FUNCTION__.9", + "__Visitor", + "__abi_tag", + "__deserialize_content", + "__do_global_dtors_aux", + "__do_global_dtors_aux_fini_array_entry", + "__dso_handle", + "__frame_dummy_init_array_entry", + "__is_enabled", + "__m128i", + "__m256i", + "__macro_support", + "__private", + "__private_api", + "__private_api_log", + "__rdl_alloc", + "__rdl_alloc_zeroed", + "__rdl_dealloc", + "__rdl_realloc", + "__rg_oom", + "__rust_alloc", + "__rust_alloc_error_handler", + "__rust_alloc_error_handler_should_panic", + "__rust_alloc_zeroed", + "__rust_begin_short_backtrace", + "__rust_dealloc", + "__rust_drop_panic", + "__rust_end_short_backtrace", + "__rust_foreign_exception", + "__rust_no_alloc_shim_is_unstable", + "__rust_panic_cleanup", + "__rust_realloc", + "__rust_start_panic", + "__stability", + "__tracing_log", + "_build", + "_build_bin_names_internal", + "_build_recursive", + "_build_self", + "_build_subcommand", + "_create", + "_do_parse", + "_eprint", + "_fini", + "_from_vec_unchecked", + "_init", + "_join", + "_messages", + "_mm256_loadu_si256", + "_new", + "_open", + "_print", + "_print_fmt", + "_rust_extern_with_linkage___dso_handle", + "_set_extension", + "_start", + "_starts_with", + "_strip_prefix", + "_var", + "_var_os", + "_xgetbv", + "_{{closure}}", + "abbrev", + "abort", + "abort_internal", + "abort_on_dtor_unwind", + "abort_on_panic", + "about", + "accept_ranges.0", + "adapter", + "adapters", + "add", + "add_capture_start", + "add_chunk", + "add_custom", + "add_dead_state_loop", + "add_defaults", + "add_dfa_state_for_nfa_state", + "add_empty", + "add_enum", + "add_field", + "add_field_option", + "add_first_group", + "add_from_client", + "add_hd_table_incremental", + "add_index_to", + "add_match", + "add_nested", + "add_next_timeout.isra.0", + "add_nfa_states", + "add_struct", + "add_struct_option", + "add_to_byteset", + "add_transition", + "add_unanchored_start_state_loop", + "add_union", + "add_union_reverse", + "add_val_to", + "addbyter", + "addr2line", + "adler", + "advance_by", + "advisory", + "aead", + "aes_soft", + "after", + "after_double_slash", + "after_punycode_decode", + "agent", + "aho_corasick", + "ahocorasick", + "alignment", + "all", + "alloc", + "alloc_addbyter", + "alloc_err", + "alloc_state", + "allocate", + "alnum", + "alphabet", + "alphabetic", + "alternation", + "alternation_literals", + "altsvc", + "altsvc_add.isra.0", + "altsvc_createid", + "altsvc_flush", + "and_then", + "annotation", + "anstream", + "anstyle", + "anstyle_parse", + "any", + "any_value", + "anyhow", + "api", + "append", + "append_val", + "apply_match", + "aranges", + "arch", + "arcinner_layout_for_value_layout", + "arg", + "arg_group", + "arg_internal", + "arg_matcher", + "arg_matches", + "args", + "args_os", + "argument_conflict", + "arith", + "array", + "as_any", + "as_header_name", + "as_path", + "as_ptr", + "as_ref", + "as_str", + "ascii", + "assert_failed", + "assert_failed_inner", + "ast", + "asyn-thread", + "async", + "async_channel", + "async_executor", + "async_global_executor", + "async_io", + "async_lock", + "async_std", + "async_task", + "atomic", + "attach_supplementary_trie_value", + "attached_text", + "attachment", + "attr_string", + "augment_args", + "auth", + "auth_create_digest_http_message", + "auth_digest_md5_to_ascii", + "auth_digest_sha256_to_ascii", + "auth_digest_string_quoted", + "authority", + "auto", + "automaton", + "available_backends", + "available_parallelism", + "avx", + "avx2", + "backend", + "backends.1", + "backends_len.0", + "backtrace", + "backtrace_rs", + "backtrack", + "badbytes.0", + "badoctets.0", + "baller_connected", + "baller_start.isra.0", + "base64", + "base64_encode", + "base64encdec", + "base64url", + "before_perform", + "begin_panic", + "begin_panic_handler", + "begin_request", + "bidirectional_merge", + "big5", + "bignum", + "binary_search_by", + "bind", + "bindlocal", + "bitflags", + "block_on", + "blocking", + "body", + "body_string", + "bold", + "bom", + "bom_reference", + "bool", + "borrow", + "borrow_cow_str", + "bounded", + "boxed", + "btree", + "bubble_down", + "buf", + "buf_mut", + "buf_reader", + "buffer_capacity_required", + "buffered", + "bufq", + "bufreader", + "bufref", + "bufs_alloc_chain.part.0", + "bufwriter", + "build", + "build_auto", + "build_conflict_err", + "build_forward_with_ranker", + "build_from_nfa", + "build_from_noncontiguous", + "build_id", + "build_many_from_hir", + "build_one_string", + "build_trie", + "builder", + "builders", + "bulk_build_from_sorted_iter", + "bulk_steal_left", + "bulk_steal_right", + "bump", + "bump_and_bump_space", + "bump_space", + "byte_classes", + "bytes", + "bytes_mut", + "byteset", + "c_alt_iter", + "c_at_least", + "c_bounded", + "c_cap", + "c_concat", + "c_str", + "cache", + "cache_next_state", + "cache_start_group", + "calc_split_length", + "call", + "call_mut", + "call_once", + "call_once_force", + "call_once{{vtable.shim}}", + "callback", + "callsite", + "canon_string", + "canonical_binary", + "canonical_gencat", + "canonical_prop", + "canonical_script", + "canonical_value", + "canonicalize", + "capacity_overflow", + "capture", + "captures", + "cartable_ptr", + "case_fold_simple", + "case_ignorable", + "cased", + "catch", + "cause", + "cc", + "cell", + "cf-h1-proxy", + "cf-h2-proxy", + "cf-haproxy", + "cf-https-connect", + "cf-socket", + "cf_get_max_baller_time.isra.0", + "cf_h1_proxy_adjust_pollset", + "cf_h1_proxy_close", + "cf_h1_proxy_connect", + "cf_h1_proxy_destroy", + "cf_h2_adjust_pollset", + "cf_h2_body_send", + "cf_h2_close", + "cf_h2_cntrl", + "cf_h2_connect", + "cf_h2_data_pending", + "cf_h2_destroy", + "cf_h2_is_alive", + "cf_h2_keep_alive", + "cf_h2_proxy_adjust_pollset", + "cf_h2_proxy_close", + "cf_h2_proxy_cntrl", + "cf_h2_proxy_connect", + "cf_h2_proxy_connect.cold", + "cf_h2_proxy_ctx_clear", + "cf_h2_proxy_data_pending", + "cf_h2_proxy_destroy", + "cf_h2_proxy_is_alive", + "cf_h2_proxy_query", + "cf_h2_proxy_recv", + "cf_h2_proxy_send", + "cf_h2_proxy_shutdown", + "cf_h2_query", + "cf_h2_recv", + "cf_h2_send", + "cf_h2_shutdown", + "cf_h2_update_local_win", + "cf_haproxy_adjust_pollset", + "cf_haproxy_close", + "cf_haproxy_connect", + "cf_haproxy_destroy", + "cf_hc_adjust_pollset", + "cf_hc_close", + "cf_hc_cntrl", + "cf_hc_connect", + "cf_hc_data_pending", + "cf_hc_destroy", + "cf_hc_query", + "cf_hc_shutdown", + "cf_he_adjust_pollset", + "cf_he_close", + "cf_he_connect", + "cf_he_ctx_clear.isra.0", + "cf_he_data_pending", + "cf_he_destroy", + "cf_he_query", + "cf_he_shutdown", + "cf_setup_close", + "cf_setup_connect", + "cf_setup_destroy", + "cf_socket_adjust_pollset", + "cf_socket_close", + "cf_socket_cntrl", + "cf_socket_conn_is_alive", + "cf_socket_data_pending", + "cf_socket_destroy", + "cf_socket_get_host", + "cf_socket_open", + "cf_socket_query", + "cf_socket_recv", + "cf_socket_send", + "cf_socket_shutdown", + "cf_ssl_is_alive", + "cf_tcp_connect", + "cfilters", + "cgroups", + "chain", + "char", + "char16trie", + "char_count_general_case", + "check", + "check_explicit", + "check_gzip_header.part.0", + "check_label", + "check_url_code_point", + "checked_add", + "checked_duration_since", + "checked_increment", + "choice", + "choose_pivot", + "chunked", + "clap_builder", + "clap_lex", + "clap_stdin", + "class", + "class_literal_byte", + "cleanup", + "clear", + "clear_cache", + "client", + "clone", + "clone_any", + "clone_from", + "clone_from_impl", + "clone_into", + "clone_span", + "clone_ssl_primary_config", + "clone_subtree", + "clone_waker", + "cloned", + "close", + "close_connect_only", + "close_start_state_loop_for_leftmost", + "cmp", + "cmp_by", + "code", + "codepointtrie", + "collect", + "collect_seq", + "collections", + "color", + "colorchoice", + "colored", + "combinator", + "command", + "common", + "compare_func", + "compile", + "compile_from", + "compile_transition", + "compiler", + "compiler_builtins", + "complete", + "complete_request", + "completed.0", + "component", + "component_data", + "compose_non_hangul", + "composition", + "compute_style", + "concat", + "concurrent_queue", + "condvar", + "config", + "configure", + "conn_report_connect_stats.isra.0", + "conncache", + "connect", + "connecting_getsock", + "connection", + "connection_cache_size", + "construct", + "consume", + "contains", + "contains_key", + "content", + "content_encoding", + "content_type", + "context", + "contiguous", + "control", + "conversions", + "convert", + "convert_unicode_class_error", + "converts", + "cookie", + "cookie_sort", + "cookie_sort_ct", + "cookiehash", + "copied", + "copy_as_lowercase", + "copy_content_type_from_body", + "copy_from_slice", + "copy_matches", + "core", + "core_arch", + "count", + "count_default", + "count_raw", + "cow", + "cpool_add_pollfds", + "cpool_bundle_free_entry", + "cpool_close_and_destroy", + "cpool_close_and_destroy.constprop.0", + "cpool_discard_conn", + "cpool_get_oldest_idle", + "cpool_perform", + "cpool_run_conn_shutdown", + "cpool_run_conn_shutdown.part.0", + "cpool_shutdown_discard_all", + "cptrie", + "cr_buf", + "cr_buf_needs_rewind", + "cr_buf_read", + "cr_buf_resume_from", + "cr_buf_total_length", + "cr_chunked_close", + "cr_chunked_init", + "cr_chunked_read", + "cr_chunked_total_length", + "cr_exp100", + "cr_exp100_done", + "cr_exp100_read", + "cr_in", + "cr_in_init", + "cr_in_is_paused", + "cr_in_needs_rewind", + "cr_in_read", + "cr_in_resume_from", + "cr_in_rewind", + "cr_in_total_length", + "cr_in_unpause", + "cr_lc", + "cr_lc_close", + "cr_lc_init", + "cr_lc_read", + "cr_lc_total_length", + "cr_mime", + "cr_mime_init", + "cr_mime_is_paused", + "cr_mime_needs_rewind", + "cr_mime_read", + "cr_mime_resume_from", + "cr_mime_rewind", + "cr_mime_total_length", + "cr_mime_unpause", + "cr_null", + "cr_null_read", + "cr_null_total_length", + "create", + "create_cache", + "create_dir_all", + "create_usage_no_title", + "create_usage_with_title", + "cross", + "cross_preamble", + "crossbeam_utils", + "crtstuff", + "ctts.2", + "curl", + "curl_addrinfo", + "curl_easy_cleanup", + "curl_easy_duphandle", + "curl_easy_escape", + "curl_easy_getinfo", + "curl_easy_init", + "curl_easy_pause", + "curl_easy_setopt", + "curl_easy_strerror", + "curl_formfree", + "curl_get_line", + "curl_getenv", + "curl_global_init", + "curl_maprintf", + "curl_memrchr", + "curl_mfprintf", + "curl_mime_addpart", + "curl_mime_data", + "curl_mime_data_cb", + "curl_mime_filedata", + "curl_mime_filename", + "curl_mime_headers", + "curl_mime_init", + "curl_mime_name", + "curl_mime_subparts", + "curl_mime_type", + "curl_msnprintf", + "curl_multi_add_handle", + "curl_multi_cleanup", + "curl_multi_info_read", + "curl_multi_init", + "curl_multi_perform", + "curl_multi_remove_handle", + "curl_multi_setopt", + "curl_multi_strerror", + "curl_multi_timeout", + "curl_multi_wait", + "curl_mvaprintf", + "curl_mvsnprintf", + "curl_pushheader_byname", + "curl_range", + "curl_sha512_256", + "curl_slist_append", + "curl_slist_free_all", + "curl_strequal", + "curl_strnequal", + "curl_thread_create_thunk", + "curl_threads", + "curl_trc", + "curl_url", + "curl_url_cleanup", + "curl_url_dup", + "curl_url_get", + "curl_url_get.cold", + "curl_url_set", + "curl_url_set.cold", + "curl_url_strerror", + "curl_version_info", + "curl_ws_send", + "curlx_mstotv", + "curlx_nonblock", + "curlx_sltosi", + "curlx_sltous", + "curlx_sotouz", + "curlx_strtoofft", + "curlx_uitous", + "curlx_ultous", + "curlx_uztosi", + "curlx_uztoui", + "current", + "current_dir", + "current_exe", + "current_span", + "cursor", + "custom", + "custom_request", + "cut", + "cvt", + "cw-out", + "cw_chunked_close", + "cw_chunked_init", + "cw_chunked_write", + "cw_download", + "cw_download_write", + "cw_out_append", + "cw_out_close", + "cw_out_do_write.isra.0", + "cw_out_flush_chain.isra.0", + "cw_out_init", + "cw_out_ptr_flush.constprop.0", + "cw_out_write", + "cw_raw", + "cw_raw_write", + "cyclonedx_bom", + "d2s_full_table", + "data", + "data_governance", + "datagram", + "date", + "day", + "dayk", + "dayo", + "de", + "dead", + "dead_id", + "debug", + "debug_cb", + "debug_list", + "debug_map", + "debug_path_exists", + "debug_set", + "debug_struct", + "debug_struct_field1_finish", + "debug_struct_field2_finish", + "debug_struct_field3_finish", + "debug_struct_field4_finish", + "debug_struct_field5_finish", + "debug_struct_fields_finish", + "debug_tuple", + "debug_tuple_field1_finish", + "debug_tuple_field2_finish", + "debug_tuple_field3_finish", + "debug_tuple_fields_finish", + "decode", + "decode_body", + "decode_error_kind", + "decode_four_hex_digits", + "decode_hex_escape", + "decode_namespace", + "decode_qualifiers", + "decode_subpath", + "decode_suffix", + "decode_to_utf8", + "decode_to_utf8_after_one_potential_bom_byte", + "decode_to_utf8_after_two_potential_bom_bytes", + "decode_to_utf8_raw", + "decode_to_utf8_without_replacement", + "decode_utf8", + "decode_without_bom_handling", + "decomposing_next", + "decompress", + "decompress_zlib", + "decrement_num_running_threads", + "dedup_by", + "dedup_sorted_iter", + "default", + "default_alloc_error_hook", + "default_calloc", + "default_free", + "default_headers", + "default_hook", + "default_malloc", + "default_read_to_end", + "default_realloc", + "deflate_do_close", + "deflate_do_init", + "deflate_do_write", + "deflate_encoding", + "delegate_next_no_pending", + "delete", + "demangle", + "densify", + "dependency", + "deref", + "deregister_tm_clones", + "derive", + "description", + "deserialize", + "deserialize_any", + "deserialize_bool", + "deserialize_enum", + "deserialize_f32", + "deserialize_i64", + "deserialize_identifier", + "deserialize_map", + "deserialize_newtype_struct", + "deserialize_option", + "deserialize_seq", + "deserialize_str", + "deserialize_string", + "deserialize_struct", + "deserialize_u32", + "destroy", + "destroy_async_data", + "destructors", + "detach", + "detect", + "detect_and_initialize", + "determinize", + "dfa", + "dial", + "did_you_mean", + "did_you_mean_flag", + "difference", + "digest", + "digit_table", + "digits.2", + "digits_to_dec_str", + "digits_to_exp_str", + "disambiguator", + "disconnect_all", + "dispatch", + "dispatcher", + "dispatchers", + "display", + "display_buffer", + "display_width", + "dns", + "dns_servers", + "do_count_chars", + "do_init_reader_stack.part.0", + "do_init_writer_stack.part.0", + "do_merge", + "do_reserve_and_handle", + "doh", + "doh_done", + "doh_run_probe", + "doh_write_cb", + "doing_getsock", + "domain_to_ascii_cow", + "domore_getsock", + "dot", + "double_ended", + "downcast_into", + "downcast_raw", + "dragon", + "drain", + "drain_array_with", + "drain_stream", + "drain_tunnel", + "drift", + "driftsort_main", + "driver", + "drop", + "drop_in_place", + "drop_slow", + "drop_span", + "drop_waker", + "duplicate_field", + "duration_since", + "dwarf", + "dying_next", + "dyn aho_corasick", + "dyn core", + "dyn flume", + "dyn regex_automata", + "dyn serde", + "dyn std", + "dyn surf", + "dyn_intercept", + "dynbuf", + "dynhds", + "each_addr", + "eager", + "easy", + "elapsed", + "elf", + "emit_indname_block", + "emit_string", + "empty", + "enable", + "enabled", + "encode_into", + "encoding_rs", + "end", + "end_map", + "end_seq", + "endian_slice", + "endianity", + "enforce_anchored_consistency", + "engine", + "enter", + "entry", + "env", + "epoll", + "epsilon_closure", + "eq", + "equal", + "errno", + "error", + "error_callback", + "error_do_close", + "error_do_init", + "error_do_write", + "error_mut", + "error_writer", + "errors", + "escape", + "escape_debug_ext", + "escape_default", + "escape_string", + "euc_jp", + "euc_kr", + "event", + "event_enabled", + "event_listener", + "event_listener_strategy", + "evidence", + "exception_cleanup", + "exception_id", + "exchange_malloc", + "executor", + "exhausted", + "exists", + "exit", + "exit_guard", + "expect_failed", + "expecting", + "expire_ex", + "explicit_slots", + "expression", + "ext", + "extend", + "extend_context_unchecked", + "extend_unchecked", + "extend_with", + "extension", + "extensions", + "external_models", + "external_reference", + "extract", + "f32", + "f64", + "fastrand", + "fd", + "fd_key_compare", + "feature_names", + "features", + "features_table", + "fetch_addr", + "fetch_purl_bodies", + "ffi", + "field", + "file", + "file_connect", + "file_disconnect", + "file_do", + "file_do.part.0", + "file_done", + "file_host", + "file_name", + "file_or_stdin", + "file_setup_connection", + "file_stem", + "fill_failure_transitions", + "fill_in_global_values", + "filter_map", + "filter_purls", + "find", + "find_at", + "find_avx2", + "find_document_and_license_ref", + "find_eh_action", + "find_function_or_location", + "find_fwd", + "find_impl", + "find_in", + "find_in_slow", + "find_long_subcmd", + "find_mountpoint", + "find_overlapping_fwd", + "find_prefilter_impl", + "find_raw", + "find_raw_avx2", + "find_ref", + "find_rev", + "find_sse2", + "find_stream_on_goaway_func", + "find_unit", + "finish", + "finish_build_both_starts", + "finish_grow", + "finish_non_exhaustive", + "finit.1", + "fire", + "fix_position", + "fixup_slot_ranges", + "flat_map", + "flat_map_take_entry", + "flat_set", + "flatten", + "float", + "float_to_decimal_common_exact", + "float_to_decimal_common_shortest", + "float_to_exponential_common_shortest", + "flt2dec", + "fluent_uri", + "flume", + "flush", + "flush_buf", + "flush_response_headers", + "fmt", + "fmt_decimal", + "fmt_subslice", + "fmt_to", + "fmt_u128", + "fold", + "follows_from", + "fopen", + "for_app", + "for_each", + "for_label", + "forget_allocation_drop_remaining", + "form", + "format", + "format64", + "format_error", + "format_error_message", + "format_exact", + "format_exact_opt", + "format_group", + "format_inner", + "format_shortest", + "format_shortest_opt", + "formatf", + "formatf.constprop.0", + "formatf.constprop.2", + "formatted", + "formdata", + "formtable.1", + "formulation", + "forward", + "fputc_wrapper", + "fr_print.constprop.0", + "fragment_only", + "frame_dummy", + "frame_pack_headers_shared.isra.0", + "free_primary_ssl_config", + "free_push_headers", + "free_streams", + "free_urlhandle", + "freecookie", + "from", + "from_bytes", + "from_bytes_with_nul", + "from_choice", + "from_elem", + "from_env", + "from_fn", + "from_formatter", + "from_iso_week_date", + "from_iter", + "from_iter_in_place", + "from_julian_day_unchecked", + "from_name", + "from_shared", + "from_static", + "from_str", + "from_str_radix", + "from_str_radix_panic", + "from_str_radix_panic_rt", + "from_trait", + "from_utf8", + "from_utf8_lossy", + "fs", + "fseeko_wrapper", + "function", + "futex", + "futex_wake", + "future", + "futures_core", + "futures_io", + "futures_lite", + "gather_conflicts", + "gather_direct_conflicts", + "gave_up", + "gb18030", + "gcb", + "gcc", + "gencat", + "general_purpose", + "general_unencoders", + "generate", + "generic", + "generic_jaro", + "get", + "get32", + "get_all", + "get_backtrace_style", + "get_cached_state", + "get_default", + "get_external_subcommand_value_parser", + "get_help_flag", + "get_matches_from", + "get_matches_with", + "get_max_baller_time.isra.0", + "get_netscape_format", + "get_or_init_blocking", + "get_or_try_init_blocking", + "get_redirect_location", + "get_required_usage_from", + "get_slow", + "get_value_parser", + "getaddrinfo_thread", + "getalnum", + "getenv", + "getinfo", + "getrandom", + "gimli", + "glibc_version", + "global", + "global_rng", + "graph", + "grapheme_extend", + "grisu", + "group_info", + "grow", + "grow_amortized", + "grow_one", + "guard", + "gzip_do_close", + "gzip_do_init", + "gzip_do_write", + "gzip_encoding", + "h06938245ce109975", + "h079fd34b43a8e4e4", + "h0ab6c035afe03fd5", + "h0d70f0954c66ce24", + "h0dcbedbe47f7cff8", + "h1432b3ab6a6c9358", + "h146a37d7b80388c1", + "h161e3b9a53e55b60", + "h187ef6100efec241", + "h19033d28387f82b6", + "h1a4d6a9a979a1d24", + "h2131da28ac929c19", + "h214bf6dd5c132ddc", + "h2440b3a7633d1508", + "h27eea5025e862059", + "h29dedeeab47bc32e", + "h2_process_pending_input", + "h2_progress_egress", + "h2_progress_ingress", + "h2_stream_hash_free", + "h2_xfer_write_resp_hd.part.0", + "h2f9b654a2590f16c", + "h33370794d78a645b", + "h38bd36e0c9b9e14f", + "h40c46735ab648345", + "h44e3075594e6d32d", + "h4555e69b9c62fbc1", + "h463f289c6e3517c9", + "h479e79a772e04c56", + "h47f34b513cc70084", + "h4838009ec59abe5a", + "h4fee7e40208a0861", + "h598104a74e475702", + "h5b1a15a6922d36fc", + "h638652b5efa5c5f2", + "h65ca53bff1275dd6", + "h6a5845f4c597fdd0", + "h6b332d0c059a45ad", + "h6d45c6f94fa41751", + "h6dba5646639ddd5e", + "h737bce638e49d53a", + "h795fc0af7ffaa28a", + "h7b7b74bc4ec5109c", + "h7f18be29c04f18e4", + "h83931b213c71ebbd", + "h910d5002937153fb", + "h92125c3496a12cb0", + "h938da38c2fbd75de", + "h96aee1bcfc5c2575", + "h99ad78531c582eb4", + "h9e084327cf22759a", + "ha0cc126fd5f6d9a6", + "ha1ccadd7c0060f7a", + "hab035baee8a278b0", + "hack", + "handle", + "handle_alloc_error", + "handle_error", + "handle_message", + "handler", + "has_next_element", + "has_next_key", + "has_windows_root", + "hash", + "hash_elem_using", + "hash_element_dtor", + "hash_fd", + "hash_one", + "hashbrown", + "hashmap_random_keys", + "hb0d012a2587773c1", + "hb48d49a4dff524d1", + "hb5d5930156041c7d", + "hb672c2b7b4a0cc79", + "hb9e1153b17ef8c01", + "hbae482c6ad22af02", + "hbbbae98399bef788", + "hbd656edb2f6fe68b", + "hc2a6681416664433", + "hc8cac7999cb84d4f", + "hc9489588de547002", + "hc977230b8a04f0b5", + "hd4a3d8ee69a4c88a", + "hd50d5879abf2696a", + "hd68c22070c302138", + "hd_inflate_commit_indname", + "hd_inflate_read_len.constprop.0", + "hd_ringbuf_get.part.0", + "hdc31535f360f68b0", + "hdddfd63f426d046a", + "hds_cw_collect", + "hds_cw_collect_write", + "he03e5260a182085c", + "he0fb9ffe59703472", + "he21885cf3f7ea591", + "he67a418996440bbc", + "hea7ad9f0689e9f39", + "header", + "header_cb", + "header_name", + "header_names", + "header_value", + "header_values", + "headers", + "heapsort", + "heb9222da4182d876", + "hebb1900f6c348de6", + "help", + "help_template", + "helper", + "hex_nibbles", + "hexdigits", + "hextable", + "hf2ab7b2f1bde06b7", + "hf2fa1fab50e29c7e", + "hf91106a61a512951", + "hf93decf0f3fec0ac", + "hfc1eb6d2a82e9dfe", + "hfc972beefd5a58cf", + "hfdbe5ad3d586dfe7", + "hfe98d7f755e65fa3", + "hfebba49974e148d5", + "hir", + "hir_perl_byte_class", + "hir_perl_unicode_class", + "hir_unicode_class", + "hmac", + "hmac_ipad", + "hmac_opad", + "host", + "host_prefix.1", + "hostasyn", + "hostcache_entry_is_stale", + "hostcache_unlink_entry", + "hostcheck", + "hostip", + "hostip6", + "hour", + "hsts", + "hsts_add.isra.0", + "hsts_create", + "hsts_load", + "hsts_pull", + "http", + "http1", + "http2", + "http2_cfilter_add", + "http2_data_done", + "http2_data_setup.isra.0", + "http2_handle_stream_close", + "http_aws_sigv4", + "http_chunks", + "http_client", + "http_digest", + "http_exp100_send_anyway", + "http_headers", + "http_perhapsrewind", + "http_proxy", + "http_proxy_cf_close", + "http_proxy_cf_connect", + "http_proxy_cf_destroy", + "http_rw_hd", + "http_types", + "http_write_header", + "httpchunk_readwrite.part.0.constprop.0", + "https_proxy_present", + "huff_decode_table", + "huff_sym_table", + "hybrid", + "hybrid_try_search_half_fwd", + "hybrid_try_search_half_rev", + "i128", + "i16", + "i32", + "i64", + "i8", + "icu_collections", + "icu_locid", + "icu_normalizer", + "icu_properties", + "icu_provider", + "id", + "ident", + "identity_encoding", + "idn", + "idna", + "if2ip", + "if_host_prefix.0", + "if_std", + "ignore_exponent", + "ignore_integer", + "ignore_str", + "imp", + "impl [T]", + "impl alloc", + "impl anyhow", + "impl char", + "impl core", + "impl event_listener", + "impl flume", + "impl i64", + "impl indexmap", + "impl isahc", + "impl regex_automata", + "impl serde", + "impl spdx", + "impl std", + "impl str", + "impl u32", + "impl u64", + "impl usize", + "impls", + "imprecise_license_id", + "in_binder", + "in_place_collect", + "in_place_drop", + "increase", + "increment_depth", + "increment_num_running_threads", + "indent", + "index", + "index_mut", + "indexmap", + "inet_ntop", + "inet_pton", + "inet_pton4", + "infer", + "infer_type_id", + "inflate", + "inflate_stream", + "init", + "init_cache", + "init_completed", + "init_ctor", + "init_current", + "init_full_state", + "init_ssl", + "init_tree", + "init_unanchored_start_state", + "init_with_config", + "init_wrapper", + "initialize", + "initialize_or_wait", + "initialized", + "inner", + "input", + "insert", + "insert_bytes", + "insert_context_unchecked", + "insert_fit", + "insert_link_dep.part.0", + "insert_recursing", + "insert_tail", + "insert_timer", + "insert_unchecked", + "insert_unique", + "int", + "integer_62", + "intercept", + "interceptor", + "internal", + "internal_decode", + "internal_small_index", + "intersect", + "interval", + "into", + "into_ast", + "into_bytes", + "into_class_literal", + "into_inner", + "into_iter", + "into_kind", + "into_nfa", + "into_notification", + "into_parts", + "into_reader", + "into_string", + "into_task", + "into_vals_flatten", + "invalid_input_anchored", + "invalid_input_unanchored", + "invalid_length", + "invalid_subcommand", + "invalid_type", + "invalid_utf8", + "invalid_value", + "invoke", + "io", + "ip_addr", + "ipnsort", + "ipv6_parse", + "is_accelerated", + "is_ascii", + "is_client_error", + "is_contained_in", + "is_dead", + "is_dir", + "is_empty", + "is_end_crlf", + "is_equal_raw", + "is_escape", + "is_escapeable_character", + "is_fast", + "is_file", + "is_long", + "is_match", + "is_match_at", + "is_match_nofail", + "is_negative_number", + "is_printable", + "is_qualifier_key_valid", + "is_read_vectored", + "is_server_error", + "is_short", + "is_size_align_valid", + "is_special", + "is_start", + "is_start_crlf", + "is_terminal", + "is_type_valid", + "is_valid_leap_second_stand_in", + "is_valid_package_type", + "is_valid_qualifier_name", + "is_word_ascii", + "is_word_character", + "is_word_end_half_unicode", + "is_word_end_unicode", + "is_word_start_half_unicode", + "is_word_start_unicode", + "is_word_unicode", + "is_word_unicode_negate", + "is_write_vectored", + "is_zero_slow_path", + "isahc", + "isize", + "iso8601", + "iso_2022_jp", + "iter", + "iter_matches", + "iter_mut", + "iter_trans", + "iterator", + "jaro", + "jis0208_symbol_decode", + "join", + "join_generic_copy", + "key", + "key_password", + "keylog", + "keylog_file_fp", + "kv", + "kv_log_macro", + "lang_start", + "lang_start_internal", + "layout", + "lazy", + "lazy_lock", + "lazy_resolve", + "legacy", + "len_before_body", + "len_mismatch_fail", + "len_overflow", + "lexer", + "libs_dl_iterate_phdr", + "libunwind", + "license", + "license_id", + "licensing", + "lifecycle", + "lifecycles", + "limited", + "line", + "linewriter", + "linewritershim", + "linux", + "linux_like", + "list", + "listen", + "listener", + "literal", + "literal_trie", + "llist", + "load_dwarf_package", + "local", + "local_addr", + "locate_build_id", + "lock", + "lock_api", + "lock_contended", + "log", + "logger", + "look", + "lookup", + "lookup.0", + "lookup_slow", + "lookup_token", + "lossy", + "lower_digits", + "main", + "main_loop", + "make_error", + "make_handler", + "make_with", + "mantissa", + "map", + "mapping", + "maps", + "marker", + "match_arg_error", + "match_kind", + "match_len", + "match_pattern", + "matched_arg", + "matches", + "matches_urn_uuid_regex", + "max5data", + "max_level_hint", + "max_pattern_len", + "max_utf8_buffer_length", + "max_utf8_buffer_length_without_replacement", + "maybe_parse_ascii_class", + "maybe_parse_special_word_boundary", + "md5", + "median3_rec", + "mem", + "mem_default", + "memchr", + "memchr2_raw", + "memchr3_raw", + "memchr_aligned", + "memchr_raw", + "memmem", + "memory_usage", + "memrchr", + "memrchr_raw", + "merge", + "meta", + "metadata", + "method", + "methods", + "metrics", + "middleware", + "mime", + "mime_file_free", + "mime_file_read", + "mime_file_seek", + "mime_mem_free", + "mime_mem_read", + "mime_mem_seek", + "mime_size", + "mime_subparts_free", + "mime_subparts_read.constprop.0", + "mime_subparts_seek", + "mime_subparts_unbind", + "mime_unpause", + "mimetable.0", + "min", + "min_pattern_len", + "min_stack_size", + "minimize", + "miniz_oxide", + "missing_field", + "missing_required_argument", + "missing_subcommand", + "mkdir", + "mkeymap", + "mmap", + "modelcard", + "models", + "modify", + "modify_with_mode", + "month", + "month_day", + "month_days_cumulative.0", + "mprintf", + "mqtt", + "mqtt_do", + "mqtt_doing", + "mqtt_done", + "mqtt_getsock", + "mqtt_read_publish", + "mqtt_recv_atleast", + "mqtt_setup_conn", + "msg", + "mstate", + "mul_digits", + "mul_pow10", + "mul_pow2", + "multi", + "multi_done", + "multi_done_locked", + "multi_follow", + "multi_getsock", + "multi_handle_timeout", + "multi_runsingle", + "multi_runsingle.cold", + "multi_wait.part.0", + "multissl_adjust_pollset", + "multissl_close", + "multissl_connect", + "multissl_connect_nonblocking", + "multissl_get_internals", + "multissl_init", + "multissl_recv_plain", + "multissl_send_plain", + "multissl_setup.part.0", + "multissl_version", + "mutex", + "my_sha256_final", + "my_sha256_init", + "my_sha256_update", + "n_to_m_digits", + "name", + "name_attr", + "name_entry", + "name_no_brackets", + "namespace", + "native", + "negate", + "net", + "netrc", + "new", + "new_debug", + "new_lookup", + "new_span", + "new_unchecked", + "new_uninit_in", + "new_unnamed", + "new_val_group", + "new_variant_decoder", + "next", + "next16", + "next_back", + "next_bytes", + "next_code_point", + "next_element", + "next_element_seed", + "next_entry", + "next_eoi_state", + "next_fallback", + "next_flag", + "next_key_seed", + "next_match", + "next_match_back", + "next_os", + "next_state", + "next_str", + "next_value", + "next_value_os", + "nfa", + "nghttp2_adjust_local_window_size", + "nghttp2_buf", + "nghttp2_buf_free", + "nghttp2_buf_init", + "nghttp2_buf_init2", + "nghttp2_buf_reserve", + "nghttp2_buf_reset", + "nghttp2_buf_wrap_init", + "nghttp2_bufs_add", + "nghttp2_bufs_addb", + "nghttp2_bufs_free", + "nghttp2_bufs_init3", + "nghttp2_bufs_len", + "nghttp2_bufs_next_present", + "nghttp2_bufs_realloc", + "nghttp2_bufs_reset", + "nghttp2_callbacks", + "nghttp2_check_authority", + "nghttp2_check_header_name", + "nghttp2_check_header_value", + "nghttp2_check_header_value_rfc9113", + "nghttp2_check_method", + "nghttp2_check_path", + "nghttp2_cpymem", + "nghttp2_data_provider_wrap_v1", + "nghttp2_downcase", + "nghttp2_enable_strict_preface", + "nghttp2_extpri", + "nghttp2_extpri_from_uint8", + "nghttp2_extpri_to_uint8", + "nghttp2_frame", + "nghttp2_frame_add_pad", + "nghttp2_frame_altsvc_free", + "nghttp2_frame_data_free", + "nghttp2_frame_data_init", + "nghttp2_frame_extension_free", + "nghttp2_frame_goaway_free", + "nghttp2_frame_goaway_init", + "nghttp2_frame_hd_init", + "nghttp2_frame_headers_free", + "nghttp2_frame_headers_init", + "nghttp2_frame_headers_payload_nv_offset", + "nghttp2_frame_iv_copy", + "nghttp2_frame_origin_free", + "nghttp2_frame_pack_altsvc", + "nghttp2_frame_pack_frame_hd", + "nghttp2_frame_pack_goaway", + "nghttp2_frame_pack_headers", + "nghttp2_frame_pack_origin", + "nghttp2_frame_pack_ping", + "nghttp2_frame_pack_priority", + "nghttp2_frame_pack_priority_spec", + "nghttp2_frame_pack_priority_update", + "nghttp2_frame_pack_push_promise", + "nghttp2_frame_pack_rst_stream", + "nghttp2_frame_pack_settings", + "nghttp2_frame_pack_settings_payload", + "nghttp2_frame_pack_window_update", + "nghttp2_frame_ping_free", + "nghttp2_frame_ping_init", + "nghttp2_frame_priority_free", + "nghttp2_frame_priority_init", + "nghttp2_frame_priority_len", + "nghttp2_frame_priority_update_free", + "nghttp2_frame_push_promise_free", + "nghttp2_frame_rst_stream_free", + "nghttp2_frame_rst_stream_init", + "nghttp2_frame_settings_free", + "nghttp2_frame_settings_init", + "nghttp2_frame_trail_padlen", + "nghttp2_frame_unpack_altsvc_payload", + "nghttp2_frame_unpack_frame_hd", + "nghttp2_frame_unpack_goaway_payload", + "nghttp2_frame_unpack_headers_payload", + "nghttp2_frame_unpack_origin_payload", + "nghttp2_frame_unpack_ping_payload", + "nghttp2_frame_unpack_priority_payload", + "nghttp2_frame_unpack_priority_spec", + "nghttp2_frame_unpack_priority_update_payload", + "nghttp2_frame_unpack_push_promise_payload", + "nghttp2_frame_unpack_rst_stream_payload", + "nghttp2_frame_unpack_settings_entry", + "nghttp2_frame_unpack_settings_payload", + "nghttp2_frame_unpack_settings_payload2", + "nghttp2_frame_unpack_window_update_payload", + "nghttp2_frame_window_update_free", + "nghttp2_frame_window_update_init", + "nghttp2_get_uint16", + "nghttp2_get_uint32", + "nghttp2_hd", + "nghttp2_hd_deflate_bound", + "nghttp2_hd_deflate_change_table_size", + "nghttp2_hd_deflate_free", + "nghttp2_hd_deflate_hd_bufs", + "nghttp2_hd_deflate_init2", + "nghttp2_hd_entry_free", + "nghttp2_hd_entry_init", + "nghttp2_hd_huff_decode", + "nghttp2_hd_huff_decode_context_init", + "nghttp2_hd_huff_decode_failure_state", + "nghttp2_hd_huff_encode", + "nghttp2_hd_huff_encode_count", + "nghttp2_hd_huffman", + "nghttp2_hd_huffman_data", + "nghttp2_hd_inflate_change_table_size", + "nghttp2_hd_inflate_end_headers", + "nghttp2_hd_inflate_free", + "nghttp2_hd_inflate_hd_nv", + "nghttp2_hd_inflate_init", + "nghttp2_hd_table_get", + "nghttp2_helper", + "nghttp2_http", + "nghttp2_http2_strerror", + "nghttp2_http_on_data_chunk", + "nghttp2_http_on_header", + "nghttp2_http_on_remote_end_stream", + "nghttp2_http_on_request_headers", + "nghttp2_http_on_response_headers", + "nghttp2_http_on_trailer_headers", + "nghttp2_http_parse_priority", + "nghttp2_http_record_request_method", + "nghttp2_increase_local_window_size", + "nghttp2_is_fatal", + "nghttp2_iv_check", + "nghttp2_map", + "nghttp2_map_each", + "nghttp2_map_each_free", + "nghttp2_map_find", + "nghttp2_map_free", + "nghttp2_map_init", + "nghttp2_map_insert", + "nghttp2_map_remove", + "nghttp2_map_size", + "nghttp2_mem", + "nghttp2_mem_calloc", + "nghttp2_mem_default", + "nghttp2_mem_free", + "nghttp2_mem_free2", + "nghttp2_mem_malloc", + "nghttp2_mem_realloc", + "nghttp2_nv_array_copy", + "nghttp2_nv_array_del", + "nghttp2_option", + "nghttp2_option_del", + "nghttp2_option_new", + "nghttp2_option_set_no_auto_window_update", + "nghttp2_option_set_no_rfc9113_leading_and_trailing_ws_validation", + "nghttp2_outbound_item", + "nghttp2_outbound_item_free", + "nghttp2_outbound_item_init", + "nghttp2_outbound_queue_pop", + "nghttp2_outbound_queue_push", + "nghttp2_pack_settings_payload", + "nghttp2_pack_settings_payload2", + "nghttp2_pq", + "nghttp2_pq_empty", + "nghttp2_pq_free", + "nghttp2_pq_init", + "nghttp2_pq_pop", + "nghttp2_pq_push", + "nghttp2_pq_remove", + "nghttp2_pq_size", + "nghttp2_pq_top", + "nghttp2_priority_spec", + "nghttp2_priority_spec_check_default", + "nghttp2_priority_spec_default_init", + "nghttp2_priority_spec_init", + "nghttp2_priority_spec_normalize_weight", + "nghttp2_put_uint16be", + "nghttp2_put_uint32be", + "nghttp2_ratelim", + "nghttp2_ratelim_drain", + "nghttp2_ratelim_init", + "nghttp2_ratelim_update", + "nghttp2_rcbuf", + "nghttp2_rcbuf_decref", + "nghttp2_rcbuf_del", + "nghttp2_rcbuf_incref", + "nghttp2_rcbuf_new", + "nghttp2_rcbuf_new2", + "nghttp2_session", + "nghttp2_session_add_goaway", + "nghttp2_session_add_item", + "nghttp2_session_add_ping", + "nghttp2_session_add_rst_stream", + "nghttp2_session_add_settings", + "nghttp2_session_add_window_update", + "nghttp2_session_adjust_closed_stream", + "nghttp2_session_adjust_idle_stream", + "nghttp2_session_callbacks_del", + "nghttp2_session_callbacks_new", + "nghttp2_session_callbacks_set_error_callback", + "nghttp2_session_callbacks_set_on_begin_headers_callback", + "nghttp2_session_callbacks_set_on_data_chunk_recv_callback", + "nghttp2_session_callbacks_set_on_frame_recv_callback", + "nghttp2_session_callbacks_set_on_frame_send_callback", + "nghttp2_session_callbacks_set_on_header_callback", + "nghttp2_session_callbacks_set_on_stream_close_callback", + "nghttp2_session_callbacks_set_send_callback", + "nghttp2_session_check_request_allowed", + "nghttp2_session_client_new2", + "nghttp2_session_client_new3", + "nghttp2_session_close_stream", + "nghttp2_session_close_stream_if_shut_rdwr", + "nghttp2_session_consume", + "nghttp2_session_del", + "nghttp2_session_destroy_stream", + "nghttp2_session_detach_idle_stream", + "nghttp2_session_get_local_window_size", + "nghttp2_session_get_remote_settings", + "nghttp2_session_get_remote_window_size", + "nghttp2_session_get_stream", + "nghttp2_session_get_stream_effective_local_window_size", + "nghttp2_session_get_stream_effective_recv_data_length", + "nghttp2_session_get_stream_raw", + "nghttp2_session_get_stream_remote_window_size", + "nghttp2_session_get_stream_user_data", + "nghttp2_session_is_my_stream_id", + "nghttp2_session_keep_closed_stream", + "nghttp2_session_keep_idle_stream", + "nghttp2_session_mem_recv", + "nghttp2_session_mem_recv2", + "nghttp2_session_mem_recv2.cold", + "nghttp2_session_mem_send_internal", + "nghttp2_session_on_altsvc_received", + "nghttp2_session_on_data_received", + "nghttp2_session_on_goaway_received", + "nghttp2_session_on_headers_received", + "nghttp2_session_on_origin_received", + "nghttp2_session_on_ping_received", + "nghttp2_session_on_priority_received", + "nghttp2_session_on_priority_update_received", + "nghttp2_session_on_push_promise_received", + "nghttp2_session_on_push_response_headers_received", + "nghttp2_session_on_request_headers_received", + "nghttp2_session_on_response_headers_received", + "nghttp2_session_on_rst_stream_received", + "nghttp2_session_on_settings_received", + "nghttp2_session_on_window_update_received", + "nghttp2_session_open_stream", + "nghttp2_session_open_stream.localalias", + "nghttp2_session_pack_data", + "nghttp2_session_pop_next_ob_item", + "nghttp2_session_reprioritize_stream", + "nghttp2_session_resume_data", + "nghttp2_session_send", + "nghttp2_session_set_local_window_size", + "nghttp2_session_set_stream_user_data", + "nghttp2_session_terminate_session", + "nghttp2_session_terminate_session_with_reason", + "nghttp2_session_update_local_settings", + "nghttp2_session_update_recv_connection_window_size", + "nghttp2_session_update_recv_stream_window_size", + "nghttp2_session_upgrade2", + "nghttp2_session_want_read", + "nghttp2_session_want_write", + "nghttp2_should_send_window_update", + "nghttp2_stream", + "nghttp2_stream_attach_item", + "nghttp2_stream_change_weight", + "nghttp2_stream_check_deferred_by_flow_control", + "nghttp2_stream_check_deferred_item", + "nghttp2_stream_defer_item", + "nghttp2_stream_dep_add", + "nghttp2_stream_dep_add_subtree", + "nghttp2_stream_dep_distributed_weight", + "nghttp2_stream_dep_find_ancestor", + "nghttp2_stream_dep_insert", + "nghttp2_stream_dep_insert_subtree", + "nghttp2_stream_dep_remove", + "nghttp2_stream_dep_remove_subtree", + "nghttp2_stream_detach_item", + "nghttp2_stream_free", + "nghttp2_stream_in_dep_tree", + "nghttp2_stream_init", + "nghttp2_stream_next_outbound_item", + "nghttp2_stream_promise_fulfilled", + "nghttp2_stream_reschedule", + "nghttp2_stream_resume_deferred_item", + "nghttp2_stream_shutdown", + "nghttp2_stream_update_local_initial_window_size", + "nghttp2_stream_update_remote_initial_window_size", + "nghttp2_strerror", + "nghttp2_submit", + "nghttp2_submit_data_shared", + "nghttp2_submit_goaway", + "nghttp2_submit_ping", + "nghttp2_submit_priority", + "nghttp2_submit_request", + "nghttp2_submit_rst_stream", + "nghttp2_submit_settings", + "nghttp2_submit_window_update", + "nghttp2_time", + "nghttp2_time_now_sec", + "nghttp2_version", + "nilstr.0", + "no_backtrace", + "no_equals", + "node", + "nonblock", + "noncontiguous", + "nonzero", + "noproxy", + "normalize_iter_private", + "normalized_string", + "notate", + "notified", + "notify", + "notify_additional", + "notify_all", + "notify_one", + "now", + "nth", + "num", + "nw_in_reader", + "nw_out_writer", + "obj", + "object", + "object_boxed", + "object_downcast", + "object_drop", + "object_drop_front", + "object_ref", + "offset_date_time", + "ok_token", + "on_begin_headers", + "on_data_chunk_recv", + "on_frame_recv", + "on_frame_send", + "on_header", + "on_register_dispatch", + "on_result", + "on_session_send", + "on_stream_close", + "once", + "once_cell", + "once_lock", + "onepass", + "open_c", + "open_socket", + "opensocket_cb", + "openssl", + "openssl_probe", + "ops", + "optimize_by_preference", + "option", + "option_sort_key", + "or_insert", + "organization", + "os", + "os_str", + "oss_x509_share_free", + "ossl_bio_cf_create", + "ossl_bio_cf_ctrl", + "ossl_bio_cf_destroy", + "ossl_bio_cf_in_read", + "ossl_bio_cf_out_write", + "ossl_cert_status_request", + "ossl_cleanup", + "ossl_close", + "ossl_close_all", + "ossl_connect", + "ossl_connect_common", + "ossl_connect_nonblocking", + "ossl_connect_step2", + "ossl_data_pending", + "ossl_engines_list", + "ossl_get_channel_binding", + "ossl_get_internals", + "ossl_init", + "ossl_keylog_callback", + "ossl_new_session_cb", + "ossl_random", + "ossl_recv", + "ossl_send", + "ossl_session_free", + "ossl_set_engine", + "ossl_set_engine_default", + "ossl_sha256sum", + "ossl_shutdown", + "ossl_strerror", + "ossl_trace", + "ossl_version", + "output", + "output_filename", + "overflow", + "overlaps", + "owned", + "owned_to_vec", + "pack_first_byte.part.0", + "packageurl", + "packed", + "packedpair", + "pad", + "pad_formatted_parts", + "pad_integral", + "pair", + "pal", + "panic", + "panic_advance", + "panic_already_borrowed", + "panic_already_mutably_borrowed", + "panic_bounds_check", + "panic_cannot_unwind", + "panic_cold_display", + "panic_const", + "panic_const_async_fn_resumed", + "panic_const_async_fn_resumed_panic", + "panic_const_div_by_zero", + "panic_const_rem_by_zero", + "panic_count", + "panic_fmt", + "panic_in_cleanup", + "panic_nounwind", + "panic_nounwind_fmt", + "panic_nounwind_nobacktrace", + "panic_on_ord_violation", + "panic_unwind", + "panicking", + "param", + "parent", + "park", + "park_timeout", + "parker_and_task", + "parker_and_waker", + "parking", + "parsable", + "parse", + "parse_ascii", + "parse_attribute", + "parse_authority", + "parse_cannot_be_a_base_path", + "parse_capture_name", + "parse_children", + "parse_counted_repetition", + "parse_decimal", + "parse_decimal_overflow", + "parse_directory_v5", + "parse_escape", + "parse_exponent", + "parse_exponent_overflow", + "parse_file", + "parse_file_v5", + "parse_flag", + "parse_flags", + "parse_fragment", + "parse_from_authority", + "parse_from_json_v1_5", + "parse_from_path", + "parse_from_scheme", + "parse_group", + "parse_hdr", + "parse_header", + "parse_help_subcommand", + "parse_hex", + "parse_hex_brace", + "parse_hex_digits", + "parse_host", + "parse_ident", + "parse_integer", + "parse_ipv4number", + "parse_ipv6addr", + "parse_long_integer", + "parse_mode", + "parse_name", + "parse_namespace", + "parse_next_component_back", + "parse_number", + "parse_object_colon", + "parse_octal", + "parse_offset_date_time", + "parse_opaque", + "parse_opt_value", + "parse_path", + "parse_path_start", + "parse_perl_class", + "parse_proxy", + "parse_qualifiers", + "parse_query", + "parse_query_and_fragment", + "parse_ref", + "parse_ref_", + "parse_relative", + "parse_running_mmaps", + "parse_scheme", + "parse_set_class", + "parse_set_class_item", + "parse_set_class_open", + "parse_set_class_range", + "parse_status_line", + "parse_str", + "parse_subpath", + "parse_type", + "parse_u64_into", + "parse_uncounted_repetition", + "parse_unicode_class", + "parse_unicode_escape", + "parse_url", + "parse_version", + "parse_with_comments", + "parsed", + "parsedate", + "parsedate.constprop.0", + "parsefmt.constprop.0", + "parsenetrc", + "parser", + "parser_bare_item", + "parser_number", + "parser_skip_inner_list.part.0", + "parser_skip_params.part.0", + "parseurl", + "parsing", + "passwd_callback", + "password", + "patch", + "path", + "path_push", + "pattern", + "pattern_len", + "patterns", + "patterns_len", + "payload_as_str", + "peek", + "peek_error", + "peek_invalid_type", + "peek_position", + "peek_space", + "pending", + "percent_encoding", + "perform", + "perform_getsock", + "perl_digit", + "perl_space", + "perl_word", + "personality", + "ph_freeentry", + "pikevm", + "pin", + "pipe", + "pivot", + "pointer_fmt_inner", + "poison", + "poll", + "poll_fill_buf", + "poll_internal", + "poll_messages", + "poll_next", + "poll_read", + "poll_read_vectored", + "poll_with_strategy", + "poll_write", + "polling", + "polyval", + "pool", + "pop", + "pop_class", + "pop_class_op", + "pop_group", + "pop_group_end", + "pop_path", + "position", + "positional_sort_key", + "possible_subcommand", + "possible_value", + "possible_values", + "possibly_round", + "post_field_size", + "powerfmt", + "prefilter", + "prefilter_kind_avx2", + "prefilter_kind_sse2", + "prefix", + "prefixes", + "prepare_resize", + "pretty", + "primitives", + "print", + "print_backref", + "print_const", + "print_const_str_literal", + "print_const_uint", + "print_dyn_trait", + "print_generic_arg", + "print_lifetime_from_index", + "print_path", + "print_path_maybe_open_generics", + "print_quoted_escaped_chars", + "print_raw_with_column", + "print_sep_list", + "print_to_buffer_if_capture_used", + "print_type", + "printable", + "private_type_id", + "probe", + "probe_from_env", + "process", + "process_innermost", + "process_sbom", + "process_timers", + "progress", + "progress_cb", + "promotable_even_clone", + "promotable_even_drop", + "promotable_even_to_mut", + "promotable_even_to_vec", + "promotable_is_unique", + "promotable_odd_clone", + "promotable_odd_drop", + "promotable_odd_to_mut", + "promotable_odd_to_vec", + "proof_of_concept", + "properties", + "property", + "property_values", + "protocol2num", + "protocol_getsock", + "protocols.1", + "provide", + "provider", + "proxy", + "proxy_h2_fr_print.constprop.0", + "proxy_h2_nw_out_writer", + "proxy_h2_on_frame_recv", + "proxy_h2_on_frame_send", + "proxy_h2_on_header", + "proxy_h2_on_stream_close", + "proxy_h2_process_pending_input", + "proxy_h2_progress_egress", + "proxy_h2_progress_ingress", + "proxy_nw_in_reader", + "proxy_password", + "proxy_username", + "prune_head", + "ptr", + "pull_pending", + "punycode", + "purl", + "push", + "push_alternate", + "push_arg_values", + "push_class_op", + "push_class_open", + "push_decomposition16", + "push_decomposition32", + "push_group", + "push_or_else", + "push_str", + "push_styled", + "push_with_handle", + "push_wtf8_codepoint", + "put_slice", + "put_value", + "qualifiers", + "quicksort", + "quit", + "quota_v1", + "rabinkarp", + "rand", + "rand_chacha", + "rand_core", + "random", + "random_seed", + "range", + "range_trie", + "rank", + "raw", + "raw_vec", + "raw_waker", + "rc", + "rcut", + "react", + "reactor", + "read", + "read_buf", + "read_buf_exact", + "read_bytes_at_until", + "read_cb", + "read_contended", + "read_exact", + "read_groups", + "read_ip_literal", + "read_ipv4_addr", + "read_ipv6_addr", + "read_number", + "read_offset", + "read_ref", + "read_sized_offset", + "read_socket_addr_v6", + "read_to_end", + "read_to_end_internal", + "read_to_string", + "read_uleb128", + "read_vectored", + "readback_part", + "reader", + "readlink", + "ready", + "rebuilder", + "record", + "record_all", + "record_bool", + "record_bytes", + "record_debug", + "record_error", + "record_f64", + "record_follows_from", + "record_i128", + "record_i64", + "record_str", + "record_u128", + "record_u64", + "recv", + "recv_from", + "recv_from_with_flags", + "redirect", + "reentrant_lock", + "regex", + "regex_automata", + "regex_syntax", + "register", + "register_tm_clones", + "rehash_in_place", + "remaining", + "remap", + "remapper", + "remove", + "remove2", + "remove_entry", + "remove_expired", + "remove_extra_value", + "remove_kv_tracking", + "remove_leaf_kv", + "remove_timer", + "rename", + "render_file", + "render_usage_", + "repeat", + "repetition", + "replace", + "replace_newline_var", + "replace_range", + "repr_bitpacked", + "req_body_read_callback", + "req_flush", + "request", + "request_builder", + "required_graph", + "reserve", + "reserve_inner", + "reserve_one_unchecked", + "reserve_rehash", + "reset", + "reset_cache", + "resize", + "resolve", + "resolve_pending", + "resolve_socket_addr", + "resource_reference", + "response", + "result", + "retain", + "retain_mut", + "reverse", + "reverse_inner", + "rfc", + "rfind_raw", + "rfind_raw_avx2", + "rnglists", + "round", + "rt", + "run", + "run_with_cstr_allocating", + "runnable", + "rust_begin_unwind", + "rust_eh_personality", + "rust_oom", + "rust_panic", + "rust_panic_with_hook", + "rustc_demangle", + "rustix", + "rwlock", + "ryu", + "s_infotype.0", + "s_lock", + "sanitize_cookie_path", + "saturating_duration_since", + "sb", + "sc_spec_vals", + "scan_v4", + "scheme", + "scoped", + "scopeguard", + "seal", + "sealed", + "search", + "search_half", + "search_imp", + "search_nofail", + "search_slots", + "search_slots_imp", + "search_slots_nofail", + "search_symtab", + "searcher", + "searcher_kind_avx2", + "searcher_kind_empty", + "searcher_kind_one_byte", + "searcher_kind_sse2", + "searcher_kind_two_way", + "searcher_kind_two_way_with_prefilter", + "section", + "seek", + "seek_cb", + "select", + "selected.2", + "send", + "send_async_inner", + "send_callback", + "send_message", + "sendf", + "sentinel_for", + "ser", + "serde", + "serde_json", + "serialize", + "serialize_entry", + "serialize_str", + "service", + "service_data", + "session_after_frame_sent1", + "session_after_frame_sent2", + "session_call_error_callback", + "session_close_stream_on_goaway", + "session_headers_add_pad", + "session_inbound_frame_reset", + "session_new", + "session_ob_data_push", + "session_ob_data_remove.part.0", + "session_process_headers_frame", + "set_anchored_start_state", + "set_body", + "set_ccc_from_trie_if_not_already_set", + "set_config", + "set_current", + "set_extra", + "set_flags", + "set_hour_24", + "set_interest", + "set_local_ip.isra.0", + "set_lookbehind_from_start", + "set_matches", + "set_max_connects", + "set_max_host_connections", + "set_max_total_connections", + "set_minute", + "set_name", + "set_nonblocking", + "set_offset_hour", + "set_offset_minute_signed", + "set_opt", + "set_output_capture", + "set_range", + "set_span", + "set_transition", + "setopt", + "setopt_cptr", + "setopt_long", + "setopt_off_t", + "setopt_path", + "setup_range", + "sf_parser_dict", + "sf_parser_init", + "sf_parser_inner_list", + "sf_parser_param", + "sfparse", + "sh_freeentry", + "sha2", + "sha256", + "shallow_clone_vec", + "share", + "shared", + "shared_clone", + "shared_drop", + "shared_is_unique", + "shared_to_mut", + "shared_to_mut_impl", + "shared_to_vec", + "shared_to_vec_impl", + "shared_v_clone", + "shared_v_drop", + "shared_v_is_unique", + "shared_v_to_mut", + "shared_v_to_vec", + "shift_jis", + "show_resolve_info", + "shrink_to_fit", + "shuffle", + "shuffle_states", + "signal", + "signal_handler", + "signature", + "simd_contains", + "single_byte", + "sip", + "size_hint", + "skip_attributes", + "skip_empty_utf8_splits_overlapping", + "skip_splits_fwd", + "skip_splits_rev", + "skip_to_escape_slow", + "skipping_printing", + "slab", + "sleep", + "slice", + "slice_contains", + "slice_end_index_len_fail", + "slice_end_index_overflow_fail", + "slice_error_fail", + "slice_error_fail_rt", + "slice_index_order_fail", + "slice_start_index_len_fail", + "slice_start_index_overflow_fail", + "slist", + "sluice", + "small_c_string", + "small_probe_read", + "small_sort_general", + "small_sort_general_with_scratch", + "smallsort", + "smallvec", + "socket", + "socket2", + "socket_addr", + "socketpair", + "socks", + "socks_cf_adjust_pollset", + "socks_cf_get_host", + "socks_proxy_cf_close", + "socks_proxy_cf_connect", + "socks_proxy_cf_destroy", + "sort", + "sort4_stable", + "sort8_stable", + "source", + "sources", + "span", + "sparse_set", + "spawn", + "spawn_more_threads", + "spawn_unchecked", + "spawn_unchecked_", + "spdx", + "spec_extend", + "spec_from_elem", + "spec_from_iter", + "spec_from_iter_nested", + "spec_new_impl", + "spec_vals", + "spec_write_fmt", + "specialize_err", + "specialized_div_rem", + "specs", + "speedcheck", + "spinlock", + "spinning_top", + "splay", + "splice", + "split", + "split_leaf_data", + "split_off", + "split_once", + "split_prefix", + "split_to", + "sqrt_approx", + "sse2", + "ssl", + "ssl_buffer.0", + "ssl_cert_type", + "ssl_cf_adjust_pollset", + "ssl_cf_close", + "ssl_cf_cntrl", + "ssl_cf_connect", + "ssl_cf_data_pending", + "ssl_cf_destroy", + "ssl_cf_query", + "ssl_cf_recv", + "ssl_cf_send", + "ssl_cf_shutdown", + "ssl_cipher_list", + "ssl_configure", + "ssl_ctx_cb", + "ssl_key_type", + "ssl_ui_reader", + "ssl_ui_writer", + "stable", + "stack_overflow", + "stack_push", + "start", + "start_custom_arg", + "start_custom_group", + "start_occurrence_of_external", + "start_req", + "start_state", + "start_state_forward", + "starts_with_windows_drive_letter_segment", + "stash", + "stat", + "state", + "state_ptr", + "static_clone", + "static_drop", + "static_in", + "static_is_unique", + "static_table", + "static_to_mut", + "static_to_vec", + "status", + "status_code", + "std_detect", + "stderr", + "stdin", + "stdio", + "stdout", + "steal", + "step", + "stopat", + "str", + "str_index_overflow_fail", + "strategy", + "strcase", + "strdup", + "stream", + "stream_less", + "stream_obq_remove", + "strerror", + "string", + "strip", + "strip_prefix", + "strsim", + "strtok", + "strtoofft", + "strum", + "style", + "styled_str", + "stylize_arg_suffix", + "stylized", + "sub_timespec", + "subcommand", + "subcommand_conflict", + "subcommands", + "subscriber", + "subtle", + "suffixes", + "suggestions", + "supported_protocols", + "surf", + "swap", + "symbolic_name_normalize", + "symbolize", + "symmetric_difference", + "sync", + "syntax", + "sys", + "sys_common", + "take_body", + "take_box", + "task", + "task_id", + "task_local", + "task_locals_wrapper", + "tcp", + "tcpnodelay", + "teddy", + "textwrap", + "thompson", + "thread", + "thread_local", + "thread_main_loop", + "thread_name_string", + "thread_start", + "threading", + "tick", + "time", + "time2str", + "time_core", + "timediff", + "timeout", + "timer_after", + "timeval", + "tinystr", + "to_ascii", + "to_bg_str", + "to_builder", + "to_curl_string", + "to_fg_str", + "to_header_values", + "to_long", + "to_lower", + "to_lowercase", + "to_offset_raw", + "to_owned", + "to_red", + "to_short", + "to_socket_addrs", + "to_str", + "to_string", + "to_string_lossy", + "to_value", + "to_vec", + "to_writer", + "token", + "tolowermap", + "too_few_values", + "too_many_values", + "tool", + "touppermap", + "trace", + "trace_fn", + "tracing", + "tracing_core", + "tracing_futures", + "trailers", + "traits", + "transfer", + "translate", + "trc_infof", + "trhash", + "trhash_compare", + "trhash_dtor", + "trie", + "trigger", + "trim_end", + "trim_end_matches", + "trim_matches", + "trim_start_matches", + "truncate", + "trustier", + "try", + "try_allocate_in", + "try_case_fold_simple", + "try_close", + "try_demangle", + "try_entry2", + "try_find", + "try_find_fwd", + "try_find_overlapping", + "try_find_overlapping_fwd", + "try_fold", + "try_from", + "try_get_one", + "try_get_typed", + "try_grow", + "try_insert_entry", + "try_is_word_character", + "try_join", + "try_lock", + "try_parse_uint", + "try_recv", + "try_remove_one", + "try_reserve", + "try_reserve_one", + "try_search", + "try_search_slots", + "try_search_slots_imp", + "try_set_output_capture", + "try_statx", + "try_wake_receiver_if_pending", + "try_which_overlapping_matches", + "try_with_capacity", + "tunnel_recv_callback", + "tunnel_send_callback", + "tv_zero.0", + "tv_zero.1", + "twoway", + "type_id", + "tz", + "u128", + "u128_div_rem", + "u16", + "u32", + "u64", + "u8", + "udata_value", + "udp", + "unbounded", + "unclosed_class_error", + "unexpected", + "unicode", + "unicode_data", + "union", + "unique_thread_exit", + "unit", + "unit_variant", + "unix", + "unknown_argument", + "unknown_variant", + "unlock", + "unlock_unchecked", + "unnecessary_double_dash", + "unpark", + "unparker", + "unrecognized_subcommand", + "unroll_arg_requires", + "unroll_args_in_group", + "unstable", + "unsupported_anchored", + "unwind_safe", + "unwrap", + "unwrap_class_bytes", + "unwrap_expr", + "unwrap_failed", + "up_free", + "update", + "update_local_initial_window_size_func", + "update_remote_initial_window_size_func", + "update_waker", + "upgrade", + "upper_digits", + "uppercase", + "uri", + "uri_to_string", + "url", + "url_match_conn", + "url_match_result", + "urlapi", + "urlencode_str", + "usage", + "username", + "usize", + "utc_offset", + "utf16_iter", + "utf8", + "utf8_decode", + "utf8_iter", + "utf8_valid_up_to", + "utf_16", + "utf_8", + "util", + "utils", + "uts46", + "uuid", + "v0", + "v1_3", + "v1_4", + "v1_5", + "validate", + "validate_bom_link", + "validate_component_bom_refs", + "validate_cpe", + "validate_hash_value", + "validate_mime_type", + "validate_normalized_string", + "validate_purl", + "validate_reference_uri", + "validate_services", + "validate_spdx_expression", + "validate_spdx_identifier", + "validate_version", + "validation", + "validations", + "validator", + "value", + "value_bag", + "value_parser", + "value_result", + "value_validation", + "variant", + "variant_seed", + "vauth", + "vec", + "vec_deque", + "verify", + "version", + "version_info", + "visit", + "visit_borrowed_str", + "visit_byte_buf", + "visit_bytes", + "visit_class_set_binary_op_in", + "visit_class_set_binary_op_post", + "visit_class_set_binary_op_pre", + "visit_class_set_item_post", + "visit_class_set_item_pre", + "visit_enum", + "visit_map", + "visit_newtype_struct", + "visit_pair", + "visit_post", + "visit_pre", + "visit_seq", + "visit_some", + "visit_str", + "visitor", + "volume", + "vquic", + "vtls", + "vulnerability", + "vulnerability_analysis", + "vulnerability_credits", + "vulnerability_rating", + "vulnerability_reference", + "vulnerability_source", + "vulnerability_target", + "wait", + "wait_for_local_executor_completion", + "wait_group", + "wait_internal", + "wait_lock", + "wait_timeout", + "wake", + "wake_by_ref", + "wake_writer_or_readers", + "waker_fn", + "warnless", + "wb", + "weak", + "week", + "weekday", + "weeks_in_year", + "well_known", + "which_overlapping_imp", + "which_overlapping_matches", + "white_space", + "with", + "with_capacity", + "with_capacity_in", + "with_cmd", + "with_content", + "with_global", + "with_http_client_internal", + "with_namespace", + "with_pair_impl", + "with_query_and_fragment", + "with_subpath", + "with_thread_name_fn", + "workflow", + "workspace", + "wrapper", + "wrappers", + "write", + "write_about", + "write_after_help", + "write_all", + "write_all_args", + "write_all_cold", + "write_all_vectored", + "write_arg_usage", + "write_args", + "write_before_help", + "write_cb", + "write_char", + "write_char_escape", + "write_code", + "write_cold", + "write_contended", + "write_flat_subcommands", + "write_fmt", + "write_formatted_parts", + "write_help", + "write_help_err", + "write_ipv6", + "write_mantissa_long", + "write_prefix", + "write_slice", + "write_str", + "write_subcommand_usage", + "write_subcommands", + "write_templated_help", + "write_usage_no_title", + "write_values_list", + "write_vectored", + "writeable", + "wrong_number_of_values", + "ws", + "ws_setup_conn", + "xdigits_l.1", + "xdigits_u.0", + "xfer_send", + "xml", + "xsave", + "year", + "yield_now", + "yoke", + "zalloc_cb", + "zfree_cb" + ] +} \ No newline at end of file diff --git a/scanpipe/tests/pipes/test_d2d.py b/scanpipe/tests/pipes/test_d2d.py index a0a88780bb..1f3af7b072 100644 --- a/scanpipe/tests/pipes/test_d2d.py +++ b/scanpipe/tests/pipes/test_d2d.py @@ -1529,3 +1529,39 @@ def test_scanpipe_pipes_d2d_map_go_paths(self): project=self.project1, status="requires-review" ).count(), ) + + def test_scanpipe_pipes_d2d_map_rust_paths(self): + input_dir = self.project1.input_path + input_resources = [ + self.data / "d2d-rust/to-trustier-binary-linux.tar.gz", + self.data / "d2d-rust/from-trustier-source.tar.gz", + ] + copy_inputs(input_resources, input_dir) + self.from_files, self.to_files = d2d.get_inputs(self.project1) + inputs_with_codebase_path_destination = [ + (self.from_files, self.project1.codebase_path / d2d.FROM), + (self.to_files, self.project1.codebase_path / d2d.TO), + ] + for input_files, codebase_path in inputs_with_codebase_path_destination: + for input_file_path in input_files: + scancode.extract_archive(input_file_path, codebase_path) + + scancode.extract_archives( + self.project1.codebase_path, + recurse=True, + ) + pipes.collect_and_create_codebase_resources(self.project1) + buffer = io.StringIO() + d2d.map_rust_paths(project=self.project1, logger=buffer.write) + self.assertEqual( + 2, + CodebaseRelation.objects.filter( + project=self.project1, map_type="rust_symbols" + ).count(), + ) + self.assertEqual( + 0, + CodebaseResource.objects.filter( + project=self.project1, status="requires-review" + ).count(), + ) diff --git a/scanpipe/tests/pipes/test_symbolmap.py b/scanpipe/tests/pipes/test_symbolmap.py new file mode 100644 index 0000000000..3a7c3680f6 --- /dev/null +++ b/scanpipe/tests/pipes/test_symbolmap.py @@ -0,0 +1,198 @@ +# SPDX-License-Identifier: Apache-2.0 +# +# http://nexb.com and https://github.com/nexB/scancode.io +# The ScanCode.io software is licensed under the Apache License version 2.0. +# Data generated with ScanCode.io is provided as-is without warranties. +# ScanCode is a trademark of nexB Inc. +# +# You may not use this software except in compliance with the License. +# You may obtain a copy of the License at: http://apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software distributed +# under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +# CONDITIONS OF ANY KIND, either express or implied. See the License for the +# specific language governing permissions and limitations under the License. +# +# Data Generated with ScanCode.io is provided on an "AS IS" BASIS, WITHOUT WARRANTIES +# OR CONDITIONS OF ANY KIND, either express or implied. No content created from +# ScanCode.io should be considered or used as legal advice. Consult an Attorney +# for any legal advice. +# +# ScanCode.io is a free software code scanning tool from nexB Inc. and others. +# Visit https://github.com/nexB/scancode.io for support and download. + +import json +from pathlib import Path + +from django.test import TestCase + +from scanpipe.models import CodebaseRelation +from scanpipe.models import CodebaseResource +from scanpipe.models import Project +from scanpipe.pipes import flag +from scanpipe.pipes import symbolmap + + +class ScanPipeSymbolmapPipesTest(TestCase): + maxDiff = None + data = Path(__file__).parent.parent / "data" + + def get_binary_symbols(self): + binary_symbol_path = self.data / "d2d-rust/trustier-binary-symbols.json" + with open(binary_symbol_path) as res: + binary_symbols_data = json.load(res) + + return binary_symbols_data.get("rust_symbols") + + def test_match_source_symbols_to_binary_for_test_file(self): + # tree-sitter symbols from https://github.com/devops-kung-fu/trustier/blob/main/tests/cli.rs + rust_test_file_symbols = [ + "anyhow", + "Ok", + "Result", + "assert_cmd", + "Command", + "predicates", + "prelude", + "test", + "dies_no_args", + "cmd", + "Command", + "cargo_bin", + "cmd", + "predicate", + "str", + "contains", + "Ok", + ] + is_source_matched, _stats = symbolmap.match_source_symbols_to_binary( + rust_test_file_symbols, self.get_binary_symbols() + ) + self.assertFalse(is_source_matched) + + def test_match_source_symbols_to_binary_for_main_file(self): + # tree-sitter symbols from https://github.com/devops-kung-fu/trustier/blob/main/src/main.rs + rust_main_file_symbols = [ + "Args", + "Bom", + "Debug", + "Duration", + "FileOrStdin", + "FromStr", + "PackageUrl", + "Parser", + "Path", + "TrustyResponse", + "Vec", + "about", + "arg", + "args", + "async_std", + "block_on", + "body", + "bold", + "bom", + "clap_stdin", + "colored", + "command", + "component", + "create_dir_all", + "cyclonedx_bom", + "derive", + "error", + "fetch_purl_bodies", + "filter_purls", + "format", + "from_str", + "fs", + "get", + "header", + "is_file", + "main", + "models", + "name", + "new", + "packageurl", + "parse", + "parse_from_json_v1_5", + "path", + "process_sbom", + "purl", + "serde_json", + "sleep", + "str", + "surf", + "task", + "time", + "url", + "version", + "write", + ] + is_source_matched, _stats = symbolmap.match_source_symbols_to_binary( + rust_main_file_symbols, self.get_binary_symbols() + ) + self.assertTrue(is_source_matched) + + def test_match_source_paths_to_binary(self): + project1 = Project.objects.create(name="Analysis") + extra_data = {"source_symbols": ["test_symbol1", "test_symbol2"]} + CodebaseResource.objects.create( + project=project1, path="src/main.rs", extra_data=extra_data + ) + CodebaseResource.objects.create( + project=project1, path="src/models.rs", extra_data=extra_data + ) + binary_resource = CodebaseResource.objects.create( + project=project1, path="binary" + ) + items = symbolmap.match_source_paths_to_binary( + to_resource=binary_resource, + from_resources=CodebaseResource.objects.all().filter(path__endswith=".rs"), + binary_symbols=["test_symbol1", "test_symbol2"], + map_type="rust_symbols", + ) + self.assertFalse(any([True for item in items if isinstance(item, str)])) + self.assertTrue( + all( + [ + True + for _rel_key, relation in items + if isinstance(relation, CodebaseRelation) + ] + ) + ) + + def test_map_resources_with_symbols_source_to_binary(self): + project1 = Project.objects.create(name="Analysis") + extra_data = {"source_symbols": ["test_symbol1", "test_symbol2"]} + CodebaseResource.objects.create( + project=project1, path="src/main.rs", extra_data=extra_data + ) + CodebaseResource.objects.create( + project=project1, path="src/models.rs", extra_data=extra_data + ) + binary_resource = CodebaseResource.objects.create( + project=project1, path="binary" + ) + symbolmap.map_resources_with_symbols( + to_resource=binary_resource, + from_resources=CodebaseResource.objects.all().filter(path__endswith=".rs"), + binary_symbols=["test_symbol1", "test_symbol2"], + map_type="rust_symbols", + ) + self.assertNotEqual(binary_resource.status, flag.REQUIRES_REVIEW) + relations = CodebaseRelation.objects.all() + self.assertEqual(relations.count(), 2) + self.assertTrue( + all(True for relation in relations if relation.map_type == "rust_symbols") + ) + self.assertTrue( + all( + [ + True + for resource in CodebaseResource.objects.all().filter( + path__endswith=".rs" + ) + if resource.status == flag.MAPPED_BY_SYMBOL + ] + ) + ) diff --git a/scanpipe/tests/test_pipelines.py b/scanpipe/tests/test_pipelines.py index d4cd06ade2..bca1ec48f0 100644 --- a/scanpipe/tests/test_pipelines.py +++ b/scanpipe/tests/test_pipelines.py @@ -46,6 +46,7 @@ from scanpipe.pipelines import is_pipeline from scanpipe.pipelines import root_filesystem from scanpipe.pipelines import scan_single_package +from scanpipe.pipes import d2d from scanpipe.pipes import flag from scanpipe.pipes import output from scanpipe.pipes import scancode @@ -1493,7 +1494,14 @@ def test_scanpipe_deploy_to_develop_pipeline_extract_input_files_errors(self): pipeline_instance.get_inputs() with mock.patch("scanpipe.pipes.scancode.extract_archive") as extract_archive: extract_archive.return_value = {"path/to/resource": ["error1", "error2"]} - pipeline_instance.extract_inputs_to_codebase_directory() + inputs_with_codebase_path_destination = [ + (pipeline_instance.from_files, project1.codebase_path / d2d.FROM), + (pipeline_instance.to_files, project1.codebase_path / d2d.TO), + ] + + for input_files, codebase_path in inputs_with_codebase_path_destination: + for input_file_path in input_files: + pipeline_instance.extract_archive(input_file_path, codebase_path) projects_errors = project1.projectmessages.all() self.assertEqual(2, len(projects_errors)) diff --git a/setup.cfg b/setup.cfg index 534efcb2cd..751a619b2f 100644 --- a/setup.cfg +++ b/setup.cfg @@ -80,7 +80,8 @@ install_requires = fetchcode-container==1.2.3.210512; sys_platform == "linux" # Inspectors elf-inspector==0.0.1 - go-inspector==0.5.0 + go-inspector==0.5.0; sys_platform == "linux" + rust-inspector==0.1.0; sys_platform == "linux" python-inspector==0.12.1 source-inspector==0.5.1; sys_platform != "darwin" and platform_machine != "arm64" aboutcode-toolkit==11.0.0