0

我在构建“中间人”记录器时遇到了很多麻烦 - 目的是将它放在 /usr/bin 中项目上方的路径上，并捕获进出应用程序的所有内容。（黑盒第 3 方应用程序由于某种原因无法通过 FTP。）一旦运行，中间人将分叉，将标准输出和标准输入重定向到/从父级控制的管道，然后执行 /usr/bin 中的程序。（硬编码；是的，我知道，我很糟糕。）

但是，一旦我运行 poll()，事情就会变得很奇怪。我失去了我的日志文件的句柄，来自孩子的输出管道上的投票引发了错误，猫和狗开始生活在一起，等等。

任何人都可以对此有所了解吗？

这是我目前拥有的... 有问题的 poll() 标有非缩进注释，以便于定位。

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <poll.h>
#include <time.h>
#include <sys/types.h>
#include <fcntl.h>

#define MAX_STR_LEN 1024
static int directionFlag; /* 0 = input, 1 = output */
static int eofFlag;

/* Splits the next char from the stream inFile, with extra
information logged if directionFlag swaps */
void logChar(int inFilDes, int outFilDes, FILE *logFile, int direction)
{
    char inChar = 0;
    if(read(inFilDes, &inChar, sizeof(char)) > 0)
    {

        if(direction != directionFlag)
        {
            directionFlag = direction;
            if(direction)
            {
                fprintf(logFile, "\nOUTPUT: ");
            } else {
                fprintf(logFile, "\nINPUT: ");
            }
        }

        write(outFilDes, &inChar, sizeof(char));
        fputc(inChar, stderr);
        fputc(inChar, logFile);
    } else {
        eofFlag = 1;
    }
    return;
}

int main(int argc, char* argv[])
{
    pid_t pid;

    int childInPipe[2];
    int childOutPipe[2];

    eofFlag = 0;

    /* [0] is input, [1] is output*/

    if(pipe(childInPipe) < 0 || pipe(childOutPipe) < 0) {
        fprintf(stderr,"Pipe error; aborting\n");
            exit(1);
    }

    if((pid = fork()) == -1){
        fprintf(stderr,"Fork error; aborting\n");
        exit(1);
    }

    if(pid)
    {
        /*Parent process*/

        int i;
        int errcode;
        time_t rawtime;
        struct tm * timeinfo;
        time(&rawtime);
        timeinfo=localtime(&rawtime);

        struct pollfd pollArray[2] = {
            { .fd = 0, .events = POLLIN, .revents = 0 },
            { .fd = childOutPipe[0], .events = POLLIN, .revents = 0 }
        };
        /* Yet again, 0 = input, 1 = output */

        nfds_t nfds = sizeof(struct pollfd[2]);

        close(childInPipe[0]);
        close(childOutPipe[1]);

        /* We don't want to change around the streams for this one,
        as we will be logging everything - and I do mean everything */

        FILE *logFile;
        if(!(logFile = fopen("/opt/middleman/logfile.txt", "a"))) {
            fprintf(stderr, "fopen fail on /opt/middleman/logfile.txt\n");
            exit(1);
        }

        fprintf(logFile, "Commandline: ");

        for(i=0; i < argc; i++)
        {
            fprintf(logFile, "%s ", argv[i]);
        }
        fprintf(logFile, "\nTIMESTAMP: %s\n", asctime(timeinfo));

        while(!eofFlag)
        {

// RIGHT HERE is where things go to pot
            errcode = poll(pollArray, nfds, 1);
// All following fprintf(logfile)s do nothing
            if(errcode < 0) {
                fprintf(stderr, "POLL returned with error %d!", errcode);
                eofFlag = 1;
            }
            if((pollArray[0].revents && POLLERR) & errno != EAGAIN ) {
                fprintf(stderr, "POLL on input has thrown an exception!\n");
                fprintf(stderr, "ERRNO value: %d\n", errno);
                fprintf(logFile, "POLL on input has thrown an exception!\n");
                eofFlag = 1;
            } else if(pollArray[0].revents && POLLIN) {
                logChar(pollArray[0].fd, childInPipe[1], logFile, 0);
            } else if((pollArray[1].revents && POLLERR) & errno != EAGAIN ) {
                fprintf(stderr, "POLL on output has thrown an exception!\n");
                fprintf(stderr, "ERRNO value: %d\n", errno);
                fprintf(logFile, "POLL on output has thrown an exception!\n");
                eofFlag = 1;
            } else if(pollArray[1].revents && POLLIN) {
                logChar(pollArray[1].fd, 1, logFile, 1);
            }

        }

        fclose(logFile);

    }
    else
    {
        /*Child process; switch streams and execute application*/
        int i;
        int catcherr = 0;
        char stmt[MAX_STR_LEN] = "/usr/bin/";

        close(childInPipe[1]);
        close(childOutPipe[0]);

        strcat(stmt, argv[0]);

        if(dup2(childInPipe[0],0) < 0) {
            fprintf(stderr, "dup2 threw error %d on childInPipe[0] to stdin!\n", errno);
        }
//      close(childInPipe[0]);

        if(dup2(childOutPipe[1],1) < 0)
        {
            fprintf(stderr, "dup2 threw error %d on childInPipe[1] to stdout!\n", errno);
        }

        /* Arguments need to be in a different format for execv */
        char* args[argc+1];
        for(i = 0; i < argc; i++)
        {
            args[i] = argv[i];
        }
        args[i] = (char *)0;

        fprintf(stderr, "Child setup complete, executing %s\n", stmt);
        fprintf(stdout, "Child setup complete, executing %s\n", stmt);

        if(execv(stmt, args) == -1) {
            fprintf(stderr, "execvP error!\n");
            exit(1);
        }
    }
    return 0;
}

编辑 09 年 6 月 23 日下午 12:20

修复后，我尝试通过该程序运行“横幅”，这是我得到的输出......

Child setup complete, executing /usr/bin/banner
POLL on output has thrown an exception!
ERRNO value: 0

日志文件具有以下内容：

Commandline: banner testing 
TIMESTAMP: Tue Jun 23 11:21:00 2009

ERRNO 中有一个 0 的原因是因为 poll() 返回得很好；是 pollArray[1].revents 返回错误，这意味着 childOutPipe[0] 被轮询为有错误。据我所知，logChar() 永远不会被调用。

我将尝试将 poll() 拆分为两个不同的调用。

好的，当我 poll() 时——即使在标准输入上，它也不会返回错误消息——它会扼杀我写入日志文件的能力。此外，我发现 while() 循环在输出轮询返回管道错误之前运行了几次。我越来越相信 poll() 只是一个失败的原因。
在 poll() 之后，每次写入 logFile 的尝试都会失败，即使是成功的 poll()，也会将 errno 设置为“错误文件号”。这真的不应该发生。老实说，我看不出它会如何影响我的文件句柄。
好吧，看来我是个白痴。谢谢你让我直截了当；我假设 nfds 是字节大小，而不是数组大小。这是固定的，瞧！它不再杀死我的 logFile 句柄。

4

1 回答 1

3

真正的问题：

第一个（但次要）问题

struct pollfd pollArray[2] = {{0, POLLIN, 0}, {childOutPipe[0], POLLIN, 0}};

您对“struct pollfd”的顺序和内容做出了可能没有根据的假设。该标准所说的只是它包含（至少）三个成员；它没有说明它们出现的顺序。

标头应定义 pollfd 结构，该结构应至少包括以下成员：

int    fd       The following descriptor being polled. 
short  events   The input event flags (see below). 
short  revents  The output event flags (see below).

由于您使用的是 C99，因此请使用安全初始化符号：

    struct pollfd pollArray[2] =
    {
        { .fd = 0,               .events = POLLIN, .revents = 0 },
        { .fd = childOutPipe[0], .events = POLLIN, .revents = 0 },
    };

您可以将标准输入的 0 替换为FILENO_STDINfrom <fcntl.h>。

第二（主要）问题

    nfds_t nfds = sizeof(pollArray);

poll 数组的大小可能是 16（字节）——在大多数但不是所有机器（32 位和 64 位）上。您需要 poll 数组的维度（即 2）。这就是为什么所有的地狱都崩溃了；系统正在查看垃圾并感到困惑。

发表评论：

要查找在本地文件或函数中定义的数组的维度（但不是传递给函数的数组参数，也不是在另一个文件中定义的数组），请使用宏的变体：

#define DIM(x) (sizeof(x)/sizeof(*(x)))

这个名字让人联想到 BASIC 在昏暗、遥远的过去。我见过的其他名字是NELEMSor ARRAY_SIZEor DIMENSION（回到 Fortran IV），我相信还有很多其他名字。

发生的事情是因为您没有设置nfds为 2，系统调用在实际struct pollfd数组之后读取数据，并尝试制作不是struct pollfd. 特别是，它可能正在写入您所说revents的数组中一行的字段struct pollfd，但实际空间是 log FILE *，所以这完全搞砸了。对于其他局部变量也是如此。换句话说，你有一个堆栈缓冲区溢出——又名堆栈溢出，这个名字应该有点熟悉。但它正在发生，因为您对其进行了编程。

使固定：

    nfds_t nfds = DIM(pollArray);

三级（中级）问题

   poll(pollArray, nfds, 1);
   if (errcode < 0) {

的结果poll()不会被保存，并且变量errcode永远不会被赋值，但是您随后会立即检查该值是什么。更正后的代码可能是：

errcode = poll(pollArray, nfds, 1);
if (errcode < 0)
{
    fprintf(stderr, "POLL returned with error %d!\n", errcode);
    eofFlag = 1;
}

请注意添加到错误消息中的换行符 - 您需要它。或者：

if (poll(pollArray, nfds, 1) < 0)
{
    int errnum = errno;
    fprintf(stderr, "POLL returned with error (%d: %s)\n",
            errnum, strerror(errnum));
    eofFlag = 1;
}

在第二种情况下，您需要将 ' #include <errno.h>' 添加到标题列表中。保存 的值errno可以防止函数调用对其进行更改 - 但您只能errno在函数（系统调用）失败时进行可靠的测试。即使是成功的函数调用也可能errno不为零。（例如，在某些系统上，如果stderr不去终端，则errno在 I/O 调用之后的值为ENOTTY，即使整个调用成功。）

以前的沉思

关于可能是什么问题的一些先前想法；我认为这里仍然有一些有用的信息。

我怀疑您的问题是poll()“损坏”了轮询描述符集，您必须在每个循环中重建它。（查看了Open Group的手册页，似乎poll()没有遇到的问题select()。）这肯定是相关select()系统调用的问题。

您的子代码没有在应该关闭所有文件描述符时 - 您已经注释掉了一个 'close()` 并且完全缺少另一个。当孩子完成将管道连接到标准输入和输出时，您不希望未复制的文件描述符仍然打开；进程无法正确检测 EOF。

类似的评论可能适用于父母。

另外，请注意，发送进程可能需要先向孩子发送多个数据包，然后孩子的标准输出上才会出现任何内容。作为一个极端情况，考虑 ' sort'; 在生成任何输出之前读取其所有数据。 因此，我担心方向切换代码，尽管我还没有完全理解它的作用。就其本身而言，方向切换是无害的——它只是在开始以与上次相反的方向写入时写入新方向。

更严重的是，不要使用单字符读写；读取合理大小的缓冲区已满。合理的大小可能几乎是 256 到 8192 之间的 2 的任何幂；您可以随意选择其他大小（管道缓冲区的大小可能是一个不错的选择）。一次处理多个字符将大大提高性能。

我解决类似问题的方法是让两个进程进行监控，一个用于标准输入，另一个用于标准输出 - 或等价物。这意味着我根本不需要使用poll()（或select()）。处理标准输入的进程读取并阻塞等待更多信息；当有东西到达时，它会记录它并将其写入孩子的标准输入。对于处理标准输出的进程也是如此。

如果您需要，我可以挖掘出适用于管道的代码（请参阅我的个人资料）。我在一两年前看过它（嗯；事实上，最后一次编辑是在 2005 年，尽管我在 2007 年重新编译了它）并且它仍然处于工作状态（它是在 1989 年左右编写的）。我也有适用于套接字而不是管道的代码。他们需要进行一些调整以适应您的要求；它们相当专业（尤其是管道版本，它知道客户端-服务器数据库协议并尝试处理完整的信息包）。

于 2009-06-23T00:13:53.637 回答