CppExplore

作者：CppExplore 地址：http://www.shnenglu.com/CppExplore/

全文針對linux環境。tcp/udp兩種server種，tcp相對較復雜也相對比較常用。本文就從tcp server開始講起。先從基本說起，看一個單線程的網絡模型，處理流程如下：

socket-->bind-->listen-->[accept-->read-->write-->close]-->close

[]中代碼循環運行，[]外的是對監聽socket的處理，[]內的是對accept返回的客戶socket的處理。這些系統調用的參數以及需要的頭文件等，只需要在linux下man就好。

一、注意事項。
（1）包裹宏使用。這些系統調用返回-1表示失敗。檢測系統調用的返回值是個好習慣，應該說必須檢測，如果系統調用總是成功的話，它為何又要有返回值呢？。每次檢查的話，代碼寫起來又很是羅唆，并且容易遺漏檢測。使用宏包裹系統調用或者使用包裹函數是不錯的方案。下面給出幾個預定義包裹宏：

#define NOERROR_FUNC(func,opt) if((func)<0) \
 { \
  printf("Line[%d] error[%d:%s]\n",__LINE__,errno,strerror(errno)); \
  opt; \
 }
#define NOERROR_FUNC_1(func) NOERROR_FUNC(func,return -1)
#define NOERROR_FUNC_NULL(func) NOERROR_FUNC(func,return NULL)

不知道strerror？，剛說了，去linux下:man strerror
以后使用就可以類似于這樣：

NOERROR_FUNC_1（(fd=socket(AF_INET,SOCKET_STREAM,0)));
NOERROR_FUNC_1(bind(fd,(struct sockaddr *)&serverAddr,sizeof(struct sockaddr_in)));

(2)不能返回失敗的錯誤。大多數阻塞式系統調用要處理EINTR錯誤，另accept還要處理ECONNABORTED。與（1）同樣道理，預定義宏如下：

#define NOERROR_FUNC_BUT_ERR(func,opt,err,erropt) if((func)<0) \
 { \
  printf("Line[%d] error[%d:%s]\n",__LINE__,errno,strerror(errno)); \
  if(errno==err) { erropt;} \
  else {opt;} \
 }
#define NOERROR_FUNC_BUT_ERR_2(func,opt,err1,err2,erropt) if((func)<0) \
 { \
  printf("Line[%d] error[%d:%s]\n",__LINE__,errno,strerror(errno)); \
  if(errno==err1||errno==err2) { erropt;} \
  else {opt;} \
 }

調用accept的代碼就可以如此寫：

while(1)
 {
  client_sockfd=accept(fd,(struct sockaddr *)&clientAddr,&lenAddr);
  NOERROR_FUNC_BUT_ERR_2(client_sockfd,retun -1,EINTR,ECONNABORTED,continue);

（3）涉及到系統調用分兩類：從用戶態到內核態，該類系統調用使用值參數，有：bind/setsockopt/connect；從內核態到用戶態,該類系統調用使用值－結果參數，有：accept/getsockopt。
看下兩者函數原型，從用戶態到內核態：

       int setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen);
       int connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen);
       int bind(int sockfd,struct sockaddr *Addr,socklen_t addrlen);

從內核態到用戶態：

    int getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen);
    int accept(int sockfd,struct sockaddr *Addr,socklen_t *addrlen);

看最后一個參數，從用戶態到內核態只要告訴內核參數長度的值就可以了，因此是值方式。從內核態到用戶態，要事先準備好變量保存內核態返回的結果長度值，因此是指針方式，稱之為值－結果參數。

二、系統調用
（1）socket

int fd;
   NOERROR_FUNC_1(fd=socket(AF_INET,SOCKET_STREAM,0));

創建一個ipv4的tcp socket
（2）bind
把socket綁定到一個地址，首先要指明地址，如下：

struct sockaddr_in addr;
addr.sin_family=AF_INET;//協議類型
addr.sin_port=htons(5000);//端口地址
addr.sin_addr.s_addr=htonl(INADDR_ANY);//此處表示任意ip（主機有多個網卡，則將環路地址127.0.0.1以及各網卡ip都指定）。
NOERROR_FUNC_1(bind(fd,(struct sockaddr *)addr,sizeof(struct sockaddr_in)));

創建ipv4協議的地址，使用5000端口，接收任何地址的connect，把該地址和fd綁定。
注意：
1、地址聲明的時候使用struct sockaddr_in，使用的時候總是強制轉化為struct sockaddr。
2、struct sockaddr_in結構中端口和ip都必須是網絡序。htons把主機序的short int轉化為網絡序，htonl把主機序的long int轉化為網絡序。
3、除任意ip地址為常量外，一般習慣用點分字符串表示ip地址，而addr.sin_addr.s_addr要使用網絡序整型。
因此有兩個函數可以在字符串和網絡序ip地址之間做轉換：

   const char *inet_ntop(int af, const void *src,char *dst, socklen_t cnt);
   int inet_pton(int af, const char *src, void *dst);

這里是需要網絡序，因此使用ton（to net）那個函數，比如：

NOERROR_FUNC_1（inet_pton(AF_INET,"172.168.0.45", &addr.sin_addr.s_addr));

（3）setsockopt

long val;
socklen_t len=sizeof(val);
NOERROR_FUNC_1(setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,&(val=1),len));

給socket設置選項，常用的不多，SO_REUSEADDR是一個，服務器一般使用，其它還有SO_RCVBUF，SO_SNDBUF。accept返回的對端socket繼承監聽socket的發送緩存、接收緩存選項。一般也不需要設置SO_RCVBUF，SO_SNDBUF，默認的足夠了，帶寬很大的情況下，需要設置，以免其稱為瓶頸，貌似默認的是8092字節。哦，還有要在listen前設置。
（4）listen

NOERROR_FUNC_1(listen(fd,SOMAXCONN));

把fd從主動端口變為被動端口，等待client connect。第二個參數是表示三次握手中隊列以及完成了三次握手等待accept系統函數來取的隊列的相加值，有的系統不是簡單相加，還有一個系數，也就是如果設置5，系數是2，那么兩個隊列的和就是10。如果隊列滿，而accept沒來?。ê苊Φ那闆r下，來不及調用accept），再有連接來就會被拒絕掉，要想系統能處理超大爆發的連接，就加大這個參數值，加快accept的處理。SOMAXCONN表示取系統允許的最大值。
（5）accept
前面已經舉例了，這里就不再列例子了。
阻塞式調用，需要處理EINTR（被信號終止），ECONNABORTED（返回前client異常終止），處理的方式就是重新accept。
（6）read

int read(int fd,char *buf,size_t len);

這是針對文件描述符的一個系統調用，socket也屬于文件描述符。tcp協議中傳輸的數據都是流字節，沒有什么結束符的標志，只能由協議提供結束方式，比如http協議使用"\r\n\r\n"或者"\n\n"標識一條信令結束，這樣的話，我們只能一個字節一個字節的讀取，然后結合已經讀取的字節，判斷是否應該結束讀。而網絡模型中要提高性能，一個重要方面就是要減少系統調用的次數。因此tcp中都要使用緩存區一次讀取盡可能多的數據，然后再從該緩存區一個字節一個字節的讀取，緩存區數據被讀完而沒有到結束位置的時候，再次調用系統調用read。
返回值為0表示對端正常關閉，大于0表示讀取到的字節數。示例見最后例子。
（7）write

int write(int fd,char *buf,size_t len);

兩個需要注意的地方：
1、對EINTR處理。防止被信號中斷，沒有正確寫入需求的字符數。
2、signal(SIGPIPE, SIG_IGN);這句代碼的意思是忽略SIGPIPE信號。
write寫被重置（對端意外關閉）的套接口，產生SIGPIPE信號，不處理的話程序被終止。忽略的話，繼續寫會產生EPIPE錯誤，檢查write系統調用的返回結果就好了。示例見最后例子。
signal的使用，man下就看到了，回調函數的原型等都有，SIG_IGN也會出現，呵呵。
（8）close就不說了
（9）fcntl
要對socket設置為非阻塞方式，setsockopt沒有提供相應的選項，只能用fcntl函數設置。

int flags;
NOERROR_FUNC_1（flags=fcntl(client_sockfd,F_GETFL,0)）；
NOERROR_FUNC_1（fcntl(client_sockfd,F_SETFL,flags|O_NONBLOCK)）;

多路分離I/O(select/poll/epoll)通常設置為非阻塞方式。
設置為阻塞方式（默認方式）代碼：

int flags;
NOERROR_FUNC_1（flags=fcntl(client_sockfd,F_GETFL,0)）；
NOERROR_FUNC_1（fcntl(client_sockfd,F_SETFL,flags&~O_NONBLOCK)）;

對于阻塞方式的套接口，如果要避免read write永遠阻塞，設置等待時間的方式有3種：信號方式，不推薦，不說了；select方式，每次調用read前調用select監視該套接口是否在指定時間內可寫，超時select返回0，這樣每次執行read都要調用兩個系統調用，不推薦；最后就是設置套接口選項SO_RECVTIMEO和SO_SNDTIMEO,其實這個也不推薦，總之不推薦阻塞式的方式，呵呵。實用的網絡模型都是多路分離的。
非阻塞方式下的connect函數要說下，當然是就客戶端而言，connect后如果沒有立即返回連接成功的話，把這個socket加入select的 fd_set(poll的pollfd，epoll的EPOLL_CTL_ADD操作),要監視是否可寫事件，可寫的時候用getsockopt獲取SO_ERROR選項，如果非負（其實就是0值）就標示connect成功，否則就是失敗。EPOLL中測試結果是connect失敗的返回事件是EPOLLERR|EPOLLHUP,并不是加入時的EPOLLOUT，成功的時候是EPOLLOUT。

三、示例
最后給個單線程的服務器，雖說沒什么實用意義，不過就象“hello world!”，入門第一課。
這個例子，讀取數據，回寫response，關閉clientfd。不管read write是否出錯，都執行close，因此代碼很簡單。
先來main函數：

int main()
{
    int server_sockfd;
    int client_sockfd;
    struct sockaddr_in serverAddr;
    struct sockaddr_in clientAddr;
    size_t lenAddr;
        int val;

    memset(&serverAddr,0,sizeof(serverAddr));
    serverAddr.sin_family=AF_INET;
    serverAddr.sin_port=htons(5000);
    serverAddr.sin_addr.s_addr=htonl(INADDR_ANY);

    NOERROR_FUNC_1((server_sockfd=socket(AF_INET,SOCK_STREAM,0)));
    NOERROR_FUNC_1(setsockopt(server_sockfd,SOL_SOCKET,SO_REUSEADDR,&(val=1),sizeof(val)));
    NOERROR_FUNC_1(bind(server_sockfd,(struct sockaddr *)&serverAddr,sizeof(struct sockaddr_in)));
    NOERROR_FUNC_1(listen(server_sockfd,SOMAXCONN));
  
    const static char * response="HTTP/1.1 200 OK\r\n\r\n";
    char buf[BUF_LEN];
    signal(SIGPIPE, SIG_IGN);
    while(1)
    {
        client_sockfd=accept(server_sockfd,(struct sockaddr *)&clientAddr,&lenAddr);
        NOERROR_FUNC_BUT_ERR_2(client_sockfd,return -1,EINTR,ECONNABORTED,continue);
        BuffCache cache;
        if(read_double_enter(client_sockfd,buf,BUF_LEN,&cache)>0)
            writen(client_sockfd,response,19);
        close(client_sockfd);
    }
    close(server_sockfd);
    return 0;
}

 下面是包含的頭文件和宏：

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <errno.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>


#define NOERROR_FUNC(func,opt) if((func)<0) \
    { \
        printf("Line[%d] error[%d:%s]\n",__LINE__,errno,strerror(errno)); \
        opt; \
    }
#define NOERROR_FUNC_BUT_ERR(func,opt,err,erropt) if((func)<0) \
    { \
        printf("Line[%d] error[%d:%s]\n",__LINE__,errno,strerror(errno)); \
        if(errno==err) { erropt;} \
        else {opt;} \
    }
#define NOERROR_FUNC_BUT_ERR_2(func,opt,err1,err2,erropt) if((func)<0) \
    { \
        printf("Line[%d] error[%d:%s]\n",__LINE__,errno,strerror(errno)); \
        if(errno==err1||errno==err2) { erropt;} \
        else {opt;} \
    }

#define NOERROR_FUNC_1(func) NOERROR_FUNC(func,return -1)
#define NOERROR_FUNC_NULL(func) NOERROR_FUNC(func,return NULL)

#define BUF_LEN 1024

class BuffCache
{
public:
    BuffCache():count(0){}
    int read_socket(int fd,char * pCh)
    {
        if(count<=0)
        {
        again:
            if((count=read(fd,buf,BUF_LEN))<0)
            {
                if(errno==EINTR)
                    goto again;
                *pCh='\0';
                return -1;
            }
            else if(count==0)
            {
                *pCh='\0';
                return 0;
            }
            ptrBuf=buf;
        }
        count--;
        *pCh=*(ptrBuf++);
        return 1;
    }
private:
    char buf[BUF_LEN];
    char * ptrBuf;
    int count;
};
inline int read_double_enter(int fd,char * pCh, int maxsize,BuffCache *cache)
{
    int i=0;
    char *ptr=pCh;
    int res=0;
    int sum=0;
    for(i=0;i<maxsize;i++)
    {
        if((res=cache->read_socket(fd,ptr))<0)
            return -1;
        else if(res==0)
        {
            *ptr='\0';
            return sum;
        }
        else
        {
            if(*ptr=='\n'&&
                ((ptr-pCh>=1&&*(ptr-1)=='\n')||
                (ptr-pCh>=3&&*(ptr-1)=='\r'&&*(ptr-2)=='\n'&&*(ptr-3)=='\r')))
            {
                *(ptr+1)='\0';
                return ++sum;
            }
        }    
        ptr++;
        sum++;
    }
}

inline int writen(int fd,const char * buf, int len)
{
    int count=0;
    int leftlen=len;
    const char * ptr=buf;
    while(leftlen>0)
    {
    again:
        NOERROR_FUNC_BUT_ERR((count=write(fd,ptr,leftlen)),return -1,EINTR,goto again);
        leftlen-=count;
        ptr+=count;
    }
}