完善webSocket协议实现

优化代码

src/Http/HttpClientImp.cpp

@@ -57,7 +57,7 @@ void HttpClientImp::sendRequest(const string& url,float fTimeOutSec) {
 #if defined(__GNUC__) && (__GNUC__ < 5)
 			public_send(data,len);
 #else//defined(__GNUC__) && (__GNUC__ < 5)
-			HttpClient::send(data,len);
+			HttpClient::send(obtainBuffer(data,len));
 #endif//defined(__GNUC__) && (__GNUC__ < 5)
 		});
 #endif //ENABLE_OPENSSL
@@ -78,28 +78,12 @@ void HttpClientImp::onRecvBytes(const char* data, int size) {
 	}
 }
 
-int HttpClientImp::send(const string& str) {
+int HttpClientImp::send(const Buffer::Ptr &buf) {
 	if(_sslBox){
-		_sslBox->onSend(str.data(),str.size());
-		return str.size();
+		_sslBox->onSend(buf->data(),buf->size());
+		return buf->size();
 	}
-	return HttpClient::send(str);
-}
-int HttpClientImp::send(string &&str){
-	if(_sslBox){
-		_sslBox->onSend(str.data(),str.size());
-		return str.size();
-	}
-	return HttpClient::send(std::move(str));
-}
-
-int HttpClientImp::send(const char* str, int len) {
-	if(_sslBox){
-		_sslBox->onSend(str,len);
-		return len;
-	}
-	return HttpClient::send(str,len);
-
+	return HttpClient::send(buf);
 }
 #endif //ENABLE_OPENSSL
 

src/Http/HttpClientImp.h

@@ -48,15 +48,13 @@ public:
 		HttpClient::onRecvBytes(data,len);
 	}
 	void public_send(const char *data, uint32_t len){
-		HttpClient::send(data,len);
+		HttpClient::send(obtainBuffer(data,len));
 	}
 #endif //defined(__GNUC__) && (__GNUC__ < 5)
 private:
 #ifdef ENABLE_OPENSSL
 	virtual void onRecvBytes(const char *data,int size) override;
-	virtual int send(const string &str) override;
-	virtual int send(string &&str) override;
-	virtual int send(const char *str, int len) override;
+	virtual int send(const Buffer::Ptr &buf) override;
 	std::shared_ptr<SSL_Box> _sslBox;
 #endif //ENABLE_OPENSSL
 };

src/Http/HttpRequestSplitter.cpp

@@ -43,6 +43,16 @@ void HttpRequestSplitter::input(const char *data,uint64_t len) {
 
 splitPacket:
 
+    /*确保ptr最后一个字节是0，防止strstr越界
+     *由于ZLToolKit确保内存最后一个字节是保留未使用字节并置0，
+     *所以此处可以不用再次置0
+     *但是上层数据可能来自其他渠道，保险起见还是置0
+     */
+
+    char &tail_ref = ((char *) ptr)[len];
+    char tail_tmp = tail_ref;
+    tail_ref = 0;
+
     //数据按照请求头处理
     const char *index = nullptr;
     while (_content_len == 0 && (index = strstr(ptr,"\r\n\r\n")) != nullptr) {
@@ -51,6 +61,11 @@ splitPacket:
         ptr = index + 4;
     }
 
+    /*
+     * 恢复末尾字节
+     */
+    tail_ref = tail_tmp;
+
     uint64_t remain = len - (ptr - data);
     if(remain <= 0){
         //没有剩余数据，清空缓存

src/Http/HttpSession.cpp

@@ -49,7 +49,7 @@ using namespace ZL::Util;
 namespace ZL {
 namespace Http {
 
-static int sock_flags = SOCKET_DEFAULE_FLAGS | FLAG_MORE;
+static int kSockFlags = SOCKET_DEFAULE_FLAGS | FLAG_MORE;
 
 string dateStr() {
 	char buf[64];
@@ -235,7 +235,7 @@ inline bool HttpSession::checkLiveFlvStream(){
         //开始发送rtmp负载
         //关闭tcp_nodelay ,优化性能
         SockUtil::setNoDelay(_sock->rawFD(),false);
-        (*this) << SocketFlags(sock_flags);
+        (*this) << SocketFlags(kSockFlags);
 
 		try{
 			start(mediaSrc);
@@ -425,29 +425,10 @@ inline bool HttpSession::Handle_Req_GET(int64_t &content_len) {
 	//关闭tcp_nodelay ,优化性能
 	SockUtil::setNoDelay(_sock->rawFD(),false);
     //设置MSG_MORE，优化性能
-    (*this) << SocketFlags(sock_flags);
-
-    //后台线程执行onFlush
-    auto onFlushWrapper = [onFlush,weakSelf](){
-        auto strongSelf = weakSelf.lock();
-        if(!strongSelf){
-            return false;
-        }
-        strongSelf->async([onFlush,weakSelf](){
-            //在后台线程完成文件读取，释放主线程性能
-            if(!onFlush()){
-                //如果onFlush返回false，则说明不再监听flush事件
-                auto strongSelf = weakSelf.lock();
-                if(strongSelf){
-                    strongSelf->_sock->setOnFlush(nullptr);
-                }
-            }
-        });
-        return true;
-    };
+    (*this) << SocketFlags(kSockFlags);
 
     onFlush();
-	_sock->setOnFlush(onFlushWrapper);
+	_sock->setOnFlush(onFlush);
 	return true;
 }
 

src/Http/HttpSession.h

@@ -126,34 +126,185 @@ private:
 					   const string &contentOut);
 };
 
+
 /**
- * 回显WebSocket会话
+ * 通过该模板类可以透明化WebSocket协议，
+ * 用户只要实现WebSock协议下的具体业务协议，譬如基于WebSocket协议的Rtmp协议等
+ * @tparam SessionType 业务协议的TcpSession类
  */
-class EchoWebSocketSession : public HttpSession {
+template <typename SessionType>
+class WebSocketSession : public HttpSession {
 public:
-    EchoWebSocketSession(const std::shared_ptr<ThreadPool> &pTh, const Socket::Ptr &pSock) : HttpSession(pTh,pSock){};
-    virtual ~EchoWebSocketSession(){};
+    WebSocketSession(const std::shared_ptr<ThreadPool> &pTh, const Socket::Ptr &pSock) : HttpSession(pTh,pSock){
+        _session = std::make_shared<SessionImp>(pTh,pSock);
+    }
+    virtual ~WebSocketSession(){};
+
+    //收到eof或其他导致脱离TcpServer事件的回调
+    void onError(const SockException &err) override{
+        HttpSession::onError(err);
+        _session->onError(err);
+    }
+    //每隔一段时间触发，用来做超时管理
+    void onManager() override{
+        HttpSession::onManager();
+        _session->onManager();
+    }
+    //在创建TcpSession后，TcpServer会把自身的配置参数通过该函数传递给TcpSession
+    void attachServer(const TcpServer &server) override{
+        HttpSession::attachServer(server);
+        _session->attachServer(server);
+
+        //此处截取数据并进行websocket协议打包
+        weak_ptr<WebSocketSession> weakSelf = dynamic_pointer_cast<WebSocketSession>(shared_from_this());
+        _session->setOnBeforeSendCB([weakSelf](const Buffer::Ptr &buf){
+            auto strongSelf = weakSelf.lock();
+            if(strongSelf){
+                bool mask_flag = strongSelf->_mask_flag;
+                strongSelf->_mask_flag = false;
+                strongSelf->WebSocketSplitter::encode((uint8_t *)buf->data(),buf->size());
+                strongSelf->_mask_flag = mask_flag;
+            }
+            return buf->size();
+        });
+
+    }
+    //作为该TcpSession的唯一标识符
+    string getIdentifier() const override{
+        return _session->getIdentifier();
+    }
 protected:
+    /**
+     * 开始收到一个webSocket数据包
+     * @param packet
+     */
     void onWebSocketDecodeHeader(const WebSocketHeader &packet) override{
-        DebugL << packet._playload_len;
-    };
+        //新包，原来的包残余数据清空掉
+        _remian_data.clear();
+    }
+
+    /**
+     * 收到websocket数据包负载
+     * @param packet
+     * @param ptr
+     * @param len
+     * @param recved
+     */
     void onWebSocketDecodePlayload(const WebSocketHeader &packet,const uint8_t *ptr,uint64_t len,uint64_t recved) override {
-        DebugL << string((char *)ptr,len) << " " << recved;
-
-        //webSocket服务器不允许对数据进行掩码加密
-        bool mask_flag = _mask_flag;
-        _mask_flag = false;
-        WebSocketSplitter::encode((uint8_t *)ptr,len);
-        _mask_flag = mask_flag;
-
-    };
+        if(packet._playload_len == recved){
+            //收到完整的包
+            if(_remian_data.empty()){
+                onRecvWholePacket((char *)ptr,len);
+            }else{
+                _remian_data.append((char *)ptr,len);
+                onRecvWholePacket(_remian_data);
+                _remian_data.clear();
+            }
+        } else {
+            //部分数据
+            _remian_data.append((char *)ptr,len);
+        }
+    }
 
+    /**
+     * 发送数据进行websocket协议打包后回调
+     * @param ptr
+     * @param len
+     */
     void onWebSocketEncodeData(const uint8_t *ptr,uint64_t len) override{
-        send((char *)ptr,len);
-    };
+        _session->realSend(_session->obtainBuffer((char *)ptr,len));
+    }
 
+    /**
+     * 收到一个完整的websock数据包
+     * @param data
+     * @param len
+     */
+    void onRecvWholePacket(const char *data,uint64_t len){
+        BufferRaw::Ptr buffer = _session->obtainBuffer(data,len);
+        _session->onRecv(buffer);
+    }
+
+    /**
+     * 收到一个完整的websock数据包
+     * @param str
+     */
+    void onRecvWholePacket(const string &str){
+        BufferString::Ptr buffer = std::make_shared<BufferString>(str);
+        _session->onRecv(buffer);
+    }
+
+private:
+    typedef function<int(const Buffer::Ptr &buf)> onBeforeSendCB;
+    /**
+     * 该类实现了TcpSession派生类发送数据的截取
+     * 目的是发送业务数据前进行websocket协议的打包
+     */
+    class SessionImp : public SessionType{
+    public:
+        SessionImp(const std::shared_ptr<ThreadPool> &pTh, const Socket::Ptr &pSock) : SessionType(pTh,pSock){};
+        ~SessionImp(){}
+
+        /**
+         * 截取到数据后，再进行webSocket协议打包
+         * 然后真正的发送数据到socket
+         * @param buf 数据
+         * @return 数据字节数
+         */
+        int realSend(const Buffer::Ptr &buf){
+            return SessionType::send(buf);
+        }
+
+        /**
+         * 设置发送数据截取回调函数
+         * @param cb 截取回调函数
+         */
+        void setOnBeforeSendCB(const onBeforeSendCB &cb){
+            _beforeSendCB = cb;
+        }
+    protected:
+        /**
+         * 重载send函数截取数据
+         * @param buf 需要截取的数据
+         * @return 数据字节数
+         */
+        int send(const Buffer::Ptr &buf) override {
+            if(_beforeSendCB){
+                return _beforeSendCB(buf);
+            }
+            return SessionType::send(buf);
+        }
+    private:
+        onBeforeSendCB _beforeSendCB;
+    };
+private:
+    std::shared_ptr<SessionImp> _session;
+    string _remian_data;
 };
 
+/**
+ * 回显会话
+ */
+class EchoSession : public TcpSession {
+public:
+    EchoSession(const std::shared_ptr<ThreadPool> &pTh, const Socket::Ptr &pSock) : TcpSession(pTh,pSock){};
+    virtual ~EchoSession(){};
+
+    void onRecv(const Buffer::Ptr &buffer) override {
+        send(buffer);
+    }
+    void onError(const SockException &err) override{
+        WarnL << err.what();
+    }
+    //每隔一段时间触发，用来做超时管理
+    void onManager() override{
+        DebugL;
+    }
+};
+
+
+typedef WebSocketSession<EchoSession> EchoWebSocketSession;
+
 } /* namespace Http */
 } /* namespace ZL */
 

src/Http/HttpsSession.h

@@ -44,7 +44,7 @@ public:
 #if defined(__GNUC__) && (__GNUC__ < 5)
 			public_send(data,len);
 #else//defined(__GNUC__) && (__GNUC__ < 5)
-			HttpSession::send(data,len);
+			HttpSession::send(obtainBuffer(data,len));
 #endif//defined(__GNUC__) && (__GNUC__ < 5)
 		});
 		m_sslBox.setOnDecData([&](const char *data, uint32_t len){
@@ -64,27 +64,17 @@ public:
 	}
 #if defined(__GNUC__) && (__GNUC__ < 5)
 	int public_send(const char *data, uint32_t len){
-		return HttpSession::send(data,len);
+		return HttpSession::send(obtainBuffer(data,len));
 	}
 	void public_onRecv(const char *data, uint32_t len){
 		HttpSession::onRecv(data,len);
 	}
 #endif//defined(__GNUC__) && (__GNUC__ < 5)
 private:
-	virtual int send(const string &buf) override{
+	virtual int send(const Buffer::Ptr &buf) override{
 		TimeTicker();
-		m_sslBox.onSend(buf.data(), buf.size());
-		return buf.size();
-	}
-	virtual int send(string &&buf) override{
-		TimeTicker();
-		m_sslBox.onSend(buf.data(), buf.size());
-		return buf.size();
-	}
-	virtual int send(const char *buf, int size) override{
-		TimeTicker();
-		m_sslBox.onSend(buf, size);
-		return size;
+		m_sslBox.onSend(buf->data(), buf->size());
+		return buf->size();
 	}
 	SSL_Box m_sslBox;
 };