計算機網絡:TCP套接字通信

原創 哥不帅但很坏 2020-02-21 00:56

預備知識

套接字

套接字(socket）這個詞可以表示很多概念：在TCP/IP協議中，”IP+地址+TCP/UDP端口號”唯一標示網絡通訊中的一個進程，IP地址+端口號”就稱爲socket。

網絡字節序

網絡中要實現通信，少不了數據的傳輸。所以這裏就引入了網絡字節序的概念。
在前邊的學習中，我們接觸到大端和小端的概念。小端：數據的地位在低地址，高位在高地址；大端：數據的低位在高地址，高位在低地址。網絡數據流同樣也有大端和小端之分。網絡數據流先發出的是低地址，後發出的是高地址。TCP/IP規定，網絡數據流採用大端字節序，即就是低位在高地址。我們之所以會說到大端和小端？是因爲，網絡通信的時候必須知道端口號，如果發送端是大端字節序，接收端是小端字節序，那麼最後看到的端口號就是不正確的端口號，所以，我們必須將端口號在發送端和接收端之間轉換成統一的字節序形式。
爲使網絡程序具有可移植性,使同樣的C代碼在大端和小端計算機上編譯後都能正常運行,可以調用以下庫函數做網絡字節序和主機字節序的轉換。

#include <arpa/inet.h>
uint32_t htonl(uint32_t hostlong); //主機字節序轉爲網絡字節序，long類型
uint16_t htons(uint16_t hostshort); //主機字節序爲網絡字節序，short類型
uint32_t ntohl(uint32_t netlong); //網絡節序轉爲主機字節序，long類型
uint16_t ntohs(uint16_t netshort); //主機節序轉爲網絡字節序，short類型

socket編程的操作函數

1.套接字創建函數sockt:
這裏寫圖片描述
函數功能：創建套接字。
參數：
(1)domain：表示建立的socket的類型，可選擇的類型如下：
這裏寫圖片描述
對於IPv4，參數指定爲AF_NET
(2)type：表示的是傳輸的數據是 數據報傳輸還是字節流傳輸，可選的類型如下：

這裏寫圖片描述
對於TCP協議，type參數指定爲SOCK_STREAM，表示面向流的傳輸協議。
如果是UDP協議，type參數指定爲SOCK_DGRAM表示面向數據報的協議。
(3)protocol：表示創建的方式，我們在這裏把他置爲0。
返回值：
成功返回一個文件描述符，失敗返回-1。

2.服務器綁定函數bind
這裏寫圖片描述
函數功能：服務器程序所監聽的網絡地址和端口號通常是固定不變的，客戶端程序得知服務器程序的地址和端口號後就可以向服務器發起連接，因此服務器需要調用bind綁定一個固定的網絡地址和端口號。
參數：
(1)sockfd:服務器的套接字，也就是socket函數的返回結果。
(2)addr:是socket服務器的地址內容，結構體內的變量則去填寫ip地址和端口號。而sockaddr_in這個結構體成員如下：
這裏寫圖片描述
這裏有設計到了字符串與in_addr的轉換：
這裏寫圖片描述
(3)addrlen：指定結構體的長度。
返回值：成功返回0，失敗返回-1。

3.設置監聽狀態函數listen
這裏寫圖片描述
函數功能：用來設置sockfd套接字爲監聽狀態的，用來監聽客戶端的連接。
參數：
backlog:表示的是服務器連接達到最大的數量之後，還可以放到等待隊列的連接個數，所以一般不要設太大。
返回值：成功返回0，失敗返回-1。

4.請求連接函數connect
這裏寫圖片描述
函數功能：用於客戶端，用來請求對服務器的連接。
參數：
sockfd表示的表示的是要鏈接到服務器的客戶端套接字。
參數addr表示的是服務器的地址與端口號；
參數addrlen表示的是addr的大小一般使用sizeof得到。

5.接受連接函數accept
這裏寫圖片描述
函數功能：三次握手完成後，服務器調用accept()接受連接，如果是服務器調用accept()時還沒有客戶端的連接請求，就阻塞等待直到有客戶端連接上來。
參數：
sockfd：已經創建好的文件描述符，也是監聽套接字。
addr：輸出型參數，獲取客戶端的信息(IP地址，端口號等)。
addrlen：是一個傳入傳出參數，傳入的是調用這提供的緩衝區addr的長度以避免緩衝區溢出問題，傳出的是客戶端地址結構體的實際長度(有可能沒有佔滿調用者提供的緩衝區)。
返回值：成功返回一個文件描述符，是真正的用於通信的桃姐子。失敗返回-1。

單進程的套接字TCP通信

server.c:

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>


void Usage(const char* name)
{
    printf("Usage:%s [IpAddress] [port]\n",name);
}

int StartUp(int port, const char* ip)
{
    int ListenSock = socket(AF_INET,SOCK_STREAM,0); 
    if(ListenSock < 0)
    {
        perror("socket");
        return 1;
    }

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);

    if(bind(ListenSock,(struct sockaddr*)&local,sizeof(local)) < 0)
    {
        perror("bind");
        return 2;
    }

    if(listen(ListenSock,5) < 0)
    {
        perror("listen");
        return 3;
    }
    return ListenSock;
}

int main(int argc,const char* argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        return 1;
    }

    int listenSock = StartUp(atoi(argv[2]),argv[1]);
    struct sockaddr_in client;
    socket_t len = sizeof(client);
    while(1)
    {
        int sock = accept(listenSock,(struct sockaddr*)&client,&len);//獲取客戶機的信息
        if(sock < 0)
        {
            perror("accept");
            continue;
        }
        printf("Get a client,IP is %s,port is %d\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));
        char buf[1024];
        while(1)
        {
            ssize_t s = read(sock,buf,sizeof(buf)-1);//從服務器讀數據
             if(s == 0)
            {
                //數據已經讀完了，客戶端不發送數據了
                printf("client is quit!\n");
                return 2;
            }
             else if(s <0)
            {
                perror("read");
                return 3;
            }
             else
            {
                buf[s] = 0;
                printf("client# %s\n",buf);
            //  write(sock, buf, strlen(buf));

                printf("say: ");
                fflush(stdout);
                ssize_t _s = read(0,buf,sizeof(buf)-1);
                if(_s <= 0)
                {
                    perror("read");
                    return 1;
                }
                buf[_s-1]=0;
                write(sock,buf,sizeof(buf)-1);
            }
        }
    close(sock);
    }

    return 0;
}

client.c:

#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<string.h>


void Usage(const char* name)
{
    printf("Usage:%s [IpAddress] [port]\n",name);
}


int main(int argc,const char* argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        return 1;
    }

    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock < 0)
    {
        perror("socke");
        return 2;
    }

    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);

    if(connect(sock,(struct sockaddr*)&server,sizeof(server)) < 0)
    {
        perror("connect");
        return 3;
    }

    //printf("connect success!\n");
    char buf[1024];
    while(1)
    {
        printf("send# ");
        fflush(stdout);
        ssize_t s = read(0,buf,sizeof(buf)-1);
        if(s <= 0)
        {
            perror("read");
            return 4;
        }
        buf[s-1] = 0;
        write(sock,buf,strlen(buf));

        ssize_t _s = read(sock, buf, sizeof(buf)-1);
        if(_s == 0)
        {
            printf("server quit\n");
            break;
        }
        else if(_s < 0)
        {
            perror("read");
            return 5;
        }
        else
        {
            buf[s]=0;
            printf("server #: %s\n", buf);
        }
    }
    close(sock);
    return 0;
}

多進程套接字TCP通信

上邊的代碼，只可以一個客戶端進行發送數據，而在實際的應用中，，都是會出現多個客戶端給服務器發送數據，所以，上邊的實現並不實用。所以，我們可以實現一個多進程的socket通信，以實現多個客戶端給服務器發數據。
實現方法：服務器端可以創建多個子進程去處理客戶端發來的信息。當每次收到一個新的客戶端的連接請求的時候，我們就會fork()出一個子進程，父進程用於等待子進程，子進程用於執行 讀客戶端發的數據 的操作。細心的你可能會發現，我們在子進程讀取信息之前還進行了一次fork()，這是爲什麼呢？其實，我們用子進程fork()出一個孫子進程，終止掉兒子進程，兒子進程被它的父進程回收，此時的孫子進程就是一個孤兒進程，被1號進程領養。這樣做的目的就是，不要讓兒子進程等待孫子進程太久而消耗太多的系統資源。
代碼實現：
server.c:

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>

void Usage(const char* name)
{
    printf("Usage:%s [IP] [port]\n",name);
}

int StartUp(int port, const char* ip)
{
    int ListenSock = socket(AF_INET,SOCK_STREAM,0);
    if(ListenSock < 0)
    {
        perror("socket");
        return 1;
    }
    int opt = 1;
    setsockopt(ListenSock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);

    if(bind(ListenSock,(struct sockaddr*)&local,sizeof(local))<0)
    {
        perror("bind");
        return 2;
    }
    if(listen(ListenSock,5) < 0)
    {
        perror("listen");
        return 3;
    }
    return ListenSock;
}

int main(int argc,const char* argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        return 1;
    }

    int listenSock = StartUp(atoi(argv[2]),argv[1]);
    struct sockaddr_in client;
    socklen_t len = sizeof(client);
    while(1)
    {
        int sock = accept(listenSock,(struct sockaddr*)&client,&len);
        if(sock < 0)
        {
            perror("accept");
            continue;
        }

        printf("get a client is %s,port is %d\n",inet_ntoa(client.sin_addr),\
                ntohs(client.sin_port));
        int id = fork();
        if(id > 0)
        {
            close(sock);
            while(waitpid(-1,NULL,WNOHANG) > 0);
            continue;
        }
        else
        {
            close(listenSock);
            if(fork() > 0)
            {
                exit(0);
            }
            char buf[1024];
            while(1)
            {
                ssize_t s = read(sock,buf,sizeof(buf)-1);  //服務器進行讀數據
                if(s > 0)
                {
                    buf[s] = 0;
                    printf("client# %s\n",buf);
                }
                else
                {
                    //數據已經讀完了，客戶端不發送數據了
                    printf("client is quit!\n");
                    break;
                }
            }
            close(sock);
            break;
        }
    }
    return 0;
}

client.c

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>

void Usage(const char* name)
{
    printf("Usage:%s [IP] [port]",name);
}
int main(int argc,const char* argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        return 1;
    }

    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock < 0)
    {
        perror("socket");
        return 2;
    }

    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);

    if(connect(sock,(struct sockaddr*)&server,sizeof(server)) < 0)
    {
        perror("connec");
        return 3;
    }
    char buf[1024];
    while(1)
    {
        printf("send# ");
        fflush(stdout);
        ssize_t s = read(0,buf,sizeof(buf)-1);
        if(s < 0)
        {
            perror("read");
            break;
        }
        buf[s-1] = 0;
        write(sock,buf,s);
    }
    close(sock);
    return 0;
}

多線程的套接字通信

實現方法：
主線程中創建出一個新線程，新線程的執行函數是讀取信息。類似於上邊的多進程間的通信，我們可以將新的線程進行分離，分離之後的線程就不需要主線程去等待，而是由操作系統區回收。（這裏我們不可以join新線程，如果這樣做的話，主線程還是需要花費很長的時間去等待，所以，新的線程還是由系統去回收） 。
代碼實現：
server.c

#include<stdio.h>
#include<stdlib.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<pthread.h>

void Usage(const char* name)
{
    printf("Usage is %s [IP] [port]\n",name);
}

int StartUp(int port,const char* ip)
{
    int ListenSock = socket(AF_INET,SOCK_STREAM,0);
    if(ListenSock < 0)
    {
        perror("socket");
        return 1;
    }

    int opt = 1;
    setsockopt(ListenSock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);
    if(bind(ListenSock,(struct sockaddr*)&local,sizeof(local)) < 0)
    {
        perror("bind");
        return 2;
    }
    if(listen(ListenSock,5) < 0)
    {
        perror(("listen"));
        return 3;
    }
    return ListenSock;
}

void* thread_hander(void* arg)
{
    int sock = *((int*)arg);
    char buf[1024];
    while(1)
    {
        ssize_t _s  = read(sock,buf,sizeof(buf)-1);
        if(_s > 0)
        {
            buf[_s-1]=0;
            printf("client say# %s\n",buf);
            if(write(sock,buf,sizeof(buf)-1) < 0)
            {
                break;
            }
        }
        else if(_s == 0)
        {
            printf("client is quit!\n");
            break;
        }
        else
        {
            perror("read");
            break;
        }
    }
    close(sock);
}

int main(int argc,const char* argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        return 1;
    }
    int listenSock = StartUp(atoi(argv[2]),argv[1]);
    struct sockaddr_in client;
    int len = 0;
    while(1)
    {
        int sock = accept(listenSock,(struct sockaddr*)&client,&len);
        if(sock < 0)
        {
            perror("accept");
            continue;
        }
        printf("Get a client! IP is %d\n,port is %d\n",inet_ntoa(client.sin_addr),\
                ntohs(client.sin_port));
        pthread_t tid;
        int ret = pthread_create(&tid,NULL,thread_hander,&sock);
        if(ret < 0)
        {
            perror("pthread_create");
            return 3;
        }
        pthread_detach(tid);
    }
    return 0;
}

server.c:

#include<stdio.h>
#include<stdlib.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include<sys/socket.h>

void Usage(const char* name)
{
    printf("Usage is %s [IP] [port]\n",name);
}

int main(int argc,const char* argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        return 1;
    }
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock < 0)
    {
        perror("socket");
        return 2;
    }
    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);
    int ret = connect(sock,(struct sockaddr*)&server,sizeof(server));
    if(ret < 0)
    {
        perror("connect");
        return 3;
    }
    char buf[1024];
    while(1)
    {
        printf("send# ");
        fflush(stdout);
        ssize_t _s = read(0,buf,sizeof(buf)-1);
        if(_s > 0)
        {
            buf[_s -1 ] = 0;
            if(write(sock,buf,sizeof(buf)-1) < 0)
            {
                break;
            }
            ssize_t s = read(sock,buf,sizeof(buf)-1);
            if(s > 0)
            {
                buf[s] = 0;
                printf("server echo# %s\n",buf);
            }
        }
        else
        {
            perror("read");
            return 4;
        }
    }
    return 0;
}
哥不帥但很壞
發佈了103 篇原創文章 · 獲贊 53 · 訪問量 15萬+
私信 關注
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

計網課設 C++實現 FTP客戶端 和 服務器端

文章目錄一、FTP課本知識1.1 概述1.2 基本工作原理二、課設要求三、課設完成流程四、一些知識點五、代碼5.1client5.2server六、運行截圖6.1 開始6.2 用user和pass指令登錄6.3 pwd 顯示當前文

Authur_gyc 2020-07-08 11:53:53

爲你揭開 Restful 的面紗

一，前言 其實，我懷疑你並不瞭解 Restful ，不過沒關係，今天，就讓我來爲大家揭開 Restful 的面紗，帶大家看一些深層次的東西吧。 二，什麼是 Restful？ Restful 是一種最流行的互聯網架構。在介紹 Res

Geffin 2020-07-08 10:04:51

計算機網絡複習（二）

接上一篇計算機網絡複習（一） HTTP的報文結構 HTTP的請求協議有哪些 HTTP的狀態碼 Session和Cookie的區別 儲存位置：Cookie是客戶端會話技術，數據保存在客戶端，Session是服務器端會話技術，

骑士逸 2020-07-08 08:51:37

IPsec 3 IP安全 P123

aiworenyanzhousuanfa 2020-07-08 06:53:07

無線局域網的安全 web 802.11 802.11i P126

        作爲無線網絡，它在實現加密的時候，跟有線網絡有一些比較特殊的地方，無線網絡在鏈路層的可靠性比較差，容易造成一些數據差錯，甚至一些數據丟失，那麼因此呢，作爲web在設計的時候提出要實現自同步，所謂的自同步，事實上就是對於每

aiworenyanzhousuanfa 2020-07-08 06:52:54

DPDK單生產者入隊單消費者出隊

摘自 深入淺出DPDK

rtoax 2020-07-08 06:34:35

DPDK網絡處理模塊劃分

摘自 深入淺出DPDK

rtoax 2020-07-08 06:34:35

向量封包處理器（VPP）如何運作

目錄 FD.io背後的技術 硬件加速 FD.io背後的技術 FD.io的核心是矢量數據包處理（VPP）。 從2002年開始開發，VPP是當前在運輸產品中運行的生產代碼。它在x86服務器和嵌入式設備上的x86，ARM和Power架構等多種架

rtoax 2020-07-08 06:34:35

The Vector Packet Processor (VPP)的安裝

目錄 How to Install VPP Update the OS Point to the Repository Get the key: Install the Mandatory Packages Install the Opt

rtoax 2020-07-08 06:34:33

【轉】Linux內核報文收發

趙佔旭的博客 Linux內核報文收發-網卡部分 https://zhaozhanxu.com/2016/07/12/Linux/2016-07-12-Linux-Kernel-Pkts_Processing1/ Linux內核報文收發-2

rtoax 2020-07-08 06:34:31

向量封包處理器（VPP）特點

目錄 功能詳細信息： 基於ACL的轉發 安全組的ACL 地址解析協議 鄰接 雙向轉發檢測 位索引顯式複製 粘接 緩衝區元數據更改跟蹤器 對靜態http或https服務器的內置URL支持 警察 分類 數據平面對象 動態主機配置協議 GPRS

rtoax 2020-07-08 06:34:31

DPDK報文收發 run to completion, pipeline

摘自 深入淺出DPDK

rtoax 2020-07-08 06:34:31

DPDK官方中文文檔

DPDK參考文檔[中]： https://dpdk-docs.readthedocs.io/en/latest/linux_gsg/index.html

rtoax 2020-07-08 06:34:31

Setup the FD.io Repository - Centos 7

目錄 Update the OS Package Cloud Repository Install VPP RPMs Starting VPP Uninstall the VPP RPMs Update the OS Before sta

rtoax 2020-07-08 06:34:31

【計算機網絡】第七章：[網絡層]網絡協議（Part2.網絡協議）

CN.StudyLog.Ch7.Network Layer.網絡層 （Part2.網絡層協議）ICMP協議TTL過期差錯報文目標不可到達路由重定向ping命令tracert/pathping命令ARP協議ARP欺騙IGMP協議組播

Chahot 2020-07-08 06:26:58