I transferred a std::pair over a named pipe how did it work? - sockets

Question

I passed a std::pair over a named pipe using read() and write() functions in Linux. I passed it by reference, and read it by reference. How did that work? From what I know, std::pair is not serialized and what happens when the reference goes out of scope. Can an object be moved, or a copy by reference?
I am confused.
I am new to C++, so my pointer and reference knowledge is a little poor, but from what I know I am passing the address over the pipe and then pointing the read side object to this new address.
Though the read side object is, well, an object, not a pointer. So what happens to it's old/original instance?
I am writing using this code:
std::pair<int, somestruct> sample_pair;
write(FD, &sample_pair, sizeof(sample_pair));
And reading it using this code:
std::pair<int, somestruct> sample_pair;
read(FD, &sample_pair, sizeof(sample_pair));

Answer 1

You are NOT sending the address of the std::pair over the pipe at all. You are sending the actual content of the std::pair instead.
You are passing the address of a std::pair instance as the starting address to write(), telling it to read sizeof(sample_pair) number of bytes starting at that initial address and write them sequentially to the pipe. The raw bytes that are stored inside of the std::pair are thus written as-is over the pipe.
You are passing the address of a std::pair instance as the starting address to read(), telling it to read sizeof(sample_pair) number of bytes from the pipe and save them sequentially to that initial address. The raw bytes received from the pipe are thus stored as-is inside of the std::pair.
That being said, sending a std::pair in this manner is still undefined behavior, since the actual memory layout of the std::pair is implementation-specific, particularly in regards to any alignment padding that may exist between the two fields. You need to manually serialize your data into a format that is safe for crossing process boundaries, then de-serialize it on the other end.
For instance, it may be as simple as sending the two fields individually (assuming somestruct is self-contained (no pointers to external data) and has no alignment issues of its own), eg:
#pragma pack(push, 1)
struct somestruct
{
int8_t value1;
int16_t value2;
int32_t value3;
char data[256];
};
#pragma pack(pop)
std::pair<int32_t, somestruct> sample_pair;
// populate as needed...
write(FD, &(sample_pair.first), sizeof(sample_pair.first));
write(FD, &(sample_pair.second), sizeof(sample_pair.second));
std::pair<int32_t, somestruct> sample_pair;
read(FD, &(sample_pair.first), sizeof(sample_pair.first));
read(FD, &(sample_pair.second), sizeof(sample_pair.second));
Or, it may be as complex and having to flatten the content of somestruct into a sequential byte[] array before sending it, eg:
struct somestruct
{
int8_t value1;
int16_t value2;
int32_t value3;
std::string data;
};
std::pair<int32_t, somestruct> sample_pair;
// populate as needed...
std::vector<uint8_t> buffer(
sizeof(int32_t) +
sizeof(int8_t) +
sizeof(int16_t) +
sizeof(int32_t) +
sizeof(int32_t) +
sample_pair.second.data.length()
);
uint8_t *ptr = &buffer[0];
*reinterpret_cast<int32_t*>(ptr) = htonl(sample_pair.first);
ptr += sizeof(int32_t);
*reinterpret_cast<int8_t*>(ptr) = sample_pair.second.value1;
ptr += sizeof(int8_t);
*reinterpret_cast<int16_t*>(ptr) = htons(sample_pair.second.value2);
ptr += sizeof(int16_t);
*reinterpret_cast<int32_t*>(ptr) = htonl(sample_pair.second.value3);
ptr += sizeof(int32_t);
*reinterpret_cast<int32_t*>(ptr) = htonl(sample_pair.second.data.length());
ptr += sizeof(int32_t);
std::copy(sample_pair.second.data.cbegin(), sample_pair.second.data.cend(), reinterpret_cast<char*>(ptr));
int32_t len = htonl(buffer.size());
write(FD, &len, sizeof(len));
write(FD, buffer.data(), buffer.size());
std::pair<int32_t, somestruct> sample_pair;
int32_t len;
read(FD, &len, sizeof(len));
len = ntohl(len);
std::vector<uint8_t> buffer(len);
uint8_t *ptr = &buffer[0];
read(FD, ptr, len);
sample_pair.first = ntohl(*reinterpret_cast<int32_t*>(ptr));
ptr += sizeof(int32_t);
sample_pair.second.value1 = *reinterpret_cast<int8_t*>(ptr);
ptr += sizeof(int8_t);
sample_pair.second.value2 = ntohs(*reinterpret_cast<int16_t*>(ptr));
ptr += sizeof(int16_t);
sample_pair.second.value3 = ntohl(*reinterpret_cast<int32_t*>(ptr));
ptr += sizeof(int32_t);
len = ntohl(*reinterpret_cast<int32_t*>(ptr));
ptr += sizeof(int32_t);
sample_pair.second.data.assign(reinterpret_cast<char*>(ptr), len);
Or, you could just send the values individually:
void sendInt8(int FD, int8_t value)
{
write(FD, &value, sizeof(value));
}
void sendInt16(int FD, int16_t value)
{
value = htons(value);
write(FD, &value, sizeof(value));
}
void sendInt32(int FD, int32_t value)
{
value = htonl(value);
write(FD, &value, sizeof(value));
}
void sendStr(int FD, const std::string &value)
{
sendInt32(FD, value.length());
write(FD, value.c_str(), value.length());
}
...
std::pair<int32_t, somestruct> sample_pair;
// populate as needed...
sendInt32(FD, sample_pair.first);
sendInt8(FD, sample_pair.second.value1);
sendInt16(FD, sample_pair.second.value2);
sendInt32(FD, sample_pair.second.value3);
sendStr(FD, sample_pair.second.data);
int8_t readInt8(int FD)
{
int8_t value;
read(FD, &value, sizeof(value));
return value;
}
int16_t readInt16(int FD)
{
int16_t value;
read(FD, &value, sizeof(value));
return ntohs(value);
}
int32_t readInt16(int FD)
{
int32_t value;
read(FD, &value, sizeof(value));
return ntohl(value);
}
std::string readStr(int FD)
{
std::string value;
int32_t len = readInt32(FD);
if (len > 0)
{
value.resize(len);
read(FD, &value[0], len);
}
return value;
}
...
std::pair<int32_t, somestruct> sample_pair;
sample_pair.first = readInt32(FD);
sample_pair.second.value1 = readInt8(FD);
sample_pair.second.value2 = readInt16(FD);
sample_pair.second.value3 = readInt32(FD);
sample_pair.second.data = readStr(FD);