socket進程通信

一、socket簡介

socket，即套接字是一種通信機制，憑借這種機制，客戶/服務器（即要進行通信的進程）系統的開發工作既可以在本地單機上進行，也可以跨網絡進行。

也就是說它可以讓不在同一台計算機但通過網絡連接計算機上的進程進行通信。也因為這樣，套接字明確地將客戶端和服務器區分開來。
 
二、套接字的屬性
套接字的特性由3個屬性確定，它們分別是：域、類型和協議。
1、套接字的域
它指定套接字通信中使用的網絡介質，最常見的套接字域是AF_INET，它指的是Internet網絡。

當客戶使用套接字進行跨網絡的連接時，它就需要用到服務器計算機的IP地址和端口來指定一台聯網機器上的某個特定服務，

所以在使用socket作為通信的終點，服務器應用程序必須在開始通信之前綁定一個端口，服務器在指定的端口等待客戶的連接。

另一個域AF_UNIX表示UNIX文件系統，它就是文件輸入/輸出，而它的地址就是文件名。

2、套接字類型
因特網提供了兩種通信機制：流（stream）和數據報（datagram），因而套接字的類型也就分為流套接字和數據報套接字。這里主要講流套接字。
流套接字由類型SOCK_STREAM指定，它們是在AF_INET域中通過TCP/IP連接實現，同時也是AF_UNIX中常用的套接字類型。

流套接字提供的是一個有序、可靠、雙向字節流的連接，因此發送的數據可以確保不會丟失、重復或亂序到達，而且它還有一定的出錯后重新發送的機制。
與流套接字相對的是由類型SOCK_DGRAM指定的數據報套接字，它不需要建立連接和維持一個連接，它們在AF_INET中通常是通過UDP/IP協議實現的。

它對可以發送的數據的長度有限制，數據報作為一個單獨的網絡消息被傳輸,它可能會丟失、復制或錯亂到達，

UDP不是一個可靠的協議，但是它的速度比較高，因為它並一需要總是要建立和維持一個連接。
 
3、套接字協議
只要底層的傳輸機制允許不止一個協議來提供要求的套接字類型，我們就可以為套接字選擇一個特定的協議。通常只需要使用默認值。

三、套接字地址
每個套接字都有其自己的地址格式，對於AF_UNIX域套接字（本地通信）來說，它的地址由結構sockaddr_un來描述，該結構定義在頭文件sys/un.h中，它的定義如下：

struct sockaddr_un{  
    sa_family_t sun_family;//AF_UNIX，它是一個短整型  
    char        sum_path[];//路徑名  
};  

對於AF_INET域套接字（不同主機通信）來說，它的地址結構由sockaddr_in來描述，它至少包括以下幾個成員：

struct sockaddr_in{  
    short int            sin_family;//AF_INET  
    unsigned short int    sin_port;//端口號  
    struct in_addr        sin_addr;//IP地址  
}; 

上面我們已經知道網絡中的進程是通過socket來通信的，那什么是socket呢？

socket起源於Unix，而Unix/Linux基本哲學之一就是“一切皆文件”，都可以用“打開open –> 讀寫write/read –> 關閉close”模式來操作。

我的理解就是Socket就是該模式的一個實現，socket即是一種特殊的文件，一些socket函數就是對其進行的操作（讀/寫IO、打開、關閉）。

四、套接字函數

1、socket()函數

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

socket函數對應於普通文件的打開操作。普通文件的打開操作返回一個文件描述字，而socket()用於創建一個socket描述符（socket descriptor），它唯一標識一個socket。

這個socket描述字跟文件描述字一樣，后續的操作都有用到它，把它作為參數，通過它來進行一些讀寫操作。

正如可以給fopen的傳入不同參數值，以打開不同的文件。創建socket的時候，也可以指定不同的參數創建不同的socket描述符，

socket函數的三個參數分別為：
　　• domain：即協議域，又稱為協議族（family）。常用的協議族有，AF_INET、AF_INET6、AF_UNIX（Unix域socket）、AF_ROUTE等等。

　　　　　　　　協議族決定了socket的地址類型，在通信中必須采用對應的地址，如

　　　　　　　　AF_INET決定了要用ipv4地址（32位的）與端口號（16位的）的組合、AF_UNIX決定了要用一個絕對路徑名作為地址。

　　　　　　　　AF_UNIX/PF_UNIX/AF_LOCAL/PF_LOCAL：Unix進程通信協議（本地通信）；
　　　　　　　　AF_INET/PF_INET：IPv4網絡協議；（不同主機通信）
　　　　　　　　AF_PACKET/PF_PACKET：初級封包接口；（自定義數據包）

• type：指定socket類型。常用的socket類型有，SOCK_STREAM、SOCK_DGRAM、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等等。
　　　　1）.流套接字(SOCK_STREAM)
　　　　　　流套接字用於提供面向連接、可靠的數據傳輸服務。該服務將保證數據能夠實現無差錯、無重復送，並按順序接收。

　　　　　　流套接字之所以能夠實現可靠的數據服務，原因在於其使用了傳輸控制協議，即TCP(The Transmission Control Protocol)協議  。
　　　　2）.數據報套接字(SOCK_DGRAM)
　　　　　　數據報套接字提供一種無連接的服務。該服務並不能保證數據傳輸的可靠性,數據有可能在傳輸過程中丟失或出現數據重復，且無法保證順序地接收到數據。

　　　　　　數據報套接字使用UDP( User DatagramProtocol)協議進行數據的傳輸。

　　　　　　由於數據報套接字不能保證數據傳輸的可靠性，對於有可能出現的數據丟失情況，需要在程序中做相應的處理 。
　　　　3）.原始套接字(SOCK_RAW)
　　　　　　原始套接字與標准套接字的區別在於：原始套接字可以讀寫內核沒有處理的IP數據包，而流套接字只能讀取TCP協議的數據，

　　　　　　數據報套接字只能讀取UDP協議的數據。因此，如果要訪問其他協議發送的數據必須使用原始套接  。
• protocol：故名思意，就是指定協議。常用的協議有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，

　　　　它們分別對應TCP傳輸協議、UDP傳輸協議、STCP傳輸協議、TIPC傳輸協議。

注意：網絡字節序與主機字節序

主機字節序就是我們平常說的大端和小端模式：不同的CPU有不同的字節序類型，這些字節序是指整數在內存中保存的順序，這個叫做主機序。

引用標准的Big-Endian和Little-Endian的定義如下：
　　a) Little-Endian就是低位字節排放在內存的低地址端，高位字節排放在內存的高地址端。
　　b) Big-Endian就是高位字節排放在內存的低地址端，低位字節排放在內存的高地址端。
網絡字節序：4個字節的32 bit值以下面的次序傳輸：首先是0～7bit，其次8～15bit，然后16～23bit，最后是24~31bit。

這種傳輸次序稱作大端字節序。由於TCP/IP首部中所有的二進制整數在網絡中傳輸時都要求以這種次序，因此它又稱作網絡字節序。

字節序，顧名思義字節的順序，就是大於一個字節類型的數據在內存中的存放順序，一個字節的數據沒有順序的問題了。
所以： 在將一個地址綁定到socket的時候，請先將主機字節序轉換成為網絡字節序，而不要假定主機字節序跟網絡字節序一樣使用的是Big-Endian。

由於 這個問題曾引發過血案！公司項目代碼中由於存在這個問題，導致了很多莫名其妙的問題，所以請謹記對主機字節序不要做任何假定，務必將其轉化為網絡字節序再 賦給socket。
常用字節轉化函數：

u_long htonl(u_long hostlong)：將unsigned long類型主機字節序轉換為TCP/IP網絡字節序.
u_short htons(u_short hostshort)：將unsigned short類型主機字節序轉換為TCP/IP網絡字節序.
unsigned long in inet_addr(const char *cp)：將一個點分制的IP地址(如192.168.0.1)轉換為網絡二進制數字
int inet_aton(cont char* cp, struct in_addr *inp)：將網絡地址轉為網絡二進制數字，與inet_addr的區別是，結果不是作為返回值，而是保存形參inp所指的in_addr結構體中
char *inet_ntoa(struct in_addr in)：將網絡二進制數字轉為網絡地址

在使用little endian的系統中 這些函數會把字節序進行轉換。
在使用big endian類型的系統中 這些函數會定義成空宏。
同樣，在網絡程序開發時 或是跨平台開發時，也應該注意保證只用一種字節序。
注意：並不是上面的type和protocol可以隨意組合的，如SOCK_STREAM不可以跟IPPROTO_UDP組合。

當protocol為0時，會自動選擇type類型對應的默認協議。
當我們調用socket創建一個socket時，返回的socket描述字它存在於協議族（address family，AF_XXX）空間中，但沒有一個具體的地址。

如果想要給它賦值一個地址，就必須調用bind()函數，否則就當調用connect()、listen()時系統會自動隨機分配一個端口。

2、bind()函數
正如上面所說bind()函數把一個地址族中的特定地址賦給socket。例如對應AF_INET、AF_INET6就是把一個ipv4或ipv6地址和端口號組合賦給socket。

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

函數的三個參數分別為：
• sockfd：即socket描述字，它是通過socket()函數創建了，唯一標識一個socket。bind()函數就是將給這個描述字綁定一個名字。
• addr：一個const struct sockaddr *指針，指向要綁定給sockfd的協議地址。這個地址結構根據地址創建socket時的地址協議族的不同而不同，如

ipv4對應的是：
struct sockaddr_in {
    sa_family_t    sin_family; 
    in_port_t      sin_port;   
    struct in_addr sin_addr;   
};

struct in_addr {
    uint32_t       s_addr;     
};

ipv6對應的是：
struct sockaddr_in6 { 
    sa_family_t     sin6_family;    
    in_port_t       sin6_port;      
    uint32_t        sin6_flowinfo;  
    struct in6_addr sin6_addr;      
    uint32_t        sin6_scope_id;  
};

struct in6_addr { 
    unsigned char   s6_addr[16];    
};

Unix域對應的是：
#define UNIX_PATH_MAX    108

struct sockaddr_un { 
    sa_family_t sun_family;                
    char        sun_path[UNIX_PATH_MAX];   
};

• addrlen：對應的是地址的長度。
通常服務器在啟動的時候都會綁定一個眾所周知的地址（如ip地址+端口號），用於提供服務，客戶就可以通過它來接連服務器；

而客戶端就不用指定，有系統自動分配一個端口號和自身的ip地址組合。這就是為什么通常服務器端在listen之前會調用bind()，而客戶端就不會調用，而是在connect()時由系統隨機生成一個。

3、listen()、connect()函數
如果作為一個服務器，在調用socket()、bind()之后就會調用listen()來監聽這個socket，如果客戶端這時調用connect()發出連接請求，服務器端就會接收到這個請求。

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

listen函數的第一個參數即為要監聽的socket描述字，第二個參數為相應socket可以排隊的最大連接個數。

socket()函數創建的socket默認是一個主動類型的，listen函數將socket變為被動類型的，等待客戶的連接請求。
connect函數的第一個參數即為客戶端的socket描述字，第二參數為服務器的socket地址，第三個參數為socket地址的長度。

客戶端通過調用connect函數來建立與TCP服務器的連接。
4、accept()函數
TCP服務器端依次調用socket()、bind()、listen()之后，就會監聽指定的socket地址了。

TCP客戶端依次調用socket()、connect()之后就想TCP服務器發送了一個連接請求。

TCP服務器監聽到這個請求之后，就會調用accept()函數取接收請求，這樣連接就建立好了。

之后就可以開始網絡I/O操作了，即類同於普通文件的讀寫I/O操作。

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

accept函數的第一個參數為服務器的socket描述字，第二個參數為指向struct sockaddr *的指針，用於返回客戶端的協議地址，

第三個參數為協議地址的長度。如果accpet成功，那么其返回值是由內核自動生成的一個全新的描述字，代表與返回客戶的TCP連接。
注意：accept的第一個參數為服務器的socket描述字，是服務器開始調用socket()函數生成的，稱為監聽socket描述字；

而accept函數返回的是已連接的socket描述字。一個服務器通常通常僅僅只創建一個監聽socket描述字，它在該服務器的生命周期內一直存在。

內核為每個由服務器進程接受的客戶連接創建了一個已連接socket描述字，當服務器完成了對某個客戶的服務，相應的已連接socket描述字就被關閉。
5、read()、write()等函數
萬事具備只欠東風，至此服務器與客戶已經建立好連接了。可以調用網絡I/O進行讀寫操作了，即實現了網咯中不同進程之間的通信！網絡I/O操作有下面幾組：
• read()/write()
• recv()/send()
• readv()/writev()
• recvmsg()/sendmsg()
• recvfrom()/sendto()

我推薦使用recvmsg()/sendmsg()函數，這兩個函數是最通用的I/O函數，實際上可以把上面的其它函數都替換成這兩個函數。它們的聲明如下：

       #include 
ssize_t read(int fd, void *buf, size_t count);
       ssize_t write(int fd, const void *buf, size_t count);
#include 
       #include 
ssize_t send(int sockfd, const void *buf, size_t len, int flags);
       ssize_t recv(int sockfd, void *buf, size_t len, int flags);
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                      const struct sockaddr *dest_addr, socklen_t addrlen);
       ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                        struct sockaddr *src_addr, socklen_t *addrlen);
ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
       ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

read函數是負責從fd中讀取內容.當讀成功時，read返回實際所讀的字節數，如果返回的值是0表示已經讀到文件的結束了，

小於0表示出現了錯誤。如果錯誤為EINTR說明讀是由中斷引起的，如果是ECONNREST表示網絡連接出了問題。
write函數將buf中的nbytes字節內容寫入文件描述符fd.成功時返回寫的字節 數。失敗時返回-1，並設置errno變量。

在網絡程序中，當我們向套接字文件描述符寫時有倆種可能。

1)write的返回值大於0，表示寫了部分或者是 全部的數據。

2)返回的值小於0，此時出現了錯誤。我們要根據錯誤類型來處理。

如果錯誤為EINTR表示在寫的時候出現了中斷錯誤。如果為EPIPE表示 網絡連接出現了問題(對方已經關閉了連接)。
其它的我就不一一介紹這幾對I/O函數了，具體參見man文檔或者baidu、Google，下面的例子中將使用到send/recv。
6、close()函數
在服務器與客戶端建立連接之后，會進行一些讀寫操作，完成了讀寫操作就要關閉相應的socket描述字，好比操作完打開的文件要調用fclose關閉打開的文件。

int close(int fd);

close一個TCP socket的缺省行為時把該socket標記為以關閉，然后立即返回到調用進程。

該描述字不能再由調用進程使用，也就是說不能再作為read或write的第一個參數。
注意：close操作只是使相應socket描述字的引用計數-1，只有當引用計數為0的時候，才會觸發TCP客戶端向服務器發送終止連接請求。

五、通信流程

1、服務器端
首先服務器應用程序用系統調用socket來創建一個套接安，它是系統分配給該服務器進程的類似文件描述符的資源，它不能與其他的進程共享。
接下來，服務器進程會給套接字起個名字，我們使用系統調用bind來給套接字命名。然后服務器進程就開始等待客戶連接到這個套接字。
然后，系統調用listen來創建一個隊列並將其用於存放來自客戶的進入連接。
最后，服務器通過系統調用accept來接受客戶的連接。它會創建一個與原有的命名套接不同的新套接字，

這個套接字只用於與這個特定客戶端進行通信，而命名套接字（即原先的套接字）則被保留下來繼續處理來自其他客戶的連接。

2、客戶端
基於socket的客戶端比服務器端簡單，同樣，客戶應用程序首先調用socket來創建一個未命名的套接字，

然后將服務器的命名套接字作為一個地址來調用connect與服務器建立連接。
一旦連接建立，我們就可以像使用底層的文件描述符那樣用套接字來實現雙向數據的通信。

六、同主機通信舉例
1、服務器的listen模塊

#include <stddef.h> 
#include <sys/socket.h> 
#include <sys/un.h> 
#include <errno.h> 
#define QLEN 10 /
* * Create a server endpoint of a connection. 
* Returns fd if all OK, <0 on error. */ 
int serv_listen(const char *name) 
{ 
    int fd, len, err, rval;
     struct sockaddr_un un; /* create a UNIX domain stream socket */ 
    if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) 
        return(-1); 
    unlink(name); 
    /* in case it already exists */
     /* fill in socket address structure */ 
    memset(&un, 0, sizeof(un)); 
    un.sun_family = AF_UNIX; 
    strcpy(un.sun_path, name); 
    len = offsetof(struct sockaddr_un, sun_path) + strlen(name); 
    /* bind the name to the descriptor */ 
    if (bind(fd, (struct sockaddr *)&un, len) < 0) 
    { 
        rval = -2; 
        goto errout;
     } 
    if (listen(fd, QLEN) < 0) //不阻塞 
    { 
        /* tell kernel we're a server */ 
        rval = -3;
        goto errout; 
    } 
    return(fd);

errout: 
    err = errno; 
    close(fd); 
    errno = err; 
    return(rval);
 }

2、服務器accept模塊

#include <stddef.h> 
#include <sys/stat.h> 
#include <sys/socket.h>
#include <sys/un.h> 
#include <errno.h> 
int serv_accept(int listenfd, uid_t *uidptr) 
{ 
    int clifd, len, err, rval; time_t staletime; 
    struct sockaddr_un un; 
    struct stat statbuf; 

    len = sizeof(un); 
    if ((clifd = accept(listenfd, (struct sockaddr *)&un, &len)) < 0) return(-1); 
    /* often errno=EINTR, if signal caught */ 
    /* obtain the client's uid from its calling address */ 
    len -= offsetof(struct sockaddr_un, sun_path); /* len of pathname */ 
    un.sun_path[len] = 0; /* null terminate */ 
    if (stat(un.sun_path, &statbuf) < 0) 
    { 
        rval = -2;
        goto errout; 
    }

     if (S_ISSOCK(statbuf.st_mode) == 0) 
    { 
        rval = -3; /* not a socket */ 
        goto errout; 
    } 

    if (uidptr != NULL) *uidptr = statbuf.st_uid; /* return uid of caller */ 
        unlink(un.sun_path); /* we're done with pathname now */ 
    return(clifd); 

errout: 
    err = errno;
    close(clifd); 
    errno = err; 
    return(rval); 
}

3、客戶端

#include <stdio.h> 
#include <stddef.h> 
#include <sys/stat.h>
#include <sys/socket.h> 
#include <sys/un.h> 
#include <errno.h> 
#define CLI_PATH "/var/tmp/" /* +5 for pid = 14 chars */ 
/* * Create a client endpoint and connect to a server. 
* Returns fd if all OK, <0 on error. */ 

int cli_conn(const char *name) 
{ 
    int fd, len, err, rval; 
    struct sockaddr_un un; /* create a UNIX domain stream socket */ 
    if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) return(-1);
    /* fill socket address structure with our address */
    memset(&un, 0, sizeof(un)); 
    un.sun_family = AF_UNIX; 
    sprintf(un.sun_path, "%s%05d", CLI_PATH, getpid()); 
    len = offsetof(struct sockaddr_un, sun_path) + strlen(un.sun_path); 
    unlink(un.sun_path); 
    /* in case it already exists */ 
    if (bind(fd, (struct sockaddr *)&un, len) < 0) { rval = -2; goto errout; } 
    /* fill socket address structure with server's address */ 
    memset(&un, 0, sizeof(un)); 
    un.sun_family = AF_UNIX; 
    strcpy(un.sun_path, name); 
    len = offsetof(struct sockaddr_un, sun_path) + strlen(name); 
    if (connect(fd, (struct sockaddr *)&un, len) < 0) { rval = -4; goto errout; } 
    return(fd); 
errout: 
    err = errno; 
    close(fd); 
    errno = err; 
    return(rval); 
}

七、不同主機通信舉例
1、tcp服務端

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <errno.h>
 
 
#define MAX_MSG_SIZE 256
#define SERVER_PORT  9987
 
 
#define BACKLOG 2
 
 
int GetServerAddr(char * addrname){
    printf("please input server addr:");
    scanf("%s",addrname);
    return 1; 
}
 
 
int main(){  
    int sock_fd,client_fd; /*sock_fd：監聽socket；client_fd：數據傳輸socket */  
    struct sockaddr_in ser_addr; /* 本機地址信息 */  
    struct sockaddr_in cli_addr; /* 客戶端地址信息 */  
    char msg[MAX_MSG_SIZE];/* 緩沖區*/  
    int ser_sockfd=socket(AF_INET,SOCK_STREAM,0);/*創建連接的SOCKET */  
    if(ser_sockfd<0)  
           {/*創建失敗 */  
                  fprintf(stderr,"socker Error:%s\n",strerror(errno));  
                  exit(1);  
          }  
    /* 初始化服務器地址*/  
    socklen_t  addrlen=sizeof(struct sockaddr_in);  
    bzero(&ser_addr,addrlen);  
    ser_addr.sin_family=AF_INET;  
    ser_addr.sin_addr.s_addr=htonl(INADDR_ANY);  
    ser_addr.sin_port=htons(SERVER_PORT);  
    if(bind(ser_sockfd,(struct sockaddr*)&ser_addr,sizeof(struct sockaddr_in))<0){ /*綁定失敗 */  
            fprintf(stderr,"Bind Error:%s\n",strerror(errno));  
            exit(1);  
    }  
    /*偵聽客戶端請求*/  
    if(listen(ser_sockfd,BACKLOG)<0){  
        fprintf(stderr,"Listen Error:%s\n",strerror(errno));  
        close(ser_sockfd);  
        exit(1);  
    }  
    while(1){/* 等待接收客戶連接請求*/  
        int cli_sockfd=accept(ser_sockfd,(struct sockaddr*) &cli_addr, &addrlen);  
        if(cli_sockfd<=0){  
            fprintf(stderr,"Accept Error:%s\n",strerror(errno));  
        }else{/*開始服務*/  
            recv(cli_sockfd, msg, (size_t)MAX_MSG_SIZE, 0); /* 接受數據*/  
            printf("received a connection from %sn", inet_ntoa(cli_addr.sin_addr));  
            printf("%s\n",msg);/*在屏幕上打印出來 */  
            strcpy(msg,"hi,I am server!");  
            send(cli_sockfd, msg, sizeof(msg),0); /*發送的數據*/  
            close(cli_sockfd);  
        }  
    }  
    close(ser_sockfd);  
    return 0;  

 }  

2、tcp客戶端

#include <stdio.h>
#include <sys/types.h>  
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <errno.h>
 
 
#define MAX_MSG_SIZE 256
#define SERVER_PORT  9987
 
 
int GetServerAddr(char * addrname){  
    printf("please input server addr:");  
    scanf("%s",addrname);  
    return 1;  
}  
 
 
int main(){  
    int cli_sockfd;/*客戶端SOCKET */  
    int addrlen;  
    char seraddr[14];  
    struct sockaddr_in ser_addr,/* 服務器的地址*/  
    cli_addr;/* 客戶端的地址*/  
    char msg[MAX_MSG_SIZE];/* 緩沖區*/  
  
    GetServerAddr(seraddr);  
  
    cli_sockfd=socket(AF_INET,SOCK_STREAM,0);/*創建連接的SOCKET */  
  
    if(cli_sockfd<0){/*創建失敗 */  
        fprintf(stderr,"socker Error:%s\n",strerror(errno));  
        exit(1);  
    }  
    /* 初始化客戶端地址*/  
    addrlen=sizeof(struct sockaddr_in);  
    bzero(&ser_addr,addrlen);  
    cli_addr.sin_family=AF_INET;  
    cli_addr.sin_addr.s_addr=htonl(INADDR_ANY);  
    cli_addr.sin_port=0;  
    if(bind(cli_sockfd,(struct sockaddr*)&cli_addr,addrlen)<0){  
        /*綁定失敗 */  
        fprintf(stderr,"Bind Error:%s\n",strerror(errno));  
        exit(1);  
    }  
    /* 初始化服務器地址*/  
    addrlen=sizeof(struct sockaddr_in);  
    bzero(&ser_addr,addrlen);  
    ser_addr.sin_family=AF_INET;  
    ser_addr.sin_addr.s_addr=inet_addr(seraddr);  
    ser_addr.sin_port=htons(SERVER_PORT);  
    if(connect(cli_sockfd,(struct sockaddr*)&ser_addr, addrlen)!=0)/*請求連接*/  
    {  
        /*連接失敗 */  
        fprintf(stderr,"Connect Error:%s\n",strerror(errno));  
        close(cli_sockfd);  
        exit(1);  
    }  
    strcpy(msg,"hi,I am client!");  
    send(cli_sockfd, msg, sizeof(msg),0);/*發送數據*/  
    recv(cli_sockfd, msg, MAX_MSG_SIZE,0); /* 接受數據*/  
    printf("%s\n",msg);/*在屏幕上打印出來 */  
    close(cli_sockfd);  
  
    return 0;  
}  

 

參考：
https://blog.csdn.net/pashanhu6402/article/details/96428887
https://blog.csdn.net/panker2008/article/details/46502783
https://baike.baidu.com/item/%E5%A5%97%E6%8E%A5%E5%AD%97/9637606?fromtitle=socket&fromid=281150&fr=aladdin
https://www.jianshu.com/p/066d99da7cbd
https://www.cnblogs.com/huqian23456/archive/2011/02/22/1961822.html
https://blog.csdn.net/will130/article/details/53326740
https://blog.51cto.com/mingtangduyao/1721604
https://blog.csdn.net/giantpoplar/article/details/47657303
https://blog.csdn.net/ljianhui/article/details/10477427#
https://www.cnblogs.com/dapaitou2006/p/6502195.html
https://blog.csdn.net/weixin_43206704/article/details/89327572
https://blog.csdn.net/weixin_43206704/article/details/89293187
http://blog.chinaunix.net/uid-27074062-id-3388166.html
https://blog.csdn.net/aebdm757009/article/details/101498118
https://tennysonsky.blog.csdn.net/article/details/44676377
https://blog.csdn.net/q623702748/article/details/52063019
https://blog.csdn.net/weixin_43288201/article/details/106266418