Пара гнезд С ++ не читает / не пишет Родитель / Ребенок

Мне был назначен проект, в котором мне нужно использовать Доменные сокеты Unix двусторонняя связь между родительским и дочерним процессами. Мой оригинальный подход заключался в создании дочернего элемента и сервера, но у меня возникали серьезные проблемы с подключением и путями. Если кто-то предпочел бы увидеть этот код, я готов предоставить его.

Так или иначе, я достигаю строки в моей программе, где я распечатываю «родитель написал», хотя я не совсем уверен, что это так, потому что последующее чтение не происходит. Я работал с закрытием каналов в разных местах и ​​изменением того, как я читаю / пишу.

Я сейчас пользуюсь socketpair () установить пару розеток. Я не могу использовать любой другой тип IPC, кроме сокетов. Эта информация совершенно новая для меня, так что простите небрежный код.

Пожалуйста, игнорируйте длинный список #include, очистите как можно скорее.

Опять же, мой текущий вывод останавливается на «Родитель пишет ребенку», а затем продолжает работать, не закрывается, так что я думаю, что это дочернее чтение, ожидающее что-то получить.

Моя программа должна иметь возможность читать и записывать невероятно длинные файлы, поэтому вы увидите работу сериализации и анализа по всему коду. Сериализация и синтаксический анализ отлично работают в другой части проекта, поэтому я знаю, что это не проблема. Это проклятые розетки!

Во всяком случае, код:

#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;
}
}

МИНИ-ВЕРСИЯ (та же самая проблема, говорит «Родитель написал ребенку …», а затем ничего не делает, а также не выходит:

#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]);
}
}