0

こんにちは、誰か助けてください

XとYの2つのプロセスがあります。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;
}

nbytes を出力しようとしたときにも cout ステートメントが正常に動作しているため、完全に書き込んでいると思います。512bytes が書き込まれました

Xが読み取ろうとすると、ロールと状態にnull値が与えられ、サイズも6441568になります。MsgTypeTに正しい他の値を与えるだけです:(コードは次のとおりです---私は何か間違ったことをしていますそれを修正してください

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書き込みます。msgInfotT

また、これは知っていると思いますが、これは、両方のプロセスが同じオプションを使用して同じコンパイラでコンパイルされた場合にのみ動作することが保証されています。(実際には、基礎となるシステムがその API を C で定義している場合に機能する可能性が高く、これは Windows と Unix の場合です。)

編集：

さらに：書くときに同じ問題があります。（288）バイトを書き込み sizeof(InfoT)ますが、ポインターが指しているデータではなく、ポインター（および大量のゴミ）を書き込みます。

そして、ポインタを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;
}

読むときはその逆。

繰り返しになりますが、これは、同じオプションを使用して同じコンパイラでコンパイルされた、同じマシン上の 2 つのプロセスに対してのみ実際に機能します。より良い解決策は、おそらく、整数、文字列などの定義された表現でプロトコルを定義し、出力をその表現にフォーマットし、それを入力用に解析することです。そうすれば、プロセスの 1 つが 64 ビットで、もう 1 つが 32 ビットであっても機能します。

于 2013-07-02T10:33:32.063 に答える