天天看點
傳回

網絡程式設計-TCP粘包

//TCP資料傳輸是以無邊界的資料流傳輸形式，所謂無邊界是指資料發送端發送的位元組數，
//在資料接收端接受時并不一定等于發送的位元組數，可能會出現粘包情況。

//TCP粘包情況：
    //（1）發送方引起的粘包是由TCP協定本身造成的，TCP為提高傳輸效率，發送方往往要收集到足夠多的資料後才發送一包資料。
    //若連續幾次發送的資料都很少，通常TCP會根據優化算法把這些資料合成一包後一次發送出去，這樣接收方就收到了粘包資料。
//（2）接收方引起的粘包是由于接收方使用者程序不及時接收資料，進而導緻粘包現象。
//這是因為接收方先把收到的資料放在系統接收緩沖區，使用者程序從該緩沖區取資料，若下一包資料到達時前一包資料尚未被使用者程序取走，
//則下一包資料放到系統接收緩沖區時就接到前一包資料之後，而使用者程序根據預先設定的緩沖區大小從系統接收緩沖區取資料，這樣就一次取到了多包資料。

//解決辦法：

//(1)發送固定長度的消息

//(2)把消息的尺寸與消息一塊發送

//(3)使用特殊标記來區分消息間隔

//下面介紹一種方法：

bool readPack(int sock, char* buf, size_t len) {    
    if (NULL == buf || len < ) {    
        return false;    
    }    
    memset(buf, , len); // only reset buffer len.    
    ssize_t read_len = , readsum = ;    
    do {    
        read_len = read(sock, buf + readsum, len - readsum);    
        if (- == read_len) { // ignore error case    
            return false;    
        }    
        printf("receive data: %s\n", buf + readsum);    
        readsum += read_len;    
    } while (readsum < len &&  != read_len);    
    return true;    
}

案例 

client.cpp

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <time.h>
#include <errno.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

void safe_close(int &sock);
void emulate_subpackage(int sock);
void emulate_adheringpackage(int sock);

int main(int argc, char *argv[]) {
    char buf[] = {};
    int sockfd = -;
    struct sockaddr_in serv_addr;

    // Create sock
    sockfd = socket(AF_INET, SOCK_STREAM, );
    if (- == sockfd) {
        printf("new socket failed. errno: %d, error: %s\n", errno, strerror(errno));
        exit(-);
    }

    serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons();

    // Connect to remote server
    if (connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < ) {
        printf("connection failed. errno: %d, error: %s\n", errno, strerror(errno));
        exit(-);
    }
    emulate_subpackage(sockfd);
    emulate_adheringpackage(sockfd);

    const int HEAD_SIZE = ;
    const char temp[] = "exit";
    memset(buf, , sizeof(buf));
    snprintf(buf, sizeof(buf), "%0.*zu", HEAD_SIZE - , sizeof(temp));
    write(sockfd, buf, HEAD_SIZE);
    write(sockfd, temp, sizeof(temp));

    printf("send complete.\n");
    memset(buf, , sizeof(buf));
    read(sockfd, buf, sizeof(buf));
    printf("receive data: %s\n", buf);
    printf("client finish.\n");

    safe_close(sockfd);
    return ;
}

void safe_close(int &sock) {
    if (sock > ) {
        close(sock);
        sock = -;
    }
}

/**
 * emulate socket data write multi part.
 */
void emulate_subpackage(int sock) {
    printf("emulate_subpackage...\n");
    char text[] = "This is a test case for client send subpackage data. data is not send complete at once.";
    const size_t TEXTSIZE = sizeof(text);
    ssize_t len = ;
    size_t sendsize = , sendsum = ;

    const int HEAD_SIZE = ;
    char buf[] = {};
    snprintf(buf, HEAD_SIZE, "%08zu", TEXTSIZE);
    write(sock, buf, HEAD_SIZE);
    printf("send data size: %s\n", buf);

    do {
        sendsize = ;   //六個位元組多次發送
        if (sendsum + sendsize > TEXTSIZE) {
            sendsize = TEXTSIZE - sendsum;
        }
        len = write(sock, text + sendsum, sendsize);
        if (- == len) {
            printf("send data failed. errno: %d, error: %s\n", errno, strerror(errno));
            return;
        }
        memset(buf, , sizeof(buf));
        snprintf(buf, len + , text + sendsum);
        printf("send data: %s\n", buf);
        sendsum += len;
        sleep();
    } while (sendsum < TEXTSIZE &&  != len);
}

/**
 * emualte socket data write adhering.
 */
void emulate_adheringpackage(int sock) {
    printf("emulate_adheringpackage...\n");
    const int HEAD_SIZE = ;
    char buf[] = {};
    char text[] = {};
    char *pstart = buf;

    // append text
    memset(text, , sizeof(text));
    snprintf(text, sizeof(text), "Hello ");
    snprintf(pstart, HEAD_SIZE, "%08zu", strlen(text) + );
    pstart += HEAD_SIZE;
    snprintf(pstart, strlen(text) + , "%s", text);
    pstart += strlen(text) + ;

    // append text
    memset(text, , sizeof(text));
    snprintf(text, sizeof(text), "I'm lucky.");
    snprintf(pstart, HEAD_SIZE, "%08zu", strlen(text) + );
    pstart += HEAD_SIZE;
    snprintf(pstart, strlen(text) + , "%s", text);
    pstart += strlen(text) + ;

    // append text
    memset(text, , sizeof(text));
    snprintf(text, sizeof(text), "Nice too me you");
    snprintf(pstart, HEAD_SIZE, "%08zu", strlen(text) + );
    pstart += HEAD_SIZE;
    snprintf(pstart, strlen(text) + , "%s", text);
    pstart += strlen(text) + ;
    write(sock, buf, pstart - buf);
}


server.cpp


#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <errno.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <unistd.h>

void newclient(int sock);
bool readPack(int sock, char* buf, size_t len);
void safe_close(int &sock);

int main(int argc, char *argv[]) {
    int sockfd = -, newsockfd = -;
    socklen_t c = ;
    struct sockaddr_in serv_addr, cli_addr;

    // Create socket
    sockfd = socket(AF_INET, SOCK_STREAM, );
    if (- == sockfd) {
        printf("new socket failed. errno: %d, error: %s\n", errno, strerror(errno));
        exit(-);
    }

    // Prepare the sockaddr_in structure
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = INADDR_ANY;
    serv_addr.sin_port = htons();

    // bind
    if (bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < ) {
        printf("bind failed. errno: %d, error: %s\n", errno, strerror(errno));
        exit(-);
    }

    // listen
    listen(sockfd, );

    printf("listening...\n");
    // accept new connection.
    c = sizeof(struct sockaddr_in);
    int i = ;
    while (i++ < ) {
        printf("waiting for new socket accept.\n");
        newsockfd = accept(sockfd, (struct sockaddr*)&cli_addr, (socklen_t*)&c);
        if (newsockfd < ) {
            printf("accept connect failed. errno: %d, error: %s\n", errno, strerror(errno));
            safe_close(sockfd);
            exit(-);
        }
        pid_t pid = fork();
        if ( == pid) {
            newclient(newsockfd);
            safe_close(sockfd);
            break;
        } else if (pid > ) {
            safe_close(newsockfd);
        }
    }
    safe_close(sockfd);
    return ;
}

void newclient(int sock) {
    printf("newclient sock fd: %d\n", sock);
    int datasize = ;
    const int HEAD_SIZE = ;
    char buf[] = {};
    while (true) {
        memset(buf, , sizeof(buf));
        if (! readPack(sock, buf, HEAD_SIZE)) {
            printf("read head buffer failed.\n");
            safe_close(sock);
            return;
        }

        datasize = atoi(buf);
        printf("data size: %s, value:%d\n", buf, datasize);
        memset(buf, , sizeof(buf));
        if (! readPack(sock, buf, datasize)) {
            printf("read data buffer failed\n");
            safe_close(sock);
            return;
        }
        printf("data size: %d, text: %s\n", datasize, buf);
        if ( == strcmp(buf, "exit")) {
            break;
        }
    }
    memset(buf, , sizeof(buf));
    snprintf(buf, sizeof(buf), "from server read complete.");
    write(sock, buf, strlen(buf) + );
    printf("newclient sockfd: %d, finish.\n", sock);
    safe_close(sock);
}

void safe_close(int &sock) {
    if (sock > ) {
        close(sock);
        sock = -;
    }
}

/**
 * read size of len from sock into buf.
 */
bool readPack(int sock, char* buf, size_t len) {
    if (NULL == buf || len < ) {
        return false;
    }
    memset(buf, , len); // only reset buffer len.
    ssize_t read_len = , readsum = ;
    do {
        read_len = read(sock, buf + readsum, len - readsum);
        if (- == read_len) { // ignore error case
            return false;
        }
        printf("receive data: %s\n", buf + readsum);
        readsum += read_len;
    } while (readsum < len &&  != read_len);
    return true;
}

結果：

用戶端發送資料
emulate_subpackage...
send data size: 00000088
send data: This i
send data: s a te
send data: st cas
send data: e for
send data: client
send data: send
send data: subpac
send data: kage d
send data: ata. d
send data: ata is
send data: not s
send data: end co
send data: mplete
send data: at on
send data: ce.
emulate_adheringpackage...
send complete.
receive data: from server read complete.
client finish.


服務端模拟接受資料
$ ./server.o 
listening...
waiting for new socket accept.
waiting for new socket accept.
newclient sock fd: 
receive data: 00000088
data size: 00000088, value:88
receive data: This i
receive data: s a te
receive data: st cas
receive data: e for
receive data: client
receive data: send
receive data: subpac
receive data: kage d
receive data: ata. d
receive data: ata is
receive data: not s
receive data: end co
receive data: mplete
receive data: at on
receive data: ce.
data size: 88, text: This is a test case for client send subpackage data. data is not send complete at once.
receive data: 00000007
data size: 00000007, value:7
receive data: Hello
data size: 7, text: Hello
receive data: 00000011
data size: 00000011, value:11
receive data: I'm lucky.
data size: 11, text: I'm lucky.
receive data: 00000016
data size: 00000016, value:16
receive data: Nice too me you
data size: 16, text: Nice too me you
receive data: 00000005
data size: 00000005, value:5
receive data: exit
data size: 5, text: exit
newclient sockfd: , finish.
C和C++ 網絡程式設計 tcp 粘包
上一篇: 樹形和仿樹形下拉框
下一篇: 微信小程式button修改樣式無效

繼續閱讀