Hello,
You are basically asking about how the TCP or UDP is implemented in an operating system. There are no standards for that, just best practices that evolved over the years.
When your application want to communicate over network with a server using TCP, for example, it first needs to open a socket. The socket represents an endpoint of a communication, and it is your object you are using in your application to talk to the other party. Under C, the socket is a file description, very similar to an open file. If you want to talk to other endpoint, you write some data to the socket, and if you want to see what data the other party sent you, you read from the socket.
As soon as you write a certain amount of data to the socket, it is taken by your operating system. It copies the data from your program (so-called userspace) into the internal buffers maintained by your operating system's kernel (so-called kernelspace). Note that as soon as the data is copied from the userspace to the kernelspace, the kernel has its own copy of the data you wanted to transfer to the other side, and can chop it, segment it, encapsulate it according to its wishes, without modifying the original data in your userspace program. That does not mean, however, that the copied data must be modified - read further.
So in the kernelspace, after you called the write() function, the amount of data you have written into the socket is segmented, encapsulated and sent along its way. If an unreliable transport protocol is used then the segments are deallocated from the kernelspace immediately after sending. If a reliable transport protocol is used then the segments are deallocated only after a successful acknowledgement from the other side. So the buffering does take place, yes, and it is in a part of memory that is maintained by your kernel for its internal usage.
so does that memory has the complete data and the transport layer simply have a description of "from a-c thats segment 1" "from d-e thats segment 2" ?
or all the segments are really being stored "sliced" somewhere ?
This is an implementation-specific question. This depends on how well your TCP/IP driver is written and what is more effective for the particular operating system. In general, however, it is more effective to store the original piece of data unmodified, and instead, have only a set of pointers that point to the specific offsets where the piece of data should be split and separately encapsulated. This way, it is easy to adapt to changing TCP window size, for example. If you already split and encapsulated data, and the TCP window size changed, you would need to defragment the data and repackage them which would be very inefficient.
Best regards,
Peter
