C++ 套接字对不读/写父/子

Question

我被分配了一个项目，在该项目中我需要使用 Unix Domain Sockets 在父进程和子进程之间进行双向通信。我最初的方法是创建一个 child 和服务器，但我在连接和路径方面遇到了一些严重的问题。如果有人希望看到该代码，我愿意提供。

无论如何，我已经到达程序中打印出“parent has written”的那一行，尽管我不完全相信它已经打印出来，因为没有后续读取发生。我曾在不同的地方关闭管道并改变我的阅读/写作方式。

我现在正在使用 socketpair() 来设置一对套接字。除了套接字，我不能使用任何其他类型的 IPC。这些信息对我来说是全新的，所以请原谅草率的代码。

请忽略长#include 列表，将尽快清理。

同样，我当前的输出停止在“Parent write to child”，然后它继续运行，没有关闭，所以我认为这是 child read 等待接收的东西。

我的程序需要能够读写非常长的文件，因此您会在整个代码中看到序列化和解析工作。序列化和解析在项目的不同部分完美运行，所以我知道这不是问题所在。这是该死的 socket !

无论如何，代码:

#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 已经写给 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]);
    }
}

Answer 1

归结起来……你的 parent 是这样的:

write(sockets[1], ...
wait(NULL)

当 child 这样做时:

while (read(sockets[0] ....)   > 0)
...

这个问题的关键是:为什么 read from sockets[0] 会返回小于或等于零的值。这里的答案是:从不。您可能打算让 child 读取 parent 写入套接字的所有内容，但套接字的工作方式是在另一个对等点关闭之前您不会收到文件结束指示套接字(或执行 shutdown(2)。

所以在 parent 中你应该做这样的事情:

write(sockets[1], ....);
shutdown(sockets[1], SHUT_WR);             <<<<<=================
wait(NULL)

通过在父端调用 shutdown 和 SHUT_WR，子端将在端获得 EOF 指示(返回值为零)的 socket 。否则，子进程的读取将永远阻塞(因为操作系统如何知道父进程稍后是否会写入更多数据？)。

进一步解释:父级也可以关闭它的套接字端，但如果这样做，它将无法从子级读取响应数据。 shutdown 实质上允许您“半关闭”套接字；这是接近于写作的，但对于阅读来说是开放的。

这种方法唯一真正的替代方法是以某种方式“构建”数据(即创建“协议(protocol)”)。也就是说，您可以先以某种固定大小或其他不同的方式写入要发送的数据的长度，然后 child 可以准确读取所需的字节数。然后，您可以无限期地继续两个进程之间的对话，而无需 shutdown 或 close。

编辑:
还有一个警告。在 fork 之后关闭套接字的其他 端是每个进程的最佳实践。换句话说，就在 fork 之后，父级将关闭 sockets[0]，子级将关闭 sockets[1]。否则，一侧的 close 不会实际上会在另一侧产生文件结尾(因为文件描述符在读取侧仍处于打开状态 - 只是在 fork 之后，两个文件描述符在两个进程中都打开了)。使用 shutdown/SHUT_WR 绕过了这个困难，因为它明确表示为了写入目的，一侧被认为是关闭的。