Xcode 不可靠的Unix套接字连接 我创建了一个基本的客户机/服务器C++套接字程序。我可以在套接字上可靠地写入整数，但当我尝试在套接字上写入字符串时，接收端只在大约25%的时间内接收数据。我已使用Wireshark验证数据是否正在发送。我是新的C++和网络编程，

不可靠的Unix套接字连接 <>我创建了一个基本的客户机/服务器C++套接字程序。我可以在套接字上可靠地写入整数，但当我尝试在套接字上写入字符串时，接收端只在大约25%的时间内接收数据。我已使用Wireshark验证数据是否正在发送。我是新的C++和网络编程，所以任何输入都会被赏识。代码如下

class compressionServer{
    int                 PORT = 4000;
    int                 LISTEN_QUEUE = 1024;
    int                 sock;
    int                 conn;
    struct sockaddr_in  socketAddress;
    int                 receivedMagicData[8+1];
    int                 receivedStatusCode[2];
    int                 receivedPayloadLength[2];
    char                receivedCompressionData[2048];
    int                 requestCode = 0;
    int                 payloadLength;
    uint32_t            inBytes = 0;
    uint32_t            outBytes = 0;
    double              compressionRatio = 0;
    string              dataToCompress;

public:
    void start(){
        if((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0){
            printf("Socket Error");
            exit(1);
        }

        bzero(&socketAddress, sizeof(socketAddress));
        socketAddress.sin_family      = AF_INET;
        socketAddress.sin_addr.s_addr = htonl(INADDR_ANY);
        socketAddress.sin_port        = htons(PORT);
        int enable = 1;
        if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int)) < 0){ // so we can rebind quickly while testing
            printf("setsockopt(SO_REUSEADDR) failed");
        }
        if(::bind(sock, (struct sockaddr *) &socketAddress, sizeof(socketAddress)) < 0){
            printf("Bind Error\n");
            std::cout << std::strerror(errno) << std::endl;
            exit(1);
        }


        if(listen(sock, LISTEN_QUEUE) < 0){
            printf("Listen Error");
            exit(1);
        }

        for ( ; ; ) {
            if((conn = accept(sock, (struct sockaddr *) NULL, NULL)) < 0){
                printf("Accept Error");
                exit(1);
            }
            ssize_t n;
            if((n = read(conn, receivedMagicData, 8)) > 0){
                int magicWord = ntohl(*receivedMagicData);

                if(magicWord == 53545259){
                    std::cout << "DOES NOT MATCH" << std::endl;
                    break;
                }

            }
            if((n = read(conn, receivedPayloadLength, 2)) > 0){
                payloadLength = ntohs(*receivedPayloadLength);

                std::cout << "payloadLength = " << std::hex << payloadLength << std::endl;
            }
            if((n = read(conn, receivedStatusCode, 2)) > 0){
                requestCode = ntohs(*receivedStatusCode);

                std::cout << "requestCode = " << std::hex << requestCode << std::endl;
            }
            while((n = read(conn, receivedCompressionData, 2048)) > 0){
                receivedCompressionData[n] = 0;
                cout << "data: " << receivedCompressionData << endl;
                dataToCompress = receivedCompressionData;
                if(strlen(receivedCompressionData) > 0){
                    break;
                }
            }

        }
        if (close(conn) < 0){
            printf("Close Error");
            exit(1);
        }
    }
};

类压缩服务器{
int端口=4000；
int LISTEN_QUEUE=1024；
int袜子；
内控室；
socketAddress中的结构sockaddr_；
int receivedMagicData8[8+1]；
int接收状态代码[2]；
int receivedPayloadLength[2]；
字符接收压缩数据[2048]；
int requestCode=0；
int有效负载长度；
uint32字节=0；
uint32\u t outBytes=0；
双压缩比=0；
字符串数据压缩；
公众：
void start（）{
if（（sock=socket（AF_INET，sock_STREAM，0））<0）{
printf（“套接字错误”）；
出口（1）；
}
bzero（&socketAddress，sizeof（socketAddress））；
socketAddress.sin_family=AF_INET；
socketAddress.sin\u addr.s\u addr=htonl（INADDR\u ANY）；
socketAddress.sin_port=htons（端口）；
int enable=1；
如果（setsockopt（sock，SOL_SOCKET，SO_REUSEADDR，&enable，sizeof（int））<0{//，那么我们可以在测试时快速重新绑定
printf（“setsockopt（SO_REUSEADDR）失败”）；
}
if（：：bind（sock，（struct sockaddr*）和socketAddress，sizeof（socketAddress））<0{
printf（“绑定错误\n”）；
std:：cout根据平台上
long
的大小，发送方在发送数据之前发送8或16个（
2*sizeof（long）
）字节。接收方读取12个（
8+2+2
）字节。这看起来不对。
receivedCompressionData[n]=0
可能会通过缓冲区溢出的方式显示未定义的行为，因为
n
可能等于2048。谢谢，@IgorTandetnik，在阅读了您的评论后，我意识到我只需要将数据存储在int中。一旦我将headerHex和Header2Hex更改为int，每次都会执行。如果您想写一个答案，我会将其标记为正确。
class compressionClient{

public:
    void start(std::string  ipAddr){
        int                 MAX_LINE = 4096;
        int                 sockfd;
        struct sockaddr_in  servaddr;


        if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
            printf("socket error");
            exit(1);
        }

        bzero(&servaddr, sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_port   = htons(4000);


        if (inet_pton(AF_INET, ipAddr.c_str(), &servaddr.sin_addr) <= 0){
            printf("inet_pton error for %s", ipAddr.c_str());
            exit(1);
        }


        if (connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0){
            printf("connect error");
            exit(1);
        }

        long headerHex = htonl(0x53545259);
        long header2Hex = htonl(0x31300034);

        std::cout << "send: " << std::hex << headerHex << std::endl;
        std::cout << "send2: " << std::hex << header2Hex << std::endl;
//server receives this
        if(send(sockfd, (char *) (&headerHex), sizeof(headerHex), 0) < 0){
            printf("Write Error");
            exit(1);
        }
//server receives this too 
        if(send(sockfd, (char *) (&header2Hex), sizeof(header2Hex), 0) < 0){
            printf("Write Error2");
            exit(1);
        }
        char data[100];
        snprintf(data, sizeof(data), "aaabbcddd");
//server only recieves this sometimes
        if(write(sockfd, data, strlen(data)) < 0){
            printf("write error3");
            exit(1);
        }
    }
};