TinyWS —— 一個C++寫的簡易WEB服務器(三)

時間  2019-12-07
標籤 tinyws 一個 c++ 寫的 簡易 web 服務器 欄目 C&C++ 简体版
原文   原文鏈接

寫在前面

代碼已經託管在 https://git.oschina.net/augustus/TinyWS.githtml

能夠用git clone下來。因爲我可能會偶爾作一些修改，不能保證git 庫上的代碼與blog裏的徹底一致（實際上也不可能把全部的代碼都貼在這裏）。另外，TinyWS是基於linux寫的（ubuntu 14.10 + eclipse luna，eclipse工程我也push到了git庫），故在Windows上可能沒法正常編譯（主要是系統調用 部分可能會不一樣）。linux

前面的內容可參考上一篇  http://www.cnblogs.com/cuiluo/p/4219946.html
git

NetConnection

NetConnection類封裝了對socket的操做。socket的原理前面簡單說過，其使用方法許多地方都有介紹，這裏不細說，其實對於服務端，不過就是打開socket，監聽某端口，然後等待客戶端請求幾個步驟。apache

// NetConnection
class NetConnection
{
public:
    NetConnection();
    void lisen(int port);
    int accept();
    void close();

private:
    int lisenfd;
    int connfd;
};

其中lisenfd是打開socket時系統函數返回的描述符，在accept客戶端請求時會用到；而connfd是調用accept系統函數時返回的文件描述符，也就是實際上的數據通道。ubuntu

在NetConnection的實現中，實際上在匿名namespace中封裝系統調用的函數（包括後面IO操做時對系統調用的封裝），摘取自《深刻理解計算機系統》這本書。設計模式

// NetConnection.cpp
namespace
{
const int  LISTENQ = 1024;
void unix_error(char *msg) /* unix-style error */
{
    fprintf(stderr, "%s: %s\n", msg, strerror(errno));
    exit(0);
}

int open_listenfd(int port)
{
    int listenfd, optval = 1;
    struct sockaddr_in serveraddr;

    /* Create a socket descriptor */
    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
        return -1;

    /* Eliminates "Address already in use" error from bind. */
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (const void *) &optval,
            sizeof(int)) < 0)
        return -1;

    /* Listenfd will be an endpoint for all requests to port
     on any IP address for this host */
    bzero((char *) &serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serveraddr.sin_port = htons((unsigned short) port);
    if (bind(listenfd, (sockaddr *) &serveraddr, sizeof(serveraddr)) < 0)
        return -1;

    /* Make it a listening socket ready to accept connection requests */
    if (listen(listenfd, LISTENQ) < 0)
        return -1;
    return listenfd;
}

int Open_listenfd(int port)
{
    int rc;

    if ((rc = open_listenfd(port)) < 0)
        unix_error("Open_listenfd error");
    return rc;
}

int Accept(int s, struct sockaddr *addr, socklen_t *addrlen)
{
    int rc;

    if ((rc = accept(s, addr, addrlen)) < 0)
        unix_error("Accept error");
    return rc;
}

void Close(int fd)
{
    int rc;

    if ((rc = close(fd)) < 0)
        unix_error("Close error");
}

}

NetConnection::NetConnection() : lisenfd(-1), connfd(-1)
{

}

void NetConnection::lisen(int port)
{
    lisenfd = Open_listenfd(port);
}

int NetConnection::accept()
{
    int clientlen;
    struct sockaddr_in clientaddr;
    clientlen = sizeof(clientaddr);

    connfd = Accept(lisenfd, (sockaddr *) &clientaddr, reinterpret_cast<socklen_t*>(&clientlen));
    return connfd;
}

void NetConnection::close()
{
    Close(connfd);
}

IoReader

IoReader類和後面的IoWriter類其實是封裝了底層的IO操做，爲業務提供更簡單的接口。瀏覽器

// IoReader.h
class IoReader
{
public:
    IoReader(int fd);void getLineSplitedByBlank(std::vector<std::string>& buf);
};

這個類中，只對外提供了一個接口，用於讀取http請求的報頭。這個接口從accept函數返回的文件描述符中（實際就是客戶端傳過來的數據）讀取一行，並使用「 」分隔成多個字符串後返回。這個實際上就是對http請求報頭的解析。一個請求報頭，第一行多是這樣的：服務器

GET / HTTP/1.1

包含三部分，方法名，請求的uri和協議版本號，它們之間使用「 」分隔。固然，一個真正的GET請求後面還有若干行，可是對於咱們這個簡單的服務器來講，只有第一行是須要的，其餘行都簡單的忽略了。若是一個uri爲 「/」,則說明是要返回主頁，咱們這裏寫死了爲Index.html，實際上應該作成可配置，這個留做後面再改吧。網絡

因此，getLineSplitedByBlank這個方法，就是把已經分隔好的字符串容器返回了。eclipse

//IoReader.cpp

namespace
{
const int MAX_LENGTH = 8192;

struct rio_t
{
    int rio_fd; /* descriptor for this internal buf */
    int rio_cnt; /* unread bytes in internal buf */
    char *rio_bufptr; /* next unread byte in internal buf */
    char rio_buf[MAX_LENGTH]; /* internal buffer */
};

void unix_error(char *msg) /* unix-style error */
{
    fprintf(stderr, "%s: %s\n", msg, strerror(errno));
    exit(0);
}

void rio_readinitb(rio_t *rp, int fd)
{
    rp->rio_fd = fd;
    rp->rio_cnt = 0;
    rp->rio_bufptr = rp->rio_buf;
}

void Rio_readinitb(rio_t *rp, int fd)
{
    rio_readinitb(rp, fd);
}

static ssize_t rio_read(rio_t *rp, char *usrbuf, size_t n)
{
    int cnt;

    while (rp->rio_cnt <= 0)
    { /* refill if buf is empty */
        rp->rio_cnt = read(rp->rio_fd, rp->rio_buf, sizeof(rp->rio_buf));
        if (rp->rio_cnt < 0)
        {
            if (errno != EINTR) /* interrupted by sig handler return */
                return -1;
        }
        else if (rp->rio_cnt == 0) /* EOF */
            return 0;
        else
            rp->rio_bufptr = rp->rio_buf; /* reset buffer ptr */
    }

    /* Copy min(n, rp->rio_cnt) bytes from internal buf to user buf */
    cnt = n;
    if (rp->rio_cnt < n)
        cnt = rp->rio_cnt;
    memcpy(usrbuf, rp->rio_bufptr, cnt);
    rp->rio_bufptr += cnt;
    rp->rio_cnt -= cnt;
    return cnt;
}

ssize_t rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen)
{
    int n, rc;
    char c, *bufp = reinterpret_cast<char*>(usrbuf);

    for (n = 1; n < maxlen; n++)
    {
        if ((rc = rio_read(rp, &c, 1)) == 1)
        {
            *bufp++ = c;
            if (c == '\n')
                break;
        }
        else if (rc == 0)
        {
            if (n == 1)
                return 0; /* EOF, no data read */
            else
                break; /* EOF, some data was read */
        }
        else
            return -1; /* error */
    }
    *bufp = 0;
    return n;
}

ssize_t Rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen)
{
    ssize_t rc;

    if ((rc = rio_readlineb(rp, usrbuf, maxlen)) < 0)
        unix_error("Rio_readlineb error");
    return rc;
}

rio_t rio;
}

IoReader::IoReader(int fd)
{
    Rio_readinitb(&rio, fd);
}

void IoReader::getLineSplitedByBlank(std::vector<std::string>& buf)
{
    char innerBuf[MAX_LENGTH], method[MAX_LENGTH], uri[MAX_LENGTH], version[MAX_LENGTH];
    Rio_readlineb(&rio, innerBuf, MAX_LENGTH);

    sscanf(innerBuf, "%s %s %s", method, uri, version);
    buf.push_back(method);
    buf.push_back(uri);
    buf.push_back(version);
}

這裏面，匿名namespace裏面的函數，也是取自《深刻理解計算機系統》那本書，並且幾個地方還引入了重複代碼，目前這樣作只是爲了快速實現而已，這也是我想要重構的地方。不過研究了半天仍是沒有徹底搞清楚怎樣將C++標準庫中的IO流綁定在一個操做系統的文件描述符上面（固然，C的庫函數很容易作到這一點），我想應該是有方法的，惋惜我不熟悉這裏。雖然我是靠C++吃飯的，也是作的所謂「嵌入式」系統，不過對於那種比較大型的通訊軟件，像我這種作業務層的，甚至不直接和操做系統打交道，也不會使用標準庫，由於其餘部門的同事會提供一個平臺層。因此我對於這些操做並非很瞭解。

IoWriter

這個類與IoReader對應，是封裝底層IO寫操做的，實際上就是向客戶端發送數據。當解析出客戶端想要訪問的uri後，這裏就會將相應的文件發送回去，這後瀏覽器解析這個文件，咱們就能看到網頁了。

// IoWriter.h

class IoWriter
{
public:
    IoWriter(int fd);
    void writeString(const std::string& str);
    void writeFile(const std::string& fileName, int filesSize);
private:
    int fileDescriptor;
};

這個類提供了兩個接口writeString 是寫入一個字符串，主要是用於發送響應報頭的，writeFile就是真正的把客戶端想要的文件返回。

咱們看一個應答報頭的例子：

HTTP/1.0 200 OK
Server: Tiny Web Server
Content-length: 120
Content-type: text/html

第一行的 200 就是返回成功，固然HTTP的返回碼你們都很熟悉，好比200是成功，404是找不到文件，403是操做權限不足等等，這裏很少說了。第二行是服務器類型，咱們這裏固然就是TinyWS,後面兩行是待返回文件的大小和類型。返回報頭以後，再調用writeFile方法，返回真正的文件。

// IOWriter.cpp
namespace
{
void unix_error(char *msg) /* unix-style error */
{
    fprintf(stderr, "%s: %s\n", msg, strerror(errno));
    exit(0);
}

ssize_t rio_writen(int fd, void *usrbuf, size_t n)
{
    size_t nleft = n;
    ssize_t nwritten;
    char *bufp = reinterpret_cast<char*>(usrbuf);

    while (nleft > 0)
    {
        if ((nwritten = write(fd, bufp, nleft)) <= 0)
        {
            if (errno == EINTR) /* interrupted by sig handler return */
                nwritten = 0; /* and call write() again */
            else
                return -1; /* errorno set by write() */
        }
        nleft -= nwritten;
        bufp += nwritten;
    }
    return n;
}

void Rio_writen(int fd, void *usrbuf, size_t n)
{
    if (rio_writen(fd, usrbuf, n) != n)
        unix_error("Rio_writen error");
}

int Open(const char *pathname, int flags, mode_t mode)
{
    int rc;

    if ((rc = open(pathname, flags, mode)) < 0)
        unix_error("Open error");
    return rc;
}

void Close(int fd)
{
    int rc;

    if ((rc = close(fd)) < 0)
        unix_error("Close error");
}

void* Mmap(void *addr, size_t len, int prot, int flags, int fd, off_t offset)
{
    void *ptr;

    if ((ptr = mmap(addr, len, prot, flags, fd, offset)) == ((void *) -1))
        unix_error("mmap error");
    return (ptr);
}

void Munmap(void *start, size_t length)
{
    if (munmap(start, length) < 0)
        unix_error("munmap error");
}

}

IoWriter::IoWriter(int fd) : fileDescriptor(fd)
{

}

void IoWriter::writeString(const std::string& str)
{
    Rio_writen(fileDescriptor, const_cast<char*>(str.c_str()), str.length());
}

void IoWriter::writeFile(const std::string& fileName, int filesSize)
{
    int srcfd;
    char *srcp;
    srcfd = Open(const_cast<char*>(fileName.c_str()), O_RDONLY, 0);
    srcp = reinterpret_cast<char*>(Mmap(0, filesSize, PROT_READ, MAP_PRIVATE,
            srcfd, 0));
    Close(srcfd);
    Rio_writen(fileDescriptor, srcp, filesSize);
    Munmap(srcp, filesSize);
}

這個實現我也很是不喜歡，因爲使用了那本經典書中的代碼，和前面產生了不少重複。留做後面重構吧

如今，TinyWS已經基本介紹完了，咱們在看一下主函數：

// Tiny.cpp
namespace
{
int getPortFromCommandLine(char **argv)
{
    return atoi(argv[1]);
}

int getDefalutPort()
{
    return 8080;
}

int getStartPort(int argc, char **argv)
{
    if (argc == 2)
        return getPortFromCommandLine(argv);
    else
        return getDefalutPort();
}
}

int main(int argc, char **argv)
{
    NetConnection connection;

    connection.lisen(getStartPort(argc, argv));
    while (1)
    {
        int connfd = connection.accept();
        RequestManager(connfd).run();
        connection.close();
    }
}

匿名namespace中的函數，是爲了獲取監聽端口的，若是用戶啓動服務時在命令行中輸入了端口，則使用用戶提供的端口，不然就使用默認的8080端口，固然，這個默認值最好也應該出如今配置文件中。之因此沒有選擇80端口，是由於個人機器上裝了apache，已經監聽了80端口，不然大可沒必要如此，還要每次測試還要輸入端口號。

測試

在代碼目錄中有一個我寫的用於測試的一組html頁面（包括html文件，圖片，還有一個CSS文件），就目前存放的位置來講，若是使用eclipse倒入了這個工程，運行其TinyWS後，就可使用http://127.0.0.1:8080/訪問到它的主頁。

這是一個關於蜂鳥的一組頁面，實際上是幫老婆寫的一個做業。老婆一邊工做還要一邊在某高校念教育學碩士，這個專業有一門彷佛是「遠程教育」的課程，還讓學生都要寫一組html頁面，確實有點過度了，不過也只好我代勞了。我作頁面的水平很初級，因此頁面自己很難看，對於測試靜態頁面倒也夠用了。這中間還發現一個問題，就是常常瀏覽器（我使用firefox）解析以後，CSS中定義好的格式就沒有了，可能刷新幾回就又恢復了，目前還沒仔細研究是怎麼一回事。

後記

整個TinyWS中有不少能夠優化和重構的地方，留做後面重構吧。同時哪位朋友知道如何將C++標準庫的IO流綁定到文件描述符上，也請不吝賜教。

我在處理IO操做的地方，使用了《深刻理解計算機系統》這本書裏的示例代碼，這本書是很不錯的，幾乎講了計算機系統的方方面面，惋惜我老是在前幾章不斷徘徊，後面的內容只是偶爾翻過，可是還記得有講IO的網絡的章節。在這本書講網絡的那章，也有一個WEB服務器的例子，是用C語言寫的，區區200多行代碼，實現的功能基本和我這裏相同。

我這裏的TinyWS,自認爲也是使用「OO」的方法實現的（固然個人設計水平很爛），還不自覺的用了幾個「設計模式」（還計劃用設計模式改造一下response和IO操做），但看了那個C語言的例子後，我在想，若是使用OO的方法，如何纔有那樣簡潔的實現呢？在有些時候，OO可能真的會將簡單的問題複雜化。（固然，那個C語言例子的風格我並不喜歡，從命名到程序結構應該均可以作的更好，可是那份簡潔真的打動了我）。

也許沒有一種方法在任什麼時候候都是合適的，纔是真理吧。

最後這段也許會引發「宗教情結」同樣的爭論的，還好此文的讀者也不會太多。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程