C++ VSCode Ubuntu Terminal intercepting command line responses

Question

I have a program in Linux C++ in VSCode that I am trying to debug. I am using Boost process::ipstream to send a command line command like "ip -a", then try to use std::getLine() to read the iostream and process the response which is a multi-line listing of all network interface information. I have tried quite a few different methods but no matter what I do as soon as I send out the command I see the response in the VSCode Terminal and my coded reader logic gets nothing. I have read up on VSCode terminal settings to see about not having it parse the responses but have found no settings that work in VSCode's settings.json file.

I feel like the core issue is VSCode stealing the responses in terminal so I cannot get them in my code. Has anybody seen anything like this and how can I disable Terminal from parsing responses to the CLI commands I am sending?

For the record, what I am really trying to do is run the speedtest cli application form my C++ code and parse the responses there, but I thought I'd try something simple first so was just trying to be able to parse results from the "ip -a" command.

I know, code is good. This is the latest thing I am trying to do (in desperation I tried something from ChatGPT):

    io_service io;
    ip::tcp::resolver resolver(io);
    boost::process::ipstream output;

    // Set up the command
    std::string command = "ip -a";

    // Set a timeout (in seconds) for the operation
    int timeout = 5;

    // Start the child process to run the ping command
    boost::process::child c(command, boost::process::std_out > output, io);

// As soon as I step over the above line I see the response in VSCode Terminal view

    // Wait for the process to exit or timeout
    if (c.wait_for(std::chrono::seconds(timeout)) == 0) {
        // Process completed within the timeout

        // Read and parse the output of the ping command
        std::string line;
        while (std::getline(output, line)) {
            // Parse and process the ping output here
            std::cout << "GLH: " << line << std::endl;
        }
    } else {
        // Process didn't complete within the timeout
// I hit this timeout every time
        std::cout << "Timeout occurred." << std::endl;
    }

Thanks

Answer 1

I can not reproduce the issue. First of all, ip -a seems to be an invalid command. It is possible that the output appears in the terminal because it is error information, going to stderr instead?

Here's my simplified approach:

Live On Compiler Explorer

#include <boost/asio.hpp>
#include <boost/process.hpp>
#include <iomanip>
#include <iostream>
using namespace std::chrono_literals;
namespace bp = boost::process;

int main() {
    boost::asio::io_context  io;
    std::future<std::string> output;

    bp::child c("ip a", bp::std_out > output, io);
    io.run_for(5s);

    std::istringstream iss(output.get());
    for (std::string line; std::getline(iss, line);) {
        std::cout << "GLH: " << quoted(line) << std::endl;
    }
}

It prints:

GLH: "1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000"
GLH: "    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00"
GLH: "    inet 127.0.0.1/8 scope host lo"
GLH: "       valid_lft forever preferred_lft forever"
GLH: "    inet6 ::1/128 scope host "
GLH: "       valid_lft forever preferred_lft forever"
GLH: "2: enp4s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000"
GLH: "    link/ether 90:2b:34:37:2d:9a brd ff:ff:ff:ff:ff:ff"
GLH: "    inet 192.168.xx.xxx/24 brd 192.168.50.255 scope global dynamic noprefixroute enp4s0"
GLH: "       valid_lft 85841sec preferred_lft 85841sec"
GLH: "    inet6 fe80::def5:7afe:7fd8:fd8b/64 scope link noprefixroute "
GLH: "       valid_lft forever preferred_lft forever"
GLH: "3: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default "
GLH: "    link/ether 02:42:92:1e:41:c3 brd ff:ff:ff:ff:ff:ff"
GLH: "    inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0"
GLH: "       valid_lft forever preferred_lft forever"

I'd consider parsing immediately, e.g.:

// #define BOOST_SPIRIT_X3_DEBUG 1
#include <boost/asio.hpp>
#include <boost/fusion/adapted/struct.hpp>
#include <boost/process.hpp>
#include <boost/spirit/home/x3.hpp>
#include <iomanip>
#include <iostream>
using namespace std::chrono_literals;
namespace bp = boost::process;

namespace NIC {
    using boost::asio::ip::address_v4;

    struct Entry {
        std::string iface;
        address_v4  net;
        unsigned    mask_number;
    };
} // namespace NIC

BOOST_FUSION_ADAPT_STRUCT(NIC::Entry, iface, net, mask_number)

namespace NIC {

    std::vector<Entry> parse(std::string_view sv) {
        using namespace boost::spirit::x3;
        auto to_address = [](auto& ctx) {
            auto raw  = _attr(ctx);
            _val(ctx) = address_v4::from_string(std::string(raw.begin(), raw.end()));
        };

        auto cidr   = rule<void, address_v4>{"cidr"} //
                    = raw[+(digit | '.')][to_address];
        auto ignore = omit[*(char_ - eol) % (eol >> !(+digit | "    inet "))];
        auto entry = rule<void, Entry>{"entry"} =            //
            omit[+digit] >> ": " >> +alnum >> ": <"          //
            >> ignore                                        // skip irrelevant
            >> eol >> "    inet " >> cidr >> '/' >> uint_ >> //
            ignore;

        std::vector<Entry> entries;
        parse(sv.begin(), sv.end(), entry % eol, entries);
        return entries;
    }

} // namespace NIC

int main() {
    boost::asio::io_context  io;
    std::future<std::string> output;

    bp::child c("ip a", bp::std_out > output, io);
    io.run_for(5s);

    for (auto [iface, cidr, mask] : NIC::parse(output.get()))
        std::cout << "iface " << iface << " net " << cidr << " mask " << mask << "\n";
}

Which prints: