How to get the size here?

[edwardcapriolo]

#include <seastar/core/seastar.hh>
#include <seastar/core/reactor.hh>
#include <seastar/core/future-util.hh>
#include <seastar/net/api.hh>

seastar::future<> handle_connection(seastar::connected_socket s) {
    auto out = s.output();
    auto in = s.input();
    return do_with(std::move(s), std::move(out), std::move(in),
            [] (auto& s, auto& out, auto& in) {
        return seastar::repeat([&out, &in] {
            return in.read().then([&out] (auto buf) {
                if (buf) {
                    return out.write(std::move(buf)).then([&out] {
                        return out.flush();
                    }).then([] {
                        return seastar::stop_iteration::no;
                    });
                } else {
                    return seastar::make_ready_future<seastar::stop_iteration>(
                            seastar::stop_iteration::yes);
                }
            });
        }).then([&out] {
            return out.close();
        });
    });
}

In this example we are reading the buffer which could have extranious data and sending it back out.
For example if I type
1234

The data may arrive server side like this:
buf size 6
0x600000003c40
0x600000004280
0x6000000048e0
0x600000004f60
0x600000005100

Two simple questions:

1. what is the ideomatic way to only return the data sent. (not including extra in the buffer)?
2. what is the most basic way to turn the input into a string?

Thank you

[edwardcapriolo]

  return in.read().then([&out, &me] (seastar::temporary_buffer<char> buf) {
					
	            	std::string* tmp = new std::string(buf.get(), buf.size());

Im guessing this is the recipe.

[edwardcapriolo]

        return in.read().then([&out, &me] (seastar::temporary_buffer<char> buf) {
				
            	std::string* tmp = new std::string(buf.get(), buf.size()-2);
            	
            	accounts for newline from telnet.

[avikivity]

First, use coroutines for healthier life.

Second, I don't understand the question. read() doesn't return extra data.

[edwardcapriolo]

I found a few examples that were taking this buffer and doing things with it in the code. I am pretty sure they were not taking this into account. In many cases the characters will be whitespace in your std out.For the "echo" server examples its nice because you want the newline anyway, (that is user data the \n") but its not clear from the docs what the last character is or why the buffer is size and how I am supposed to know where the user data ends.

[avikivity]

Please don't post images where text works.

I don't understand what's your problem with size 6. 6 bytes were sent, so 6 bytes are reported. Verify with packet capture.

[edwardcapriolo]

Please don't post images where text works.

I don't understand what's your problem with size 6. 6 bytes were sent, so 6 bytes are reported. Verify with packet capture.

I had not assumed that telnet stuck an extra character on things. I assumed it would stick a \n on my string and send. I attached the picture because someone mentioned not understanding the question, even though the code is provided, so I thought to demonstrate. Also since it is a buffer, I assumed it might be the case that the buffer is sized larger for some reason or is possibly reused and the size could be > the content for a variety of reasons.

[avikivity]

Instead of pasting a picture, paste text in triple backticks.

I suggest reading the telnet protocol and/or examining the actual bytes sent via packet capture. This isn't the place to argue about the telnet protocol. If you find that you get more or less bytes than are send by the peer, then it is interesting, but not before.

[edwardcapriolo]

Again sir, I am not arguing. Simply I asked a question:

Here it is again

In this example we are reading the buffer which could have extranious data and sending it back out.
For example if I type
1234

The data may arrive server side like this:
buf size 6
0x600000003c40
0x600000004280
0x6000000048e0
0x600000004f60
0x600000005100

Two simple questions:

    what is the ideomatic way to only return the data sent. (not including extra in the buffer)?

Fine, I dont know the telnet protocol,
https://superuser.com/questions/1545899/why-does-telnet-send-crlf-when-i-press-enter

I assumed it was possible that the buffer be larger then the data size. This isn't out of the realm of human possibility maybe buffers are sized larger at times, or reused. Stop telling me to "read stuff". You likely didnt know the answer either or you would have said "according to RFC bla bla, or based on telnet coming with linux fedora 42, 2 character linefeeds are added"

[nyh]

As Avi said, read() does not read any extra characters beyond what was actually sent on the socket.
If you read 6 characters, it means 6 characters were actually sent.
To figure out why 6 characters were sent, you need to understand your protocol, not Seastar. Your question didn't say what is your protocol or what tool you used to send the 4-character request. Most likely whatever tool that was sent an extra CR LF pair.

If you had printed the actual characters in the buffer instead of those pointers (?) you would have seen what those extra characters are.

I suggest to close this issue (?)