0

嗨，请有人帮助我

我有两个进程说一些 X 和 Y。X 和 Y 都有以下信息

typedef enum {
    HEALTHY=1,
    FAULTY=2,
    CHANGE=3,
    ERROR=4
} MsgTypeT;

typedef struct {
    char role[16];
    char state[16];
    char info[256];
} InfoT;

typedef struct {
    MsgTypeT type;
    int size;
    InfoT *data;
} MsgT;

这里的条件是，如果进程 Y 发送一个信息，进程 X 会读取它所以我在 x 和 y 之间使用了 fifo，Y 有一个写入 fifo 的函数写入缓冲区，代码如下

int write_buffer(HA_DEVMON_MsgT const* send)
{                   
char* dest = buffer;
memcpy( dest, &send->type, sizeof( MsgTypeT ));
dest += sizeof(MsgTypeT);
memcpy( dest, &send->size, sizeof( int ));
dest += sizeof(int);
memcpy( dest, send->data, sizeof( InfoT ));
dest += sizeof(InfoT);
int byteCount = write( this->fifo_fd, buffer, dest - buffer );
if ( byteCount != dest - buffer ) {
cout<<"Error in writing ";
}
return byteCount == dest - buffer ? 0 : -1;
}

我认为它写得很好，因为 cout 语句在尝试输出 nbytes 时也可以正常工作，它给出了 512bytes 已被写入

现在，当 X 尝试读取时，它为角色和状态提供 null 值，它的大小也为 6441568 它只给 MsgTypeT 正确的其他值是 null :( 代码如下---我做错了，请纠正它

int readMsg(MsgT *msg)
{
    int rCode=0, nbytes=0;
    char buffer[512]={0};

    nbytes = read(this->get_handle(), buffer, sizeof(buffer));
    if (nbytes < 0) {
        cout<<"error in read";
        rCode=-1;
    } 
    if (rCode == 0) {
        char *p_src = (char *)buffer;
        mempcpy(&msg->type, p_src, sizeof(MsgTypeT));
        p_src+=sizeof(MsgTypeT);
        mempcpy(&msg->size, p_src, sizeof(int));
        p_src+=sizeof(int);
        msg->data = new InfoT(); //allocating memory (needed or not???)
        mempcpy(msg->data, p_src, sizeof(InfoT));
        p_src+=sizeof(InfoT);
    }
    return rCode;
}
4

1 回答 1

2

在readMsg，您最后一次mempcpy写入msg，而不是 InfotT您刚刚分配的。

另外，但我想你知道这一点：只有当两个进程都使用相同的编译器，使用相同的选项编译时，才能保证工作。（实际上，如果底层系统用 C 定义其 API，它可能会起作用，Windows 和 Unix 就是这种情况。）

编辑：

进一步：写作时你有同样的问题。你写 sizeof(InfoT)（288）字节，但你写的是指针（然后是很多垃圾），而不是它指向的数据。

然后将指针递增到MsgT对象中。如果有任何填充，这可能不起作用。你真正需要做的是：

int
write_buffer( MsgT const* data )
{
    char buffer[512] = {};  //  Or better yet, std::vector<char>
    char* dest = buffer;
    memcpy( dest, &data->type, sizeof( MsgTypeT ) );
    dest += sizeof( MsgTypeT );
    memcpy( dest, &data->size, sizeof( int ) );
    dest += sizeof( int );
    memcpy( dest, &data->data, sizeof( InfoT ) );
    dest += sizeof( InfoT );
    int byteCount = write( fifo_fd, buffer, dest - buffer );
    if ( byteCount != dest - buffer ) {
        std::cerr << "Error in write" << std::endl;
    }
    return byteCount == dest - buffer ? 0 : -1;
}

阅读时则相反。

再一次，这仅适用于同一台机器上的两个进程，使用相同的编译器使用相同的选项进行编译。更好的解决方案可能是定义一个协议，定义整数、字符串等的表示，将输出格式化为该表示，然后解析它以供输入。这样，即使其中一个进程是 64 位，而另一个是 32 位，它仍然可以工作。

于 2013-07-02T10:33:32.063 回答