From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from simark.ca by simark.ca with LMTP id MBWeJTgwRGocESAAWB0awg (envelope-from ) for ; Tue, 30 Jun 2026 17:08:08 -0400 Authentication-Results: simark.ca; dkim=pass (1024-bit key; unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256 header.s=mimecast20190719 header.b=hPFmJjaV; dkim-atps=neutral Received: by simark.ca (Postfix, from userid 112) id 89D621E098; Tue, 30 Jun 2026 17:08:08 -0400 (EDT) X-Spam-Checker-Version: SpamAssassin 4.0.1 (2024-03-25) on simark.ca X-Spam-Level: X-Spam-Status: No, score=-6.4 required=5.0 tests=ARC_SIGNED,ARC_VALID,BAYES_00, DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,MAILING_LIST_MULTI, RCVD_IN_DNSWL_MED autolearn=ham autolearn_force=no version=4.0.1 Received: from vm01.sourceware.org (vm01.sourceware.org [IPv6:2620:52:6:3111::32]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange x25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by simark.ca (Postfix) with ESMTPS id 058291E024 for ; Tue, 30 Jun 2026 17:08:06 -0400 (EDT) Received: from vm01.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 797F14BA2E33 for ; Tue, 30 Jun 2026 21:08:04 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 797F14BA2E33 Authentication-Results: sourceware.org; dkim=pass (1024-bit key, unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256 header.s=mimecast20190719 header.b=hPFmJjaV Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTP id 83CDF4BA2E2E for ; Tue, 30 Jun 2026 21:07:37 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 83CDF4BA2E2E Authentication-Results: sourceware.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 83CDF4BA2E2E Authentication-Results: sourceware.org; arc=none smtp.remote-ip=170.10.129.124 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1782853657; cv=none; b=k9Po0yzRsT6yp+mGt+jiPvOBQ+5lPrfcS9Jwdj635IcnD/g/j0SjzqnzW2iqRgZsdkLeLPVopjOVazF30Rekp+nUgD4yY78dNHq12x96zUmdHN47YrgBko2SX6OeVTp29OFJIuCSugEmdCIutoXw+Pd3qYKEt45PFDW7gj2mwNU= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1782853657; c=relaxed/simple; bh=2gpSqB9/LQlAdJWxQ50TtTZHiXVnT+s3tW4FU98Mu9M=; h=DKIM-Signature:Message-ID:Date:MIME-Version:Subject:To:From; b=kGeMDa8SUwuRQLMoHFRvqSZFCv0QbiUdHHd8gHoaHJ42fjUDp2RrxhUh8Q5Xkr8gULAQsJnn6ZmdNB4Ez9nKflimCu8HtWlUV5DUd3g9sGsE9ZV+6VmvfOyeWSL2TvpGZNzBH0TnSp2RUIZ6dUINcxHS0XeLx0ZdzRxS1ZIWR1E= ARC-Authentication-Results: i=1; sourceware.org; dkim=pass (1024-bit key, unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256 header.s=mimecast20190719 header.b=hPFmJjaV DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 83CDF4BA2E2E DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1782853657; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=FVK58QOM/G7ecTc91g63QCm/1JoH/Ulc5TqVJ3/w8Tc=; b=hPFmJjaV8u+B1biH2ZVeofsspnoLr59Uc2shtKEZsvJjZ7i7nQxK+bmCUCaWLSCMTDWKeD DKCbv5RmA4Bqdox8uRzA2BiPb6GE5f+IFMZZOCRjFcs/IJdxEJP+ZxuZLj5fqvmWFeuypH GLNTfQ7N95mznbUG5mIJN3A8Zn5z6Po= Received: from mail-vs1-f71.google.com (mail-vs1-f71.google.com [209.85.217.71]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-581-k2zYcG3WMDKvVrQeo2nSbw-1; Tue, 30 Jun 2026 17:07:35 -0400 X-MC-Unique: k2zYcG3WMDKvVrQeo2nSbw-1 X-Mimecast-MFC-AGG-ID: k2zYcG3WMDKvVrQeo2nSbw_1782853655 Received: by mail-vs1-f71.google.com with SMTP id ada2fe7eead31-6798c46f723so3511594137.1 for ; Tue, 30 Jun 2026 14:07:35 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1782853655; x=1783458455; h=content-transfer-encoding:in-reply-to:from:content-language :references:to:subject:user-agent:mime-version:date:message-id :x-gm-gg:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=FVK58QOM/G7ecTc91g63QCm/1JoH/Ulc5TqVJ3/w8Tc=; b=QGIa3W2afo/R5pVDkNmQ0iThz66irq5NjrnWf9u70d3V0AZC0/wFjP5gOmVPDM3psB QwWaxaY5OTPU1UPRBIAXgKB835MRPTGeS21Eyqd+cHP7SUnT0HMAHfZvgwtPmhy+Mxv3 dByIztaF6WsHHoOUdQ3EMFe0r6OuA9P11R/uCnkHvd63wvKVUavBXWvEY1BdNGiskz1S pIKWOBGyVnlDIVjgA/GN/7sH5n8NljfdQJ9YulVLArJjuT7nbFbszMEznPXi6s++DJe+ AbnzsHkQAzaW87hkoBNnV3cuRXNEnp/TfMkjLGDqGqt9NCvES8MqUrdIEqDgc53AgoEN 2YTg== X-Forwarded-Encrypted: i=1; AHgh+RqBSYCe2AIj1G8OFgrTzTFxIkZXUNFCwSgavLjO2OGQtIzNBa9tqU4wTVB4zYU9rMec0z87CkmYyZq/Yw==@sourceware.org X-Gm-Message-State: AOJu0YxZcqKzyDUEBfcI1PZkHqWqXfDz6tAeIJdVVKpsGbzsidy9qk2W Ehokthg3cchf7Lt2VSfLsyNSUhGwOV5S62XzZ/ZatRroygBClMe3ujOopVU42Hse/Bi1tkxDH6E jvm7wkwBB/tPH1r3eU4V3nzAxJYwLRB5HvKf0EXnF9Lv3/IZjpe/7n33ns9lDhuw= X-Gm-Gg: AfdE7cn4qQIv3mxx1mlpkf/gqzwn4jINZyxlg98TqWhh/vyGHgIhkqJUG72OfcJ7wE9 IJEkKZl+Ecp3GO5CrkSzkp4dDSDCZFUGc0fwlctM1CiFBI16XyH2fpBfpmIxH1N9SfUQV4U9+pi /C3vDksbb2rzIg8Hoj+XwHXPxh/FiJq0r8jCk5UV0LTRbAFAG/tpusnJPMM2YkjqMrqRltGLfmh TLEzjkSvxL45kORnu7g66QDBbtIqe7OuIMzxJoWOH9tsZ94sn32zeIYtMn4eWrecdFKpqqHO6T/ mPWlC/4IOUlPBCfmCh5g6ygnJa8YDmaH+h05nGIfjuOanhxxzDKwZwBgEn1k+Bffki5lZPjCMQE OHc+SMXHTBwKntI2g0xpr X-Received: by 2002:a05:6102:5542:b0:6d9:a0bb:9095 with SMTP id ada2fe7eead31-73cb8afaf86mr1053490137.13.1782853654853; Tue, 30 Jun 2026 14:07:34 -0700 (PDT) X-Received: by 2002:a05:6102:5542:b0:6d9:a0bb:9095 with SMTP id ada2fe7eead31-73cb8afaf86mr1053480137.13.1782853654273; Tue, 30 Jun 2026 14:07:34 -0700 (PDT) Received: from ?IPV6:2804:14d:8084:993e::75d? ([2804:14d:8084:993e::75d]) by smtp.gmail.com with ESMTPSA id ada2fe7eead31-73a8433bbabsm1784573137.11.2026.06.30.14.07.32 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Tue, 30 Jun 2026 14:07:33 -0700 (PDT) Message-ID: <07986ffa-b589-4661-a108-d6b27cf1a198@redhat.com> Date: Tue, 30 Jun 2026 18:07:30 -0300 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH] gdb: replace alloca with gdb::char_vector in remote-fileio.c To: Luis Machado , gdb-patches@sourceware.org References: <20260630095238.1700797-1-luis.machado@amd.com> From: Guinevere Larsen In-Reply-To: <20260630095238.1700797-1-luis.machado@amd.com> X-Mimecast-Spam-Score: 0 X-Mimecast-MFC-PROC-ID: LWLHJGi9oGnCYP7_hx_ZVgh9PvUIx1eoOXw34kPQPic_1782853655 X-Mimecast-Originator: redhat.com Content-Language: en-US Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 7bit X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gdb-patches-bounces~public-inbox=simark.ca@sourceware.org On 6/30/26 6:52 AM, Luis Machado wrote: > remote_fileio_extract_ptr_w_len parsed a debuggee-controlled 64-bit > length, narrowed it to int with no bounds check, and the value flowed > directly into alloca() across RSP File-I/O handlers (Fopen, Frename, > Funlink, Fstat, Fsystem). A malicious inferior or remote > stub could send a crafted packet with a path-length near INT_MAX, > displacing the stack pointer by ~2 GiB and potentially crashing the debugger. > > remote_fileio_extract_ptr_w_len now rejects negative lengths, zero, and > values above PATH_MAX before the int cast. An allow_zero_length flag > lets the Fsystem handler opt in to the zero-length sentinel that signals a > NULL cmdline query. All other handlers use the default and are protected > without any per-call checks. All alloca(length) calls have been replaced > with gdb::char_vector. > > Add a selftest that exercises various problematic cases. > > Signed-off-by: Luis Machado Hi Luis! I took a look at this and everything looks good! And I'm always happy to see fewer uses of alloca Reviewed-By: Guinevere Larsen -- Cheers, Guinevere Larsen it/its she/her (deprecated) > --- > gdb/remote-fileio.c | 150 +++++++++++++++++++++++++++++++++++--------- > 1 file changed, 119 insertions(+), 31 deletions(-) > > diff --git a/gdb/remote-fileio.c b/gdb/remote-fileio.c > index ef608cabfab..50c7869a1a5 100644 > --- a/gdb/remote-fileio.c > +++ b/gdb/remote-fileio.c > @@ -31,8 +31,11 @@ > #include "target.h" > #include "filenames.h" > #include "gdbsupport/filestuff.h" > +#include "gdbsupport/byte-vector.h" > +#include "gdbsupport/selftest.h" > > #include > +#include > #include "gdbsupport/gdb_sys_time.h" > #ifdef __CYGWIN__ > #include > @@ -194,7 +197,8 @@ remote_fileio_extract_int (char **buf, long *retint) > } > > static int > -remote_fileio_extract_ptr_w_len (char **buf, CORE_ADDR *ptrval, int *length) > +remote_fileio_extract_ptr_w_len (char **buf, CORE_ADDR *ptrval, int *length, > + bool allow_zero_length = false) > { > char *c; > LONGEST retlong; > @@ -211,6 +215,11 @@ remote_fileio_extract_ptr_w_len (char **buf, CORE_ADDR *ptrval, int *length) > *buf = c; > if (remote_fileio_extract_long (buf, &retlong)) > return -1; > + /* Reject negative lengths, zero (unless the caller permits it for the > + Fsystem NULL-cmdline sentinel), and lengths above PATH_MAX to prevent > + out-of-bounds memory reads or oversized heap allocations. */ > + if (retlong < 0 || (!allow_zero_length && retlong == 0) || retlong > PATH_MAX) > + return -1; > *length = (int) retlong; > return 0; > } > @@ -305,7 +314,6 @@ remote_fileio_func_open (remote_target *remote, char *buf) > long num; > int flags, fd; > mode_t mode; > - char *pathname; > struct stat st; > > /* 1. Parameter: Ptr to pathname / length incl. trailing zero. */ > @@ -339,8 +347,8 @@ remote_fileio_func_open (remote_target *remote, char *buf) > } > > /* Request pathname. */ > - pathname = (char *) alloca (length); > - if (target_read_memory (ptrval, (gdb_byte *) pathname, length) != 0) > + gdb::char_vector pathname (length); > + if (target_read_memory (ptrval, (gdb_byte *) pathname.data (), length) != 0) > { > remote_fileio_ioerror (remote); > return; > @@ -349,7 +357,7 @@ remote_fileio_func_open (remote_target *remote, char *buf) > /* Check if pathname exists and is not a regular file or directory. If so, > return an appropriate error code. Same for trying to open directories > for writing. */ > - if (!stat (pathname, &st)) > + if (!stat (pathname.data (), &st)) > { > if (!S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode)) > { > @@ -364,7 +372,7 @@ remote_fileio_func_open (remote_target *remote, char *buf) > } > } > > - fd = gdb_open_cloexec (pathname, flags, mode).release (); > + fd = gdb_open_cloexec (pathname.data (), flags, mode).release (); > if (fd < 0) > { > remote_fileio_return_errno (remote, -1); > @@ -659,7 +667,6 @@ remote_fileio_func_rename (remote_target *remote, char *buf) > { > CORE_ADDR old_ptr, new_ptr; > int old_len, new_len; > - char *oldpath, *newpath; > int ret, of, nf; > struct stat ost, nst; > > @@ -678,24 +685,24 @@ remote_fileio_func_rename (remote_target *remote, char *buf) > } > > /* Request oldpath using 'm' packet */ > - oldpath = (char *) alloca (old_len); > - if (target_read_memory (old_ptr, (gdb_byte *) oldpath, old_len) != 0) > + gdb::char_vector oldpath (old_len); > + if (target_read_memory (old_ptr, (gdb_byte *) oldpath.data (), old_len) != 0) > { > remote_fileio_ioerror (remote); > return; > } > > /* Request newpath using 'm' packet */ > - newpath = (char *) alloca (new_len); > - if (target_read_memory (new_ptr, (gdb_byte *) newpath, new_len) != 0) > + gdb::char_vector newpath (new_len); > + if (target_read_memory (new_ptr, (gdb_byte *) newpath.data (), new_len) != 0) > { > remote_fileio_ioerror (remote); > return; > } > > /* Only operate on regular files and directories. */ > - of = stat (oldpath, &ost); > - nf = stat (newpath, &nst); > + of = stat (oldpath.data (), &ost); > + nf = stat (newpath.data (), &nst); > if ((!of && !S_ISREG (ost.st_mode) && !S_ISDIR (ost.st_mode)) > || (!nf && !S_ISREG (nst.st_mode) && !S_ISDIR (nst.st_mode))) > { > @@ -703,7 +710,7 @@ remote_fileio_func_rename (remote_target *remote, char *buf) > return; > } > > - ret = rename (oldpath, newpath); > + ret = rename (oldpath.data (), newpath.data ()); > > if (ret == -1) > { > @@ -726,10 +733,10 @@ remote_fileio_func_rename (remote_target *remote, char *buf) > char newfullpath[PATH_MAX]; > int len; > > - cygwin_conv_path (CCP_WIN_A_TO_POSIX, oldpath, oldfullpath, > - PATH_MAX); > - cygwin_conv_path (CCP_WIN_A_TO_POSIX, newpath, newfullpath, > - PATH_MAX); > + cygwin_conv_path (CCP_WIN_A_TO_POSIX, oldpath.data (), > + oldfullpath, PATH_MAX); > + cygwin_conv_path (CCP_WIN_A_TO_POSIX, newpath.data (), > + newfullpath, PATH_MAX); > len = strlen (oldfullpath); > if (IS_DIR_SEPARATOR (newfullpath[len]) > && !filename_ncmp (oldfullpath, newfullpath, len)) > @@ -752,7 +759,6 @@ remote_fileio_func_unlink (remote_target *remote, char *buf) > { > CORE_ADDR ptrval; > int length; > - char *pathname; > int ret; > struct stat st; > > @@ -763,8 +769,8 @@ remote_fileio_func_unlink (remote_target *remote, char *buf) > return; > } > /* Request pathname using 'm' packet */ > - pathname = (char *) alloca (length); > - if (target_read_memory (ptrval, (gdb_byte *) pathname, length) != 0) > + gdb::char_vector pathname (length); > + if (target_read_memory (ptrval, (gdb_byte *) pathname.data (), length) != 0) > { > remote_fileio_ioerror (remote); > return; > @@ -772,13 +778,13 @@ remote_fileio_func_unlink (remote_target *remote, char *buf) > > /* Only operate on regular files (and directories, which allows to return > the correct return code). */ > - if (!stat (pathname, &st) && !S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode)) > + if (!stat (pathname.data (), &st) && !S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode)) > { > remote_fileio_reply (remote, -1, FILEIO_ENODEV); > return; > } > > - ret = unlink (pathname); > + ret = unlink (pathname.data ()); > > if (ret == -1) > remote_fileio_return_errno (remote, -1); > @@ -791,7 +797,6 @@ remote_fileio_func_stat (remote_target *remote, char *buf) > { > CORE_ADDR statptr, nameptr; > int ret, namelength; > - char *pathname; > LONGEST lnum; > struct stat st; > struct fio_stat fst; > @@ -812,14 +817,14 @@ remote_fileio_func_stat (remote_target *remote, char *buf) > statptr = (CORE_ADDR) lnum; > > /* Request pathname using 'm' packet */ > - pathname = (char *) alloca (namelength); > - if (target_read_memory (nameptr, (gdb_byte *) pathname, namelength) != 0) > + gdb::char_vector pathname (namelength); > + if (target_read_memory (nameptr, (gdb_byte *) pathname.data (), namelength) != 0) > { > remote_fileio_ioerror (remote); > return; > } > > - ret = stat (pathname, &st); > + ret = stat (pathname.data (), &st); > > if (ret == -1) > { > @@ -997,24 +1002,28 @@ remote_fileio_func_system (remote_target *remote, char *buf) > { > CORE_ADDR ptrval; > int ret, length; > - char *cmdline = NULL; > > /* Parameter: Ptr to commandline / length incl. trailing zero */ > - if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length)) > + if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length, true)) > { > remote_fileio_ioerror (remote); > return; > } > > + gdb::char_vector cmdline_buf; > + const char *cmdline = nullptr; > + > if (length) > { > /* Request commandline using 'm' packet */ > - cmdline = (char *) alloca (length); > - if (target_read_memory (ptrval, (gdb_byte *) cmdline, length) != 0) > + cmdline_buf.resize (length); > + if (target_read_memory (ptrval, (gdb_byte *) cmdline_buf.data (), > + length) != 0) > { > remote_fileio_ioerror (remote); > return; > } > + cmdline = cmdline_buf.data (); > } > > /* Check if system(3) has been explicitly allowed using the > @@ -1244,6 +1253,81 @@ show_system_call_allowed (const char *args, int from_tty) > remote_fio_system_call_allowed ? "" : "not "); > } > > +#if GDB_SELF_TEST > + > +namespace selftests { > + > +/* Verify that remote_fileio_extract_ptr_w_len rejects lengths that are > + negative or exceed PATH_MAX, and accepts boundary values. The packet > + buffer format is "ptr/len[,...]" with both fields as hex integers. */ > + > +static void > +test_remote_fileio_extract_ptr_w_len () > +{ > + CORE_ADDR ptrval; > + int length; > + > + /* Build a writable "ptr/len" buffer and parse it, with and without > + the Fsystem zero-length allowance. */ > + auto parse = [&] (const char *s) -> int > + { > + std::string buf (s); > + char *p = buf.data (); > + return remote_fileio_extract_ptr_w_len (&p, &ptrval, &length); > + }; > + auto parse_allow_zero = [&] (const char *s) -> int > + { > + std::string buf (s); > + char *p = buf.data (); > + return remote_fileio_extract_ptr_w_len (&p, &ptrval, &length, true); > + }; > + > + /* Valid: length 1 (minimum positive). Verify both fields are parsed. */ > + SELF_CHECK (parse ("deadbeef/1") == 0); > + SELF_CHECK (ptrval == 0xdeadbeef); > + SELF_CHECK (length == 1); > + > + /* Valid: packet with trailing fields. */ > + SELF_CHECK (parse ("deadbeef/4,0,1a4") == 0); > + SELF_CHECK (ptrval == 0xdeadbeef); > + SELF_CHECK (length == 4); > + > + /* Valid: length 0 with allow_zero_length (Fsystem). */ > + SELF_CHECK (parse_allow_zero ("0/0") == 0); > + SELF_CHECK (length == 0); > + > + /* Invalid: length 0 without allow_zero_length (pathname handlers). */ > + SELF_CHECK (parse ("0/0") == -1); > + > + /* Valid: length exactly PATH_MAX. */ > + { > + char hex[32]; > + xsnprintf (hex, sizeof (hex), "1/%x", PATH_MAX); > + SELF_CHECK (parse (hex) == 0); > + SELF_CHECK (length == PATH_MAX); > + } > + > + /* Invalid: length PATH_MAX + 1. */ > + { > + char hex[32]; > + xsnprintf (hex, sizeof (hex), "1/%x", PATH_MAX + 1); > + SELF_CHECK (parse (hex) == -1); > + } > + > + /* Invalid: value well above PATH_MAX (INT_MAX as a stress case). */ > + SELF_CHECK (parse ("1/7fffffff") == -1); > + > + /* Invalid: negative length. */ > + SELF_CHECK (parse ("1/-1") == -1); > + > + /* Invalid: missing '/' separator. */ > + SELF_CHECK (parse ("deadbeef") == -1); > +} > + > +} /* namespace selftests */ > + > +#endif /* GDB_SELF_TEST */ > + > void > initialize_remote_fileio (struct cmd_list_element **remote_set_cmdlist, > struct cmd_list_element **remote_show_cmdlist) > @@ -1256,4 +1340,8 @@ initialize_remote_fileio (struct cmd_list_element **remote_set_cmdlist, > show_system_call_allowed, > _("Show if the host system(3) call is allowed for the target."), > remote_show_cmdlist); > +#if GDB_SELF_TEST > + selftests::register_test ("remote_fileio_extract_ptr_w_len", > + selftests::test_remote_fileio_extract_ptr_w_len); > +#endif > }