C++ 套接字对不是 Reading/Writing Parent/Child
C++ Socket Pair Not Reading/Writing Parent/Child
我被分配了一个项目，我需要在其中使用 Unix Domain Sockets 在 two-way 之间进行通信parent 和 child 进程。我最初的方法是创建一个 child 和服务器，但我在连接和路径方面遇到了一些严重的问题。如果有人希望看到该代码，我愿意提供它。
无论如何，我到达了程序中打印出 "parent has written" 的那一行，尽管我不完全相信它已经到达，因为没有后续读取发生。我曾在不同的地方关闭管道并改变我的方式 reading/writing。
我现在正在使用 socketpair() 来设置一对套接字。除了套接字，我不能使用任何其他类型的 IPC。这些信息对我来说是全新的，所以请原谅草率的代码。
请忽略长#include 列表，将尽快清理。
再次，我的当前输出停止在 "Parent wrote to child" 然后它保持 运行，没有关闭，所以我认为这是 child 读取等待接收东西。
我的程序需要能够读写非常长的文件，因此您会在整个代码中看到序列化和解析工作。序列化和解析在项目的不同部分完美运行，所以我知道这不是问题所在。这是该死的插座！
无论如何，代码：
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string>
#include <iostream>
#include <algorithm>
#include <sys/wait.h>
#include <vector>
#include <fstream>
int main() {
int sockets[2];
std::cout << "Please enter name of text file." << std::endl;
std::string entered_file;
std::cin >> entered_file;
std::string string_to_find;
std::cout << "Please enter the string you'd like to search for." << std::endl;
std::cin >> string_to_find;
int rc = socketpair(AF_UNIX, SOCK_STREAM, 0, sockets);
if (rc < 0) {
perror("socketpair");
exit(1);
}
pid_t p;
p = fork();
if (p == 0) //child
{
char ch;
std::string the_file_as_string = "";
std::vector<std::string> lines_with_string;
int r;
while ((r = read(sockets[0], &ch, 1)) > 0) {
the_file_as_string.push_back(ch);
}
std::cout << "Child has read from parent..." << std::endl;
size_t pos = 0;
while(the_file_as_string.find(string_to_find, pos) != std::string::npos) {
pos = the_file_as_string.find(string_to_find, pos+string_to_find.size());
std::string sub = the_file_as_string.substr(0,pos);
int occurrences = 0;
size_t pos2 = 0;
while (sub.find("/0", pos2 ) != std::string::npos) {
pos2 = sub.find("/0", pos2+2);
++ occurrences;
pos += string_to_find.length();
}
occurrences = occurrences;
std::string occurrences_string = std::to_string(occurrences);
lines_with_string.push_back(occurrences_string);
}
std::cout << "child has parsed" << std::endl;
std::string lines_with_string_as_string = "";
for(unsigned int i=0; i<lines_with_string.size(); i++) {
lines_with_string_as_string = lines_with_string_as_string + lines_with_string.at(i) + "/0";
}
int file_size = lines_with_string_as_string.size();
write(sockets[0], lines_with_string_as_string.c_str(), file_size+1);
close(sockets[0]);
std::cout << "child has sent back to parent..." << std::endl;
}
else //parent
{
close(sockets[0]);
std::ifstream myfile;
//open file
myfile.open(entered_file.c_str());
if (!myfile) {
std::cerr << "Unable to open file datafile.txt" << std::endl;
return 1; // call system to stop
}
//here, pass lines to child one by one and return true or false based on if it finds the string
char lines_with_string[100];
char ch;
std::vector<std::string> the_file;
std::vector<int> final_line_numbers;
std::vector<std::string> final_lines;
std::string str;
while (std::getline(myfile, str))
{
the_file.push_back(str);
}
std::string the_file_as_string = "";
for(unsigned int i=0; i<the_file.size(); i++) {
the_file_as_string = the_file_as_string + the_file.at(i) + "/0";
}
int big_size = the_file_as_string.size();
write(sockets[1], the_file_as_string.c_str(), big_size+1);
std::cout << "Parent wrote to the child..." << std::endl;
wait(NULL);
std::string lines_with_string_as_string = "";
int r;
while ((r = read(sockets[1], &ch, 1)) > 0) {
lines_with_string_as_string.push_back(ch);
}
close(sockets[1]);
std::cout << "Parent has read from child..." << std::endl;
std::string delimit = "/0";
size_t pos3 = 0;
while ((pos3 = lines_with_string_as_string.find(delimit)) != std::string::npos) {
std::string token = lines_with_string_as_string.substr(0, pos3);
int token2 = std::stoi(token);
final_line_numbers.push_back(token2);
lines_with_string_as_string.erase(0, pos3 + delimit.length());
}
//match line numbers to array of lines (original)
for(unsigned int i=0; i < final_line_numbers.size(); i++) {
int find_int = final_line_numbers.at(i);
std::string find_string = the_file.at(find_int-1);
std::cout << find_string << std::endl;
final_lines.push_back(find_string);
}
std::sort(final_lines.begin(), final_lines.end());
std::cout << "The final outcome with lines containing " << "'" << string_to_find << "' are:" << std::endl;
for(unsigned int i=0; i<final_lines.size(); i++) {
std::cout << final_lines.at(i) << std::endl;
}
myfile.close();
std::cout << "Program has exited completely." << std::endl;
}
}
迷你版（同样的问题，说 "Parent has written to child..." 然后没有做任何进一步的事情，也没有退出：
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string>
#include <iostream>
#include <algorithm>
#include <sys/wait.h>
#include <vector>
#include <fstream>
int main() {
int sockets[2];
pid_t p;
socketpair(AF_UNIX, SOCK_STREAM, 0, sockets);
p=fork();
if (p < 0) {
perror("forking");
}
else if(p > 0) { //parent
std::string long_string_to_send = "ladjfldjsfljasdfj adjlkjadlsjf a fljasdfladj ljdl aljfajdfljadfadsflajd ajfdlkjslfjadj faldjsljalsdfljdfljadsl jladsfjasflajdflkajfl dasl fjalfjldjsfladsflajdlsfald fjljdfljadfjadfjl djfljadlfj aldjl hello";
int big_size = long_string_to_send.size();
write(sockets[1], long_string_to_send.c_str(), big_size+1);
std::cout << "Parent has written to child..." << std::endl;
wait(NULL);
std::string lines_with_string_as_string = "";
int r;
char ch;
while ((read(sockets[1], &ch, 1)) > 0) {
lines_with_string_as_string.push_back(ch);
}
close(sockets[1]);
std::cout << "Parent has received from child..." << std::endl;
std::cout << "Parent has read the following... " << lines_with_string_as_string << std::endl;
std::cout << "Program has exited completely" << std::endl;
}
else { //child
char ch;
std::string the_file_as_string = "";
int r;
while ((read(sockets[0], &ch, 1)) > 0) {
the_file_as_string.push_back(ch);
}
std::cout << "Child has read from parent..." << std::endl;
std::cout << "Child has read the following... " << the_file_as_string << std::endl;
int file_size = the_file_as_string.size();
write(sockets[0], the_file_as_string.c_str(), file_size+1);
close(sockets[0]);
}
}
归结...您的 parent 确实：
write(sockets[1], ...
wait(NULL)
而 child 会：
while (read(sockets[0] ....) > 0)
...
这个问题的关键在于：为什么 sockets[0] 中的 read 会 return 小于或等于零。这里的答案是：从不。您可能打算让 child 读取 parent 写入套接字的所有内容，但套接字的工作方式是您不会得到 end-of-file 指示，直到另一个对等方关闭套接字（或shutdown(2)。
所以在 parent 你应该做这样的事情：
write(sockets[1], ....);
shutdown(sockets[1], SHUT_WR); <<<<<=================
wait(NULL)
通过在 parent 的末端用 SHUT_WR 调用 shutdown，child 将得到 EOF 指示（return 值为零）在套接字的 its 端。否则，child 的读取将永远阻塞（因为 OS 如何知道 parent 稍后是否会写入更多数据？）。
进一步解释：parent 也可以 close 它的套接字末端，但如果是这样，它将无法从 [=61= 读取响应数据]. shutdown 实质上允许您 "half-close" 套接字；那是 close-for-writing 但请打开以供阅读。
此方法的唯一真正替代方法是以某种方式 "frame" 数据（即创建 "protocol"）。也就是说，您可以首先以某种 fixed-size 或其他不同的方式写入要发送的数据的长度，然后 child 可以准确读取所需的字节数。然后，您可以无限期地继续两个进程之间的对话，而无需 shutdown 或 close.
编辑：
还有一个警告。每个进程的最佳做法是，在 fork 之后关闭套接字的 other's 端。换句话说，就在分叉之后，parent 将关闭 sockets[0] 而 child 将关闭 sockets[1]。否则，一侧的 close 将 而不是 实际上会在另一侧产生 end-of-file （因为文件描述符在读取端仍然打开 - 只是在 fork 之后，两个文件描述符在两个进程中都打开了）。使用 shutdown/SHUT_WR 绕过了这个困难，因为它明确表示为了写作的目的，一侧被认为是封闭的。
我被分配了一个项目，我需要在其中使用 Unix Domain Sockets 在 two-way 之间进行通信parent 和 child 进程。我最初的方法是创建一个 child 和服务器，但我在连接和路径方面遇到了一些严重的问题。如果有人希望看到该代码，我愿意提供它。
无论如何，我到达了程序中打印出 "parent has written" 的那一行，尽管我不完全相信它已经到达，因为没有后续读取发生。我曾在不同的地方关闭管道并改变我的方式 reading/writing。
我现在正在使用 socketpair() 来设置一对套接字。除了套接字，我不能使用任何其他类型的 IPC。这些信息对我来说是全新的，所以请原谅草率的代码。
请忽略长#include 列表，将尽快清理。
再次，我的当前输出停止在 "Parent wrote to child" 然后它保持 运行，没有关闭，所以我认为这是 child 读取等待接收东西。
我的程序需要能够读写非常长的文件，因此您会在整个代码中看到序列化和解析工作。序列化和解析在项目的不同部分完美运行，所以我知道这不是问题所在。这是该死的插座！
无论如何，代码：
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string>
#include <iostream>
#include <algorithm>
#include <sys/wait.h>
#include <vector>
#include <fstream>
int main() {
int sockets[2];
std::cout << "Please enter name of text file." << std::endl;
std::string entered_file;
std::cin >> entered_file;
std::string string_to_find;
std::cout << "Please enter the string you'd like to search for." << std::endl;
std::cin >> string_to_find;
int rc = socketpair(AF_UNIX, SOCK_STREAM, 0, sockets);
if (rc < 0) {
perror("socketpair");
exit(1);
}
pid_t p;
p = fork();
if (p == 0) //child
{
char ch;
std::string the_file_as_string = "";
std::vector<std::string> lines_with_string;
int r;
while ((r = read(sockets[0], &ch, 1)) > 0) {
the_file_as_string.push_back(ch);
}
std::cout << "Child has read from parent..." << std::endl;
size_t pos = 0;
while(the_file_as_string.find(string_to_find, pos) != std::string::npos) {
pos = the_file_as_string.find(string_to_find, pos+string_to_find.size());
std::string sub = the_file_as_string.substr(0,pos);
int occurrences = 0;
size_t pos2 = 0;
while (sub.find("/0", pos2 ) != std::string::npos) {
pos2 = sub.find("/0", pos2+2);
++ occurrences;
pos += string_to_find.length();
}
occurrences = occurrences;
std::string occurrences_string = std::to_string(occurrences);
lines_with_string.push_back(occurrences_string);
}
std::cout << "child has parsed" << std::endl;
std::string lines_with_string_as_string = "";
for(unsigned int i=0; i<lines_with_string.size(); i++) {
lines_with_string_as_string = lines_with_string_as_string + lines_with_string.at(i) + "/0";
}
int file_size = lines_with_string_as_string.size();
write(sockets[0], lines_with_string_as_string.c_str(), file_size+1);
close(sockets[0]);
std::cout << "child has sent back to parent..." << std::endl;
}
else //parent
{
close(sockets[0]);
std::ifstream myfile;
//open file
myfile.open(entered_file.c_str());
if (!myfile) {
std::cerr << "Unable to open file datafile.txt" << std::endl;
return 1; // call system to stop
}
//here, pass lines to child one by one and return true or false based on if it finds the string
char lines_with_string[100];
char ch;
std::vector<std::string> the_file;
std::vector<int> final_line_numbers;
std::vector<std::string> final_lines;
std::string str;
while (std::getline(myfile, str))
{
the_file.push_back(str);
}
std::string the_file_as_string = "";
for(unsigned int i=0; i<the_file.size(); i++) {
the_file_as_string = the_file_as_string + the_file.at(i) + "/0";
}
int big_size = the_file_as_string.size();
write(sockets[1], the_file_as_string.c_str(), big_size+1);
std::cout << "Parent wrote to the child..." << std::endl;
wait(NULL);
std::string lines_with_string_as_string = "";
int r;
while ((r = read(sockets[1], &ch, 1)) > 0) {
lines_with_string_as_string.push_back(ch);
}
close(sockets[1]);
std::cout << "Parent has read from child..." << std::endl;
std::string delimit = "/0";
size_t pos3 = 0;
while ((pos3 = lines_with_string_as_string.find(delimit)) != std::string::npos) {
std::string token = lines_with_string_as_string.substr(0, pos3);
int token2 = std::stoi(token);
final_line_numbers.push_back(token2);
lines_with_string_as_string.erase(0, pos3 + delimit.length());
}
//match line numbers to array of lines (original)
for(unsigned int i=0; i < final_line_numbers.size(); i++) {
int find_int = final_line_numbers.at(i);
std::string find_string = the_file.at(find_int-1);
std::cout << find_string << std::endl;
final_lines.push_back(find_string);
}
std::sort(final_lines.begin(), final_lines.end());
std::cout << "The final outcome with lines containing " << "'" << string_to_find << "' are:" << std::endl;
for(unsigned int i=0; i<final_lines.size(); i++) {
std::cout << final_lines.at(i) << std::endl;
}
myfile.close();
std::cout << "Program has exited completely." << std::endl;
}
}
迷你版（同样的问题，说 "Parent has written to child..." 然后没有做任何进一步的事情，也没有退出：
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string>
#include <iostream>
#include <algorithm>
#include <sys/wait.h>
#include <vector>
#include <fstream>
int main() {
int sockets[2];
pid_t p;
socketpair(AF_UNIX, SOCK_STREAM, 0, sockets);
p=fork();
if (p < 0) {
perror("forking");
}
else if(p > 0) { //parent
std::string long_string_to_send = "ladjfldjsfljasdfj adjlkjadlsjf a fljasdfladj ljdl aljfajdfljadfadsflajd ajfdlkjslfjadj faldjsljalsdfljdfljadsl jladsfjasflajdflkajfl dasl fjalfjldjsfladsflajdlsfald fjljdfljadfjadfjl djfljadlfj aldjl hello";
int big_size = long_string_to_send.size();
write(sockets[1], long_string_to_send.c_str(), big_size+1);
std::cout << "Parent has written to child..." << std::endl;
wait(NULL);
std::string lines_with_string_as_string = "";
int r;
char ch;
while ((read(sockets[1], &ch, 1)) > 0) {
lines_with_string_as_string.push_back(ch);
}
close(sockets[1]);
std::cout << "Parent has received from child..." << std::endl;
std::cout << "Parent has read the following... " << lines_with_string_as_string << std::endl;
std::cout << "Program has exited completely" << std::endl;
}
else { //child
char ch;
std::string the_file_as_string = "";
int r;
while ((read(sockets[0], &ch, 1)) > 0) {
the_file_as_string.push_back(ch);
}
std::cout << "Child has read from parent..." << std::endl;
std::cout << "Child has read the following... " << the_file_as_string << std::endl;
int file_size = the_file_as_string.size();
write(sockets[0], the_file_as_string.c_str(), file_size+1);
close(sockets[0]);
}
}
归结...您的 parent 确实：
write(sockets[1], ...
wait(NULL)
而 child 会：
while (read(sockets[0] ....) > 0)
...
这个问题的关键在于：为什么 sockets[0] 中的 read 会 return 小于或等于零。这里的答案是：从不。您可能打算让 child 读取 parent 写入套接字的所有内容，但套接字的工作方式是您不会得到 end-of-file 指示，直到另一个对等方关闭套接字（或shutdown(2)。
所以在 parent 你应该做这样的事情：
write(sockets[1], ....);
shutdown(sockets[1], SHUT_WR); <<<<<=================
wait(NULL)
通过在 parent 的末端用 SHUT_WR 调用 shutdown，child 将得到 EOF 指示（return 值为零）在套接字的 its 端。否则，child 的读取将永远阻塞（因为 OS 如何知道 parent 稍后是否会写入更多数据？）。
进一步解释：parent 也可以 close 它的套接字末端，但如果是这样，它将无法从 [=61= 读取响应数据]. shutdown 实质上允许您 "half-close" 套接字；那是 close-for-writing 但请打开以供阅读。
此方法的唯一真正替代方法是以某种方式 "frame" 数据（即创建 "protocol"）。也就是说，您可以首先以某种 fixed-size 或其他不同的方式写入要发送的数据的长度，然后 child 可以准确读取所需的字节数。然后，您可以无限期地继续两个进程之间的对话，而无需 shutdown 或 close.
编辑：
还有一个警告。每个进程的最佳做法是，在 fork 之后关闭套接字的 other's 端。换句话说，就在分叉之后，parent 将关闭 sockets[0] 而 child 将关闭 sockets[1]。否则，一侧的 close 将 而不是 实际上会在另一侧产生 end-of-file （因为文件描述符在读取端仍然打开 - 只是在 fork 之后，两个文件描述符在两个进程中都打开了）。使用 shutdown/SHUT_WR 绕过了这个困难，因为它明确表示为了写作的目的，一侧被认为是封闭的。