1.ip & port

1.1 ip地址

IP地址（Internet Protocol Address）是指互聯網協議地址，又譯為網際協議地址，

IP地址就像家庭地址一樣，當你給別人寫信時，需要寫上收信地址和發信地址，
收信地址就相當于目的ip地址，
發信地址就相當于源ip地址，

1.2 ip地址的本質

一個IP地址實際上就是一個32位無符號整數，網路程式將IP地址存放在struct in_addrIP地址結構體中，

struct in_addr {

    in_addr_t s_addr;

};

1.3 ip地址的分類

1. A類IP地址：A類IP地址就由1位元組的網路地址和3位元組主機地址組成，網路地址的最高位必須是“0”，A類網路地址數量較少，有126個網路(2^7 - 2)，減2是因為，‘’0.0.0.0‘’對應為當前主機，127.255.255.255為廣播地址，A類網路中最大主機數為16777214 (2^?24-2)，減2是因為，主機號為全0為網路地址，主機號為全1表示為廣播地址，
2. B類IP地址：B類IP地址由2位元組的網路地址和2位元組的主機地址組成，其中網路地址的最高兩位必須為10，B類網路地址數量有16384個網路(2^14)，128.0.0.0已經可以被指派，B類網路中最大主機數為65534 (2^16-2)，減2是因為，主機號為全0為網路地址，主機號為全1表示為廣播地址，
3. C類IP地址：C類IP地址由3位元組的網路地址和1位元組的主機地址組成，網路地址的最高位必須為110，C類網路地址中192.0.0.0為保留地址不可指派，因此可以指派的網路總數為2097151（2^ 21-1）個，C類地址的每個網路上最大主機數為254(2^ 8-2)，減2是因為，主機號為全0為網路地址，主機號為全1表示為廣播地址，
4. D類IP地址：D類IP地址在歷史上被叫做多播地址(multicast address)，即組播地址，在以太網中，多播地址命名了一組應該在這個網路中應用接收到一個分組的站點，多播地址的最高位必須是“1110”，范圍從224.0.0.0到239.255.255.255，

特殊的IP地址：

1. 每一個位元組都為0的地址“0.0.0.0”對應為當前主機；
2. IP地址中的每一個位元組都為1的IP地址（“255．255．255．255”）是當前子網的廣播地址；
3. IP地址中凡是以“11110”開頭的E類IP地址都保留用于將來和實驗使用，
4. IP地址中不能以十進制“127”作為開頭，該類地址中數字127．0．0．1到127．255．255．255用于回路測驗
5. 網路ID的第一個6位組也不能全置為“0”，全“0”表示本地網路，

1.4 port

計算機 “埠”可以認為是計算機與外界通訊交流的出口，

其中硬體領域的埠又稱介面，如： USB 埠，串行埠等，

軟體領域的埠一般指網路中面向連接服務和無連接服務的通信協議埠，是一種抽象的軟體結構，包括一些資料結構和 I / O （基本輸入輸出）緩沖區，

按埠號可分為 3 大類：

（ 1 ）公認埠（Well Known Ports ）：從0 到1023 ，它們緊密系結（binding ）于一些服務，通常這些埠的通訊明確表示了某種服務的協議，例如：80 埠實際上總是HTTP 通訊，

（ 2 ）注冊埠（注冊埠）：從1024 到49151 它們松散地系結于一些服務也就是說有許多服務系結于這些端口，這些埠同樣用于許多其它目的例如，許多系統處理動態埠從1024 左右開始，

（3）動態和 / 或私有埠（動態和/或專用埠）：從49152 到65535 ，理論上，不應為服務分配這些埠實際上，機器通常從1024 起分配動態埠但也有例外，：SUN 的RPC 埠從32768 開始
埠詳解
常用埠大全

一臺機器當中一個埠號可以唯一標識一個行程，而一個行程可以占用多個埠，

1.5 port本質

1. 埠號是一個2位元組16位的整數
2. 埠號用來標識一個行程，告訴OS，當前的這個資料要交給那一個行程來處理
3. IP地址+ 埠號能夠標識網路上的某一臺主機的一個行程

2.位元組序

位元組序是CPU對記憶體的訪問順序，

1. 小端位元組序：低位放在低地址
2. 大端位元組序：低位放在高地址

例：

2.1主機位元組序

指的是機器本身的位元組序，如果為大端則主機位元組序為大端，否則為小端，

2.1.1驗證自己的機器為大端還是小端？

1. 使用聯合體

代碼：

#include <iostream>
using namespace std;

union un{
  int a;
  char b;
}p;

int main()
{
  p.a = 1;
  if(p.b == 1)
    cout << "小端" << endl;
  else 
    cout << "大端" << endl;
  return 0;
}

結果：

2. 使用指標

代碼：

#include <iostream>
using namespace std;


int main()
{
  int a = 1;
  char *p = (char*)&a;
  if(*p == 1)
    cout << "小端" << endl;
  else 
    cout << "大端" << endl;
  return 0;
}

結果：

2.2 網路位元組序

規定網路中傳輸的位元組序為大端， 則小端機器傳輸資料時，需要將資料轉化為大端位元組序進行傳輸，

一般情況下，自己機器上的ip和port都會進行轉化，如何轉化呢？

2.3 ip && port轉化

主機位元組序轉換為網路位元組序：

 #include <arpa/inet.h>
  uint32_t htonl(uint32_t hostlong);//ip轉化
  uint16_t htons(uint16_t hostshort);//port轉化

網路位元組序轉換為主機位元組序：

 #include <arpa/inet.h>
  uint32_t ntohl(uint32_t netlong);//ip轉化
  uint16_t ntohs(uint16_t netshort);//port轉化

不管是網路報頭部分ip或者port，還是要傳輸的真實資料，都需要轉化為網路位元組序，

• 當通信雙方都是小端機器的時候，對于網路報頭當中的ip和port還是必須遵守網路位元組序的格式進行傳輸，否則網路鏈路上面的轉發設備就無法正確的轉發該資料，
• 如果都為小端機器，傳輸的資料可以不用位元組序轉換，

3. TCP與UDP的區別

3.1 TCP特點

TCP協議：面向連接、可靠傳輸、面向位元組流

1. 面向連接：TCP通信雙方在發送給資料之前，需要先建立連接，才能夠發送資料
2. 可靠傳輸：TCP保證傳輸的資料都是可靠有序的到達對端
3. 面向位元組流：①對于傳輸的資料之前是沒有明顯的資料邊界的，②對于接收方而言，在可以接受資料的情況下，可以接受任意位元組的資料

3.2 UDP特點

UDP協議：無連接，不可靠，面向資料報

1. 無連接：UDP通信雙方在發送資料之前，是不需要進行溝通的，客戶端只需要知道服務端的ip和port，即可發送資料
2. 不可靠：不保證資料是可靠到達對端的，并且不保證資料是按序到達的
3. 面向資料報：UDP對于應用層和傳輸層資料遞交的時候，都是整個資料交付的

4.UDP編程

4.1 server服務端

基本流程：創建套接字、系結地址資訊、接收資料、發送資料、關閉套接字

4.2 client 客戶端

基本流程：創建套接字、一般不指定系結地址資訊（讓OS自己系結，這樣可以支持應用多開，否則會有埠沖突）、發送資料、接受資料、關閉套接字

對于UDP而言，一定是客戶端給服務端先發送資料，

4.3 創建套接字介面

int socket(int domain, int type, int protocol);

例：

socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);//采用UDP協議
socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);//采用TCP協議

回傳值：

該介面回傳一個套接字句柄，本質上是一個檔案描述符，
回傳值大于0，創建成功，回傳值小于0，則創建失敗，

代碼示例：

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

int main()
{
  int ret = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
  if(ret < 0)
  {
    perror("socket create failed");
    return -1;
  }
  while(1)
  {}
  return 0;
}

結果：

創建出來的檔案，會一直在閃，是因為該檔案對應了一個內核緩沖區，不是檔案不存在了，

4.3.1 套接字是什么？創建套接字的意義?

套接字：套接字從Linux內核角度來看，一個套接字就是一個通信的端點，從Linux程式的角度來看，套接字就是一個有相應檔案描述符的檔案，
意義：創建套接字是為了將行程和網卡進行系結，行程可以從網卡中接受資料，也可以通過網卡進行發送資料，

4.4 系結地址資訊

4.4.1系結的是什么？

系結ip和port，服務器提供服務，必須讓客戶端知道怎么將資料傳輸給服務端，而網路當中傳輸資料的時候，是按照ip地址和port來進行傳輸的，

ip作用：知道具體是哪一臺主機發送的請求，
port作用：知道具體是哪一臺主機的哪一個行程發送的請求，

4.4.2 介面

#include <sys/socket.h>
int bind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen);

通用的地址資訊結構：

typedef unsigned short  sa_family_t;//兩位元組
struct sockaddr {
        sa_family_t     sa_family;      /* address family, AF_xxx       */
        char            sa_data[14];    /* 14 bytes of protocol address */
};

注意：該結構體占16位元組，是一個通用的地址資訊結構，并不是某一個具體的地址資訊結構，

ipv4地址資訊結構：

typedef uint16_t in_port_t; //埠
typedef uint32_t in_addr_t; //ip
struct in_addr     //ip結構體，占兩個位元組                                                                                                                                                                          
  {
    in_addr_t s_addr;
  };
struct sockaddr_in
  {
    __SOCKADDR_COMMON (sin_);//協議
    in_port_t sin_port;    //埠             
    struct in_addr sin_addr;   //ip         
	//用0填充
    unsigned char sin_zero[sizeof (struct sockaddr) -
                           __SOCKADDR_COMMON_SIZE -
                           sizeof (in_port_t) -
                           sizeof (struct in_addr)];
  };

則在系結ip和port的時候，需要將ipv4地址資訊結構struct sockaddr_in強轉為通用地址資訊結構struct sockaddr，

如圖：

4.4.3 結論

• 當使用ipv4版本的ip協議，寫網路程式，系結地址資訊的時候，需要填充struct sockaddr_in結構體中保存服務器的ip和偵聽埠，
• 在使用bind函式時候，需要將struct sockaddr_in結構體強轉為struct sockaddr結構體
• 對于struct sockaddr_in和struct sockaddr這兩個結構體而言，前面兩個位元組都表示地址域，當強轉struct sockaddr_in結構體傳入內核之后，內核是通過前面兩個位元組（地址域），來確定后續空間如何進行讀取的，
• struct sockaddr結構體是通用地址資訊結構體，AF_UNIX為本機上的行程間通信（此時addrlen長度為110），
• 使用struct sockaddr的好處：bind函式不需要針對特定的協議，準備不同型別的引數，只需要準備一個通用的地址資訊結構體即可，

4.5 UDP發送介面

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                      const struct sockaddr *dest_addr, socklen_t addrlen);

回傳值：

發送成功回傳發送的字符長度，失敗回傳-1，并設定錯誤，

4.6 UDP接收介面

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                        struct sockaddr *src_addr, socklen_t *addrlen);

回傳值：

接收成功回傳接收的字符長度，發生錯誤回傳-1，并設定錯誤，若對端關閉socket描述符，回傳0，

4.7 關閉套接字

int close(int fd);

直接關閉套接字檔案描述符即可，

4.8 server編程

代碼：

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

#include <iostream>
#include <string>
 using namespace std;
int main()
{
  int socket_ret = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
  if(socket_ret < 0)
  {
    perror("socket error");
    return -1;
  }
  struct sockaddr_in addr;//當前服務端的ip，port，協議為ipv4
  addr.sin_family = AF_INET;//協議
  addr.sin_port = htons(9999);//埠，轉換為大端
  addr.sin_addr.s_addr = inet_addr("ip地址");//ip地址，使用inet_addr自動轉換為大端，并且為點分十進制

  int bind_ret = bind(socket_ret, (struct sockaddr*)&addr, sizeof(addr));//系結地址資訊
  if(bind_ret < 0)
  {
    perror("bind error");
    return -1;
  }
  while(1)
  {
    char buf[1024] = {0};
    struct sockaddr_in peer_addr;//對端地址資訊結構體
    socklen_t peer_addr_len = sizeof(peer_addr);//對端長度
    ssize_t recv_size = recvfrom(socket_ret, buf, sizeof(buf) - 1, 0, (struct sockaddr*)&peer_addr, &peer_addr_len);//讀取對端訊息
    if(recv_size < 0)
    {
      perror("recvfrom");
      continue;
    }
    printf("client says: %s\n",buf);

    string s;
    cin >> s;
    ssize_t send_size = sendto(socket_ret, s.c_str(), s.size(), 0, (struct sockaddr*)&peer_addr, peer_addr_len);//回復對端訊息
    if(send_size < 0)
    {
      perror("sendto");
      continue;
    }
  }
  close(socket_ret);
  return 0;
}

使用到的介面輔助介面有：

in_addr_t inet_addr(const char *cp);
uint16_t htons(uint16_t hostshort);

解釋：

inet_addr將字串自動轉換為大端ip地址，并且為點分十進制，
htons將埠轉換為大端，

4.9 client編程

代碼：

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

#include <iostream>
#include <string>
 using namespace std;
int main()
{
  int socket_ret = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
  if(socket_ret < 0)
  {
    perror("socket error");
    return -1;
  }
  // 服務端的地址資訊結構，包含服務端的ip和port
  struct sockaddr_in server_addr;
  server_addr.sin_family = AF_INET;// 協議
  server_addr.sin_port = htons(9999);// 埠
  server_addr.sin_addr.s_addr = inet_addr("ip地址");// ip
  while(1)
  {
    string s;
    cin >> s;
    ssize_t send_size = sendto(socket_ret, s.c_str(), s.size(), 0, (struct sockaddr*)&server_addr, sizeof(server_addr));//發送訊息
    if(send_size < 0)
    {
      perror("sendto");
      continue;
    }

    char buf[1024] = {0};
    ssize_t recv_size = recvfrom(socket_ret, buf, sizeof(buf) - 1, 0, NULL, 0);//接收訊息
    if(recv_size < 0)
    {
      perror("recvfrom");
      continue;
    }
    printf("server says: %s\n",buf);
  }
  close(socket_ret);
  return 0;
}

上述結果：

客戶端先給服務端發送訊息，服務端接收到訊息，然后回復，

netstat -anp查看埠被那個行程占有，

引數解釋：

4.10 封裝UDP編程類

頭檔案：

#ifndef _CLASSOFUDP_HPP_
#define _CLASSOFUDP_HPP_

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

#include <iostream>
#include <string>
using namespace std;


class ClassOfUdp// udp編程類
{
  public:
    ClassOfUdp()//構造
      :_socketfd(-1)
    {}
    ~ClassOfUdp()//析構，關閉套接字
    {
      close(_socketfd);
    }
    int CreateSocket()//創建套接字
    {
      _socketfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
      if(_socketfd < 0)
      {
        perror("socket");
        return -1;
      }
      return 0;
    }
    int BindAddr(string ip, uint16_t port)//系結埠和ip
    {
      struct sockaddr_in addr;
      addr.sin_family = AF_INET;
      addr.sin_port = htons(port);
      addr.sin_addr.s_addr = inet_addr(ip.c_str());
      int ret = bind(_socketfd, (struct sockaddr*)&addr, sizeof(addr));
      if(ret < 0)
      {
        perror("bind");
        return -1;
      }
      return 0;
    }
    int SendTo(string* data, struct sockaddr_in* peer_addr)//發送資料
    {
      ssize_t send_size = sendto(_socketfd, data->c_str(), data->size(), 0, (struct sockaddr*)peer_addr, sizeof(struct sockaddr_in));
      if(send_size < 0)
      {
        perror("sendto");
        return -1;
      }
      return 0;
    }
    int RecvFrom(string* data, struct sockaddr_in* peer_addr)//接收資料
    {
      char buf[1024] = {0};
      socklen_t peer_addr_len = sizeof(struct sockaddr_in);
      ssize_t recv_size = recvfrom(_socketfd, buf, sizeof(buf) - 1, 0, (struct sockaddr*)peer_addr, &peer_addr_len);
      if(recv_size < 0)
      {
        perror("recvform");
        return -1;
      }
      data->append(buf);
      return 0;
    }
  private:
    int _socketfd;//成員
};

#endif

服務端：

#include "../ClassOfUdp.hpp"

int main()
{
  ClassOfUdp UdpOfServer;//服務端類
  string ip("192.168.128.128");//ip地址
  uint16_t port = 9999;//埠
  int ret = UdpOfServer.CreateSocket();//創建套接字
  if(ret < 0)
    return -1;
  ret = UdpOfServer.BindAddr(ip, port);//系結埠
  if(ret < 0)
    return -1;
  while(1)
  {
    string data;
    struct sockaddr_in peer_addr;
    ret = UdpOfServer.RecvFrom(&data, &peer_addr);//接收資料
    if(ret < 0)
      continue;
    printf("client say : %s\n", data.c_str());
    data.clear();
    fflush(stdout);
    cin >> data;
    ret = UdpOfServer.SendTo(&data, &peer_addr);//發送資料
    if(ret < 0)
      continue;
  }
  return 0;
}

客戶端：

#include "../ClassOfUdp.hpp"

int main()
{
  ClassOfUdp UdpOfServer;
  int ret = UdpOfServer.CreateSocket();//創建客戶端套接字
  struct sockaddr_in dest_addr;
  dest_addr.sin_family = AF_INET;
  dest_addr.sin_port = htons(9999);
  dest_addr.sin_addr.s_addr = inet_addr("192.168.128.128");

  while(1)
  {
    string data;
    cin >> data;
    ret = UdpOfServer.SendTo(&data, &dest_addr);//發送資料
    if(ret < 0)
      continue;
    data.clear();
    fflush(stdout);
    ret = UdpOfServer.RecvFrom(&data, &dest_addr);//接收資料，這里可不傳源埠
    if(ret < 0)
      continue;
    printf("server say : %s\n", data.c_str());
    data.clear();
  }
  return 0;
}

代碼結果和未封裝的結果保持一致，這里就不貼代碼結果圖了，有興趣的小伙伴可以演示一下，

5. TCP編程

5.1 server服務端

基本流程：創建套接字、系結地址資訊、監聽、獲取新連接、發送（接收）資料、接收（發送）資料、關閉套接字，

5.2 client服務端

基本流程：創建套接字、不推薦系結地址資訊（可程式多開）、發起連接、發送（接收）資料、接收（發送）資料、關閉套接字，

5.3 創建套接字 && 系結地址資訊

和udp協議保持一樣，就不展開了，

5.4 監聽介面

int listen(int s, int backlog);

當呼叫listen函式之后，也就是告訴內核，當前程式可以接受新的連接了，也就是可以完成三次握手的程序了，
三次握手是網路協議堆疊完成的事情，程式員不需要干涉，連接完成建立的程序是在內核當中完成的，

回傳值：

成功回傳0，失敗回傳-1， 并設定錯誤，

5.5 接受新連接介面

int accept(int s, struct sockaddr *addr, socklen_t *addrlen);

回傳值：

成功回傳的是新創建出來的套接字，

失敗回傳-1，并設定錯誤，

5.6 發起連接介面

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

回傳值：

成功回傳0，失敗回傳-1，并設定錯誤，

5.7 發送資料

int send(int s, const void *msg, size_t len, int flags);

回傳值：

發送成功回傳發送字符長度，否則回傳-1，

5.8 接收資料

ssize_t recv(int sockfd, void *buf, size_t len, int flags);

回傳值：

發送成功回傳接收字符長度，
小于0，發送失敗，
等于0：對端關閉了連接，

5.9 server編程

代碼：

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

#include <iostream>
#include <string>
using namespace std;

int main()
{
  int socket_ret = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);//創建服務端套接字
  if(socket_ret < 0)
  {
    perror("socket");
    return -1;
  }
  struct sockaddr_in addr;
  addr.sin_family = AF_INET;
  addr.sin_port = htons(9999);
  addr.sin_addr.s_addr = inet_addr("0.0.0.0");
  int ret = bind(socket_ret, (struct sockaddr*)&addr, sizeof(addr));//系結地址資訊
  if(ret < 0)
  {
    perror("bind");
    return -1;
  }
  ret = listen(socket_ret, 3);//監聽，最大可完成連接佇列為3個
  if(ret < 0)
  {
    perror("listen");
    return -1;
  }
  int new_sock = accept(socket_ret, NULL, NULL);//接收連接，回傳的是一個套接字
  if(new_sock < 0)
  {
    perror("accept");
    return -1;
  }
  while(1)
  {
    char buf[1024] = {0};
    ssize_t recv_size = recv(new_sock, buf, sizeof(buf) - 1, 0);//接收資料
    if(recv_size < 0)
    {
      perror("recv");
      continue;
    }
    else if(recv_size == 0)//對端關閉了介面
    {
      printf("peersocket shutdown\n");
      close(new_sock);
      close(socket_ret);
      return 0;
    }
    printf("client says: %s\n", buf);
    string s;
    cin >> s;
    ssize_t send_size = send(new_sock, s.c_str(), s.size(), 0);//發送資料
    if(send_size < 0)
    {
      perror("send_size");
      continue;
    }
  }
  return 0;
}

5.10 client編程

代碼：

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

#include <iostream>
#include <string>
using namespace std;

int main()
{
  int socket_ret = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);//創建客戶端套接字
  if(socket_ret < 0)
  {
    perror("socket");
    return -1;
  }
  struct sockaddr_in addr;
  addr.sin_family = AF_INET;
  addr.sin_port = htons(9999);
  addr.sin_addr.s_addr = inet_addr("ip地址");

  int ret = connect(socket_ret, (struct sockaddr*)&addr, sizeof(addr));//連接服務端
  if(ret < 0)
  {
    perror("connect");
    return -1;
  }
  while(1)
  {
    string s;
    cin >> s;
    ssize_t send_size = send(socket_ret, s.c_str(), s.size(), 0);//發送資料
    if(send_size < 0)
    {
      perror("send_size");
      continue;
    }
    char buf[1024] = {0};
    ssize_t recv_size = recv(socket_ret, buf, sizeof(buf) - 1, 0);//接收資料
    if(recv_size < 0)
    {
      perror("recv");
      continue;
    }
    else if(recv_size == 0)
    {
      printf("peersocket shutdown\n");
      close(socket_ret);
      return 0;
    }
    printf("server says: %s\n", buf);
  }
  return 0;
}

結果圖就不放了，有興趣的小伙伴可以將代碼在自己環境下實驗一下，

上述代碼只能進行單執行流網路通信，若要進行多執行流通信，則需要多行程或者多執行緒，

5.11 多行程TCP編程

代碼：

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

#include <iostream>
#include <string>
using namespace std;

void signcall(int signumber)//改變子行程退出信號處理方式，回收子行程資源
{
  wait();//行程等待
}

int main()
{
  int socket_ret = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);//創建套接字
  if(socket_ret < 0)
  {
    perror("socket");
    return -1;
  }
  struct sockaddr_in addr;
  addr.sin_family = AF_INET;
  addr.sin_port = htons(9999);
  addr.sin_addr.s_addr = inet_addr("0.0.0.0");
  int ret = bind(socket_ret, (struct sockaddr*)&addr, sizeof(addr));//系結地址資訊
  if(ret < 0)
  {
    perror("bind");
    return -1;
  }
  ret = listen(socket_ret, 3);//監聽
  if(ret < 0)
  {
    perror("listen");
    return -1;
  }
  signal(17, signcall);//改變子行程信號處理方式
  while(1)
  {
    int new_sock = accept(socket_ret, NULL, NULL);//回傳一個套接字
    if(new_sock < 0)
    {
      perror("accept");
      return -1;
    }
    pid_t pid = fork();//創建子行程
    if(pid < 0)
    {
      perror("fork");
      continue;
    }
    else if(pid == 0)//子行程入口
    {
      while(1)
      {
        close(socket_ret);//關閉偵聽套接字，子行程用不到這個
        char buf[1024] = {0};
        ssize_t recv_size = recv(new_sock, buf, sizeof(buf) - 1, 0);//接收資料
        if(recv_size < 0)
        {
          perror("recv");
          continue;
        }
        else if(recv_size == 0)//對端關閉了埠
        {
          printf("peersocket shutdown\n");
          close(new_sock);
          return 0;
        }
        printf("client says: %s\n", buf);
        string s;
        cin >> s;
        ssize_t send_size = send(new_sock, s.c_str(), s.size(), 0);//發送資料
        if(send_size < 0)
        {
          perror("send_size");
          continue;
        }
      }
    }
    close(new_sock);
  }
  //close(socket_ret);
  return 0;
}

5.12 多執行緒TCP編程

代碼：

#include <stdio.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/signal.h>
#include <signal.h>
#include <pthread.h>

#include <iostream>
#include <string>
using namespace std;

struct NewSock
{
  int _new_sock;
};

void* TcpTheadStart(void *arg)//執行緒入口函式
{
  pthread_detach(pthread_self());//分離自己，可自己回收資源
  NewSock* sockfd = (NewSock*)arg;//強轉
  while(1)
  {
    char buf[1024] = {0};
    ssize_t recv_size = recv(sockfd->_new_sock, buf, sizeof(buf) - 1, 0);//接收資料
    if(recv_size < 0)
    {
      perror("recv");
      continue;
    }
    else if(recv_size == 0)//對端關閉了套接字
    {
      printf("peersocket shutdown\n");
      close(sockfd->_new_sock);//關閉該套接字
      delete sockfd;//釋放變數，避免記憶體泄漏
      
      return 0;
    }
    printf("client says: %s\n", buf);
    string s;
    cin >> s;
    ssize_t send_size = send(sockfd->_new_sock, s.c_str(), s.size(), 0);//發送資料
    if(send_size < 0)
    {
      perror("send_size");
      continue;
    }
  }
  return NULL;
}

int main()
{
  int socket_ret = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);//創建服務端套接字，偵聽套接字
  if(socket_ret < 0)
  {
    perror("socket");
    return -1;
  }
  struct sockaddr_in addr;
  addr.sin_family = AF_INET;
  addr.sin_port = htons(9999);
  addr.sin_addr.s_addr = inet_addr("0.0.0.0");
  int ret = bind(socket_ret, (struct sockaddr*)&addr, sizeof(addr));//系結地址資訊
  if(ret < 0)
  {
    perror("bind");
    return -1;
  }
  ret = listen(socket_ret, 3);//監聽
  if(ret < 0)
  {
    perror("listen");
    return -1;
  }
  while(1)
  {
    int new_sock = accept(socket_ret, NULL, NULL);//完成連接，回傳一個套接字
    if(new_sock < 0)
    {
      perror("accept");
      return -1;
    }
    pthread_t tid;//執行緒id
    NewSock *tmp = new NewSock();//執行緒中不能傳入臨時變數，則new一個，然后傳遞
    tmp->_new_sock = new_sock;
    ret = pthread_create(&tid, NULL, TcpTheadStart, (void*)tmp);//創建執行緒
    if(ret < 0)
    {
      perror("pthread_create");
      continue;
    }
  }
  return 0;
}

上述程式均在博主的linux環境下除錯成功，若有問題可以私信或者評論區留言，，，