Mirror/ZLMediaKit
1
0
Fork 0
mirror of https://github.com/ZLMediaKit/ZLMediaKit.git synced 2026-06-14 03:55:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

整理命名空间 (#1409)

Browse Source 
* feat: remove using namespace mediakit in header files.

(cherry picked from commit d44aeb339a8a0e1f0455be82b21fe4b1b536299f)

* feat: remove using namespace mediakit in FFmpegSource.h

* feat: remove using namespace mediakit in RtpExt.h

* feat: remove using namespace mediakit in header files.

* feat: remove using namespace std in header files.

* feat: remove using namespace std in header files when zltoolkit remove std in header

* 补充命名空间

* 整理命名空间

* 整理命名空间2

* 修复macos ci

* 修复编译问题

* 修复编译问题2

* 修复编译问题3

Co-authored-by: Johnny <hellojinqiang@gmail.com>
Co-authored-by: Xiaofeng Wang <wasphin@gmail.com>
This commit is contained in:
夏楚
2022-02-02 20:34:50 +08:00
committed by GitHub
parent 80a0e27d8c
commit c72cf4cbcc
239 changed files with 1887 additions and 1766 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/Http/HlsParser.cpp
View File

@@ -13,7 +13,10 @@
#include "HlsParser.h"
#include "Util/util.h"
#include "Common/Parser.h"
using namespace std;
using namespace toolkit;
namespace mediakit {
bool HlsParser::parse(const string &http_url, const string &m3u8) {

8
src/Http/HlsParser.h
View File

@@ -14,12 +14,12 @@
#include <string>
#include <list>
#include <map>
using namespace std;
namespace mediakit {
typedef struct{
//url地址
string url;
std::string url;
//ts切片长度
float duration;
@@ -38,7 +38,7 @@ class HlsParser {
public:
HlsParser(){}
~HlsParser(){}
bool parse(const string &http_url,const string &m3u8);
bool parse(const std::string &http_url,const std::string &m3u8);
/**
* 是否存在#EXTM3U字段，是否为m3u8文件
@@ -82,7 +82,7 @@ public:
protected:
//解析出ts文件地址回调
virtual void onParsed(bool is_m3u8_inner,int64_t sequence,const map<int,ts_segment> &ts_list) {};
virtual void onParsed(bool is_m3u8_inner,int64_t sequence,const std::map<int,ts_segment> &ts_list) {};
private:
bool _is_m3u8 = false;

9
src/Http/HlsPlayer.cpp
View File

@@ -10,6 +10,9 @@
#include "HlsPlayer.h"
using namespace std;
using namespace toolkit;
namespace mediakit {
HlsPlayer::HlsPlayer(const EventPoller::Ptr &poller) {
@@ -27,8 +30,8 @@ void HlsPlayer::fetchIndexFile() {
if (waitResponse()) {
return;
}
if (!(*this)[kNetAdapter].empty()) {
setNetAdapter((*this)[kNetAdapter]);
if (!(*this)[Client::kNetAdapter].empty()) {
setNetAdapter((*this)[Client::kNetAdapter]);
}
setCompleteTimeout((*this)[Client::kTimeoutMS].as<int>());
setMethod("GET");
@@ -83,7 +86,7 @@ void HlsPlayer::fetchSegment() {
strong_self->onPacket_l(data, len);
});
if (!(*this)[kNetAdapter].empty()) {
if (!(*this)[Client::kNetAdapter].empty()) {
_http_ts_player->setNetAdapter((*this)[Client::kNetAdapter]);
}
}

50
src/Http/HlsPlayer.h
View File

@@ -17,8 +17,6 @@
#include "HlsParser.h"
#include "Rtp/TSDecoder.h"
using namespace toolkit;
namespace mediakit {
class HlsDemuxer
@@ -29,12 +27,12 @@ public:
HlsDemuxer() = default;
~HlsDemuxer() override { _timer = nullptr; }
void start(const EventPoller::Ptr &poller, TrackListener *listener);
void start(const toolkit::EventPoller::Ptr &poller, TrackListener *listener);
bool inputFrame(const Frame::Ptr &frame) override;
bool addTrack(const Track::Ptr &track) override { return _delegate.addTrack(track); }
void addTrackCompleted() override { _delegate.addTrackCompleted(); }
void resetTracks() override { ((MediaSink &)_delegate).resetTracks(); }
vector<Track::Ptr> getTracks(bool ready = true) const override { return _delegate.getTracks(ready); }
std::vector<Track::Ptr> getTracks(bool ready = true) const override { return _delegate.getTracks(ready); }
private:
void onTick();
@@ -44,22 +42,22 @@ private:
private:
int64_t _ticker_offset = 0;
Ticker _ticker;
toolkit::Ticker _ticker;
Stamp _stamp[2];
Timer::Ptr _timer;
toolkit::Timer::Ptr _timer;
MediaSinkDelegate _delegate;
multimap<int64_t, Frame::Ptr> _frame_cache;
std::multimap<int64_t, Frame::Ptr> _frame_cache;
};
class HlsPlayer : public HttpClientImp , public PlayerBase , public HlsParser{
public:
HlsPlayer(const EventPoller::Ptr &poller);
HlsPlayer(const toolkit::EventPoller::Ptr &poller);
~HlsPlayer() override = default;
/**
* 开始播放
*/
void play(const string &url) override;
void play(const std::string &url) override;
/**
* 停止播放
@@ -76,37 +74,37 @@ protected:
private:
void onParsed(bool is_m3u8_inner,int64_t sequence,const map<int,ts_segment> &ts_map) override;
void onResponseHeader(const string &status,const HttpHeader &headers) override;
void onResponseHeader(const std::string &status,const HttpHeader &headers) override;
void onResponseBody(const char *buf,size_t size) override;
void onResponseCompleted(const SockException &e) override;
bool onRedirectUrl(const string &url,bool temporary) override;
void onResponseCompleted(const toolkit::SockException &e) override;
bool onRedirectUrl(const std::string &url,bool temporary) override;
private:
void playDelay();
float delaySecond();
void fetchSegment();
void teardown_l(const SockException &ex);
void teardown_l(const toolkit::SockException &ex);
void fetchIndexFile();
void onPacket_l(const char *data, size_t len);
private:
struct UrlComp {
//url忽略？后面的参数
bool operator()(const string& __x, const string& __y) const {
return split(__x,"?")[0] < split(__y,"?")[0];
bool operator()(const std::string& __x, const std::string& __y) const {
return toolkit::split(__x,"?")[0] < toolkit::split(__y,"?")[0];
}
};
private:
bool _play_result = false;
int64_t _last_sequence = -1;
string _m3u8;
string _play_url;
Timer::Ptr _timer;
Timer::Ptr _timer_ts;
list<ts_segment> _ts_list;
list<string> _ts_url_sort;
set<string, UrlComp> _ts_url_cache;
std::string _m3u8;
std::string _play_url;
toolkit::Timer::Ptr _timer;
toolkit::Timer::Ptr _timer_ts;
std::list<ts_segment> _ts_list;
std::list<std::string> _ts_url_sort;
std::set<std::string, UrlComp> _ts_url_cache;
HttpTSPlayer::Ptr _http_ts_player;
TSSegment _segment;
};
@@ -114,7 +112,7 @@ private:
class HlsPlayerImp : public PlayerImp<HlsPlayer, PlayerBase>, private TrackListener {
public:
typedef std::shared_ptr<HlsPlayerImp> Ptr;
HlsPlayerImp(const EventPoller::Ptr &poller = nullptr);
HlsPlayerImp(const toolkit::EventPoller::Ptr &poller = nullptr);
~HlsPlayerImp() override = default;
private:
@@ -123,9 +121,9 @@ private:
private:
//// PlayerBase override////
void onPlayResult(const SockException &ex) override;
vector<Track::Ptr> getTracks(bool ready = true) const override;
void onShutdown(const SockException &ex) override;
void onPlayResult(const toolkit::SockException &ex) override;
std::vector<Track::Ptr> getTracks(bool ready = true) const override;
void onShutdown(const toolkit::SockException &ex) override;
private:
//// TrackListener override////

3
src/Http/HttpBody.cpp
View File

@@ -22,6 +22,9 @@
#define ENABLE_MMAP
#endif
using namespace std;
using namespace toolkit;
namespace mediakit {
HttpStringBody::HttpStringBody(string str){

41
src/Http/HttpBody.h
View File

@@ -18,9 +18,6 @@
#include "Util/logger.h"
#include "Thread/WorkThreadPool.h"
using namespace std;
using namespace toolkit;
#ifndef MIN
#define MIN(a,b) ((a) < (b) ? (a) : (b) )
#endif //MIN
@@ -47,14 +44,14 @@ public:
* @param size 请求大小
* @return 字节对象,如果读完了，那么请返回nullptr
*/
virtual Buffer::Ptr readData(size_t size) { return nullptr;};
virtual toolkit::Buffer::Ptr readData(size_t size) { return nullptr;};
/**
* 异步请求读取一定字节数，返回大小可能小于size
* @param size 请求大小
* @param cb 回调函数
*/
virtual void readDataAsync(size_t size,const function<void(const Buffer::Ptr &buf)> &cb){
virtual void readDataAsync(size_t size,const std::function<void(const toolkit::Buffer::Ptr &buf)> &cb){
//由于unix和linux是通过mmap的方式读取文件，所以把读文件操作放在后台线程并不能提高性能
//反而会由于频繁的线程切换导致性能降低以及延时增加，所以我们默认同步获取文件内容
//(其实并没有读，拷贝文件数据时在内核态完成文件读)
@@ -63,20 +60,20 @@ public:
};
/**
* string类型的content
* std::string类型的content
*/
class HttpStringBody : public HttpBody{
public:
typedef std::shared_ptr<HttpStringBody> Ptr;
HttpStringBody(string str);
HttpStringBody(std::string str);
~HttpStringBody() override = default;
ssize_t remainSize() override;
Buffer::Ptr readData(size_t size) override ;
toolkit::Buffer::Ptr readData(size_t size) override ;
private:
size_t _offset = 0;
mutable string _str;
mutable std::string _str;
};
/**
@@ -85,14 +82,14 @@ private:
class HttpBufferBody : public HttpBody{
public:
typedef std::shared_ptr<HttpBufferBody> Ptr;
HttpBufferBody(Buffer::Ptr buffer);
HttpBufferBody(toolkit::Buffer::Ptr buffer);
~HttpBufferBody() override = default;
ssize_t remainSize() override;
Buffer::Ptr readData(size_t size) override;
toolkit::Buffer::Ptr readData(size_t size) override;
private:
Buffer::Ptr _buffer;
toolkit::Buffer::Ptr _buffer;
};
/**
@@ -110,11 +107,11 @@ public:
* @param use_mmap 是否使用mmap方式访问文件
*/
HttpFileBody(const std::shared_ptr<FILE> &fp, size_t offset, size_t max_size, bool use_mmap = true);
HttpFileBody(const string &file_path, bool use_mmap = true);
HttpFileBody(const std::string &file_path, bool use_mmap = true);
~HttpFileBody() override = default;
ssize_t remainSize() override ;
Buffer::Ptr readData(size_t size) override;
toolkit::Buffer::Ptr readData(size_t size) override;
private:
void init(const std::shared_ptr<FILE> &fp,size_t offset,size_t max_size, bool use_mmap);
@@ -124,7 +121,7 @@ private:
size_t _offset = 0;
std::shared_ptr<FILE> _fp;
std::shared_ptr<char> _map_addr;
ResourcePool<BufferRaw> _pool;
toolkit::ResourcePool<toolkit::BufferRaw> _pool;
};
class HttpArgs;
@@ -142,21 +139,21 @@ public:
* @param filePath 文件路径
* @param boundary boundary字符串
*/
HttpMultiFormBody(const HttpArgs &args,const string &filePath,const string &boundary = "0xKhTmLbOuNdArY");
HttpMultiFormBody(const HttpArgs &args,const std::string &filePath,const std::string &boundary = "0xKhTmLbOuNdArY");
virtual ~HttpMultiFormBody(){}
ssize_t remainSize() override ;
Buffer::Ptr readData(size_t size) override;
toolkit::Buffer::Ptr readData(size_t size) override;
public:
static string multiFormBodyPrefix(const HttpArgs &args,const string &boundary,const string &fileName);
static string multiFormBodySuffix(const string &boundary);
static string multiFormContentType(const string &boundary);
static std::string multiFormBodyPrefix(const HttpArgs &args,const std::string &boundary,const std::string &fileName);
static std::string multiFormBodySuffix(const std::string &boundary);
static std::string multiFormContentType(const std::string &boundary);
private:
size_t _offset = 0;
size_t _totalSize;
string _bodyPrefix;
string _bodySuffix;
std::string _bodyPrefix;
std::string _bodySuffix;
HttpFileBody::Ptr _fileBody;
};

2
src/Http/HttpChunkedSplitter.cpp
View File

@@ -11,6 +11,8 @@
#include <string.h>
#include "HttpChunkedSplitter.h"
using namespace std;
namespace mediakit{
const char *HttpChunkedSplitter::onSearchPacketTail(const char *data, size_t len) {

3
src/Http/HttpClient.cpp
View File

@@ -13,6 +13,9 @@
#include "HttpClient.h"
#include "Common/config.h"
using namespace std;
using namespace toolkit;
namespace mediakit {
void HttpClient::sendRequest(const string &url) {

51
src/Http/HttpClient.h
View File

@@ -25,18 +25,15 @@
#include "strCoding.h"
#include "HttpBody.h"
using namespace std;
using namespace toolkit;
namespace mediakit {
class HttpArgs : public map<string, variant, StrCaseCompare> {
class HttpArgs : public std::map<std::string, toolkit::variant, StrCaseCompare> {
public:
HttpArgs() = default;
~HttpArgs() = default;
string make() const {
string ret;
std::string make() const {
std::string ret;
for (auto &pr : *this) {
ret.append(pr.first);
ret.append("=");
@@ -50,7 +47,7 @@ public:
}
};
class HttpClient : public TcpClient, public HttpRequestSplitter {
class HttpClient : public toolkit::TcpClient, public HttpRequestSplitter {
public:
using HttpHeader = StrCaseMap;
using Ptr = std::shared_ptr<HttpClient>;
@@ -62,7 +59,7 @@ public:
* 发送http[s]请求
* @param url 请求url
*/
virtual void sendRequest(const string &url);
virtual void sendRequest(const std::string &url);
/**
* 重置对象
@@ -73,7 +70,7 @@ public:
* 设置http方法
* @param method GET/POST等
*/
void setMethod(string method);
void setMethod(std::string method);
/**
* 覆盖http头
@@ -81,13 +78,13 @@ public:
*/
void setHeader(HttpHeader header);
HttpClient &addHeader(string key, string val, bool force = false);
HttpClient &addHeader(std::string key, std::string val, bool force = false);
/**
* 设置http content
* @param body http content
*/
void setBody(string body);
void setBody(std::string body);
/**
* 设置http content
@@ -113,7 +110,7 @@ public:
/**
* 获取请求url
*/
const string &getUrl() const;
const std::string &getUrl() const;
/**
* 判断是否正在等待响应
@@ -150,7 +147,7 @@ protected:
* @param status 状态码，譬如:200 OK
* @param headers http头
*/
virtual void onResponseHeader(const string &status, const HttpHeader &headers) = 0;
virtual void onResponseHeader(const std::string &status, const HttpHeader &headers) = 0;
/**
* 收到http conten数据
@@ -162,7 +159,7 @@ protected:
/**
* 接收http回复完毕,
*/
virtual void onResponseCompleted(const SockException &ex) = 0;
virtual void onResponseCompleted(const toolkit::SockException &ex) = 0;
/**
* 重定向事件
@@ -170,7 +167,7 @@ protected:
* @param temporary 是否为临时重定向
* @return 是否继续
*/
virtual bool onRedirectUrl(const string &url, bool temporary) { return true; };
virtual bool onRedirectUrl(const std::string &url, bool temporary) { return true; };
protected:
//// HttpRequestSplitter override ////
@@ -178,15 +175,15 @@ protected:
void onRecvContent(const char *data, size_t len) override;
//// TcpClient override ////
void onConnect(const SockException &ex) override;
void onRecv(const Buffer::Ptr &pBuf) override;
void onErr(const SockException &ex) override;
void onConnect(const toolkit::SockException &ex) override;
void onRecv(const toolkit::Buffer::Ptr &pBuf) override;
void onErr(const toolkit::SockException &ex) override;
void onFlush() override;
void onManager() override;
private:
void onResponseCompleted_l(const SockException &ex);
void onConnect_l(const SockException &ex);
void onResponseCompleted_l(const toolkit::SockException &ex);
void onConnect_l(const toolkit::SockException &ex);
void checkCookie(HttpHeader &headers);
void clearResponse();
@@ -201,23 +198,23 @@ private:
//for request args
bool _is_https;
string _url;
std::string _url;
HttpHeader _user_set_header;
HttpBody::Ptr _body;
string _method;
string _last_host;
std::string _method;
std::string _last_host;
//for this request
string _path;
std::string _path;
HttpHeader _header;
//for timeout
size_t _wait_header_ms = 10 * 1000;
size_t _wait_body_ms = 10 * 1000;
size_t _wait_complete_ms = 0;
Ticker _wait_header;
Ticker _wait_body;
Ticker _wait_complete;
toolkit::Ticker _wait_header;
toolkit::Ticker _wait_body;
toolkit::Ticker _wait_complete;
};
} /* namespace mediakit */

2
src/Http/HttpClientImp.cpp
View File

@@ -10,6 +10,8 @@
#include "Http/HttpClientImp.h"
using namespace toolkit;
namespace mediakit {
void HttpClientImp::onConnect(const SockException &ex) {

6
src/Http/HttpClientImp.h
View File

@@ -13,17 +13,17 @@
#include "HttpClient.h"
#include "Util/SSLBox.h"
using namespace toolkit;
namespace mediakit {
class HttpClientImp : public TcpClientWithSSL<HttpClient> {
class HttpClientImp : public toolkit::TcpClientWithSSL<HttpClient> {
public:
using Ptr = std::shared_ptr<HttpClientImp>;
HttpClientImp() = default;
~HttpClientImp() override = default;
protected:
void onConnect(const SockException &ex) override;
void onConnect(const toolkit::SockException &ex) override;
};
} /* namespace mediakit */

3
src/Http/HttpConst.cpp
View File

@@ -13,6 +13,9 @@
#include "Common/Parser.h"
#include "Util/onceToken.h"
using namespace std;
using namespace toolkit;
namespace mediakit{
const char *getHttpStatusMessage(int status) {

3
src/Http/HttpConst.h
View File

@@ -12,7 +12,6 @@
#define ZLMEDIAKIT_HTTPCONST_H
#include <string>
using namespace std;
namespace mediakit{
@@ -28,7 +27,7 @@ const char *getHttpStatusMessage(int status);
* @param name 文件后缀，譬如html
* @return mime值，譬如text/html
*/
const string &getHttpContentType(const char *name);
const std::string &getHttpContentType(const char *name);
}//mediakit

2
src/Http/HttpCookie.cpp
View File

@@ -17,6 +17,8 @@
#endif
using namespace toolkit;
using namespace std;
namespace mediakit {
void HttpCookie::setPath(const string &path){

27
src/Http/HttpCookie.h
View File

@@ -17,7 +17,6 @@
#include <map>
#include <unordered_map>
#include <mutex>
using namespace std;
namespace mediakit {
@@ -31,19 +30,19 @@ public:
HttpCookie(){}
~HttpCookie(){}
void setPath(const string &path);
void setHost(const string &host);
void setExpires(const string &expires,const string &server_date);
void setKeyVal(const string &key,const string &val);
void setPath(const std::string &path);
void setHost(const std::string &host);
void setExpires(const std::string &expires,const std::string &server_date);
void setKeyVal(const std::string &key,const std::string &val);
operator bool ();
const string &getKey() const ;
const string &getVal() const ;
const std::string &getKey() const ;
const std::string &getVal() const ;
private:
string _host;
string _path = "/";
string _key;
string _val;
std::string _host;
std::string _path = "/";
std::string _key;
std::string _val;
time_t _expire = 0;
};
@@ -56,12 +55,12 @@ public:
~HttpCookieStorage(){}
static HttpCookieStorage &Instance();
void set(const HttpCookie::Ptr &cookie);
vector<HttpCookie::Ptr> get(const string &host,const string &path);
std::vector<HttpCookie::Ptr> get(const std::string &host,const std::string &path);
private:
HttpCookieStorage(){};
private:
unordered_map<string/*host*/,map<string/*cookie path*/,map<string/*cookie_key*/,HttpCookie::Ptr> > > _all_cookie;
mutex _mtx_cookie;
std::unordered_map<std::string/*host*/, std::map<std::string/*cookie path*/,std::map<std::string/*cookie_key*/, HttpCookie::Ptr> > > _all_cookie;
std::mutex _mtx_cookie;
};

3
src/Http/HttpCookieManager.cpp
View File

@@ -13,6 +13,9 @@
#include "Common/config.h"
#include "HttpCookieManager.h"
using namespace std;
using namespace toolkit;
namespace mediakit {
//////////////////////////////HttpServerCookie////////////////////////////////////

66
src/Http/HttpCookieManager.h
View File

@@ -19,10 +19,6 @@
#include "Network/Socket.h"
#include "Common/Parser.h"
using namespace std;
using namespace toolkit;
using namespace mediakit;
#define COOKIE_DEFAULT_LIFE (7 * 24 * 60 * 60)
namespace mediakit {
@@ -32,7 +28,7 @@ class HttpCookieManager;
/**
* cookie对象，用于保存cookie的一些相关属性
*/
class HttpServerCookie : public AnyStorage , public noncopyable{
class HttpServerCookie : public toolkit::AnyStorage , public toolkit::noncopyable{
public:
typedef std::shared_ptr<HttpServerCookie> Ptr;
/**
@@ -45,9 +41,9 @@ public:
*/
HttpServerCookie(const std::shared_ptr<HttpCookieManager> &manager,
const string &cookie_name,
const string &uid,
const string &cookie,
const std::string &cookie_name,
const std::string &uid,
const std::string &cookie,
uint64_t max_elapsed);
~HttpServerCookie() ;
@@ -55,7 +51,7 @@ public:
* 获取uid
* @return uid
*/
const string &getUid() const;
const std::string &getUid() const;
/**
* 获取http中Set-Cookie字段的值
@@ -63,19 +59,19 @@ public:
* @param path http访问路径
* @return 例如 MY_SESSION=XXXXXX;expires=Wed, Jun 12 2019 06:30:48 GMT;path=/index/files/
*/
string getCookie(const string &path) const;
std::string getCookie(const std::string &path) const;
/**
* 获取cookie随机字符串
* @return cookie随机字符串
*/
const string& getCookie() const;
const std::string& getCookie() const;
/**
* 获取该cookie名
* @return
*/
const string& getCookieName() const;
const std::string& getCookieName() const;
/**
* 更新该cookie的过期时间，可以让此cookie不失效
@@ -92,16 +88,16 @@ public:
* 获取区域锁
* @return
*/
std::shared_ptr<lock_guard<recursive_mutex> > getLock();
std::shared_ptr<std::lock_guard<std::recursive_mutex> > getLock();
private:
string cookieExpireTime() const ;
std::string cookieExpireTime() const ;
private:
string _uid;
string _cookie_name;
string _cookie_uuid;
std::string _uid;
std::string _cookie_name;
std::string _cookie_uuid;
uint64_t _max_elapsed;
Ticker _ticker;
recursive_mutex _mtx;
toolkit::Ticker _ticker;
std::recursive_mutex _mtx;
std::weak_ptr<HttpCookieManager> _manager;
};
@@ -117,18 +113,18 @@ public:
* 获取不碰撞的随机字符串
* @return 随机字符串
*/
string obtain();
std::string obtain();
/**
* 释放随机字符串
* @param str 随机字符串
*/
void release(const string &str);
void release(const std::string &str);
private:
string obtain_l();
std::string obtain_l();
private:
//碰撞库
unordered_set<string> _obtained;
std::unordered_set<std::string> _obtained;
//增长index，防止碰撞用
int _index = 0;
};
@@ -156,7 +152,7 @@ public:
* @param max_elapsed 该cookie过期时间，单位秒
* @return cookie对象
*/
HttpServerCookie::Ptr addCookie(const string &cookie_name,const string &uid, uint64_t max_elapsed = COOKIE_DEFAULT_LIFE,int max_client = 1);
HttpServerCookie::Ptr addCookie(const std::string &cookie_name,const std::string &uid, uint64_t max_elapsed = COOKIE_DEFAULT_LIFE,int max_client = 1);
/**
* 根据cookie随机字符串查找cookie对象
@@ -164,7 +160,7 @@ public:
* @param cookie cookie随机字符串
* @return cookie对象，可以为nullptr
*/
HttpServerCookie::Ptr getCookie(const string &cookie_name,const string &cookie);
HttpServerCookie::Ptr getCookie(const std::string &cookie_name,const std::string &cookie);
/**
* 从http头中获取cookie对象
@@ -172,7 +168,7 @@ public:
* @param http_header http头
* @return cookie对象
*/
HttpServerCookie::Ptr getCookie(const string &cookie_name,const StrCaseMap &http_header);
HttpServerCookie::Ptr getCookie(const std::string &cookie_name,const StrCaseMap &http_header);
/**
* 根据uid获取cookie
@@ -180,7 +176,7 @@ public:
* @param uid 用户id
* @return cookie对象
*/
HttpServerCookie::Ptr getCookieByUid(const string &cookie_name,const string &uid);
HttpServerCookie::Ptr getCookieByUid(const std::string &cookie_name,const std::string &uid);
/**
* 删除cookie，用户登出时使用
@@ -197,7 +193,7 @@ private:
* @param uid 用户id
* @param cookie cookie随机字符串
*/
void onAddCookie(const string &cookie_name,const string &uid,const string &cookie);
void onAddCookie(const std::string &cookie_name,const std::string &uid,const std::string &cookie);
/**
* 析构cookie对象时触发
@@ -205,7 +201,7 @@ private:
* @param uid 用户id
* @param cookie cookie随机字符串
*/
void onDelCookie(const string &cookie_name,const string &uid,const string &cookie);
void onDelCookie(const std::string &cookie_name,const std::string &uid,const std::string &cookie);
/**
* 获取某用户名下最先登录时的cookie，目的是实现某用户下最多登录若干个设备
@@ -214,7 +210,7 @@ private:
* @param max_client 最多登录的设备个数
* @return 最早的cookie随机字符串
*/
string getOldestCookie(const string &cookie_name,const string &uid, int max_client = 1);
std::string getOldestCookie(const std::string &cookie_name,const std::string &uid, int max_client = 1);
/**
* 删除cookie
@@ -222,12 +218,12 @@ private:
* @param cookie cookie随机字符串
* @return 成功true
*/
bool delCookie(const string &cookie_name,const string &cookie);
bool delCookie(const std::string &cookie_name,const std::string &cookie);
private:
unordered_map<string/*cookie_name*/,unordered_map<string/*cookie*/,HttpServerCookie::Ptr/*cookie_data*/> >_map_cookie;
unordered_map<string/*cookie_name*/,unordered_map<string/*uid*/,map<uint64_t/*cookie time stamp*/,string/*cookie*/> > >_map_uid_to_cookie;
recursive_mutex _mtx_cookie;
Timer::Ptr _timer;
std::unordered_map<std::string/*cookie_name*/,std::unordered_map<std::string/*cookie*/,HttpServerCookie::Ptr/*cookie_data*/> >_map_cookie;
std::unordered_map<std::string/*cookie_name*/,std::unordered_map<std::string/*uid*/,std::map<uint64_t/*cookie time stamp*/,std::string/*cookie*/> > >_map_uid_to_cookie;
std::recursive_mutex _mtx_cookie;
toolkit::Timer::Ptr _timer;
RandStrGeneator _geneator;
};

1
src/Http/HttpDownloader.cpp
View File

@@ -12,6 +12,7 @@
#include "Util/File.h"
#include "Util/MD5.h"
using namespace toolkit;
using namespace std;
namespace mediakit {

12
src/Http/HttpDownloader.h
View File

@@ -18,7 +18,7 @@ namespace mediakit {
class HttpDownloader : public HttpClientImp {
public:
using Ptr = std::shared_ptr<HttpDownloader>;
using onDownloadResult = std::function<void(const SockException &ex, const string &filePath)>;
using onDownloadResult = std::function<void(const toolkit::SockException &ex, const std::string &filePath)>;
HttpDownloader() = default;
~HttpDownloader() override;
@@ -29,9 +29,9 @@ public:
* @param file_path 文件保存地址，置空则选择默认文件路径
* @param append 如果文件已经存在，是否断点续传方式下载
*/
void startDownload(const string &url, const string &file_path = "", bool append = false);
void startDownload(const std::string &url, const std::string &file_path = "", bool append = false);
void startDownload(const string &url, const onDownloadResult &cb) {
void startDownload(const std::string &url, const onDownloadResult &cb) {
setOnResult(cb);
startDownload(url, "", false);
}
@@ -40,15 +40,15 @@ public:
protected:
void onResponseBody(const char *buf, size_t size) override;
void onResponseHeader(const string &status, const HttpHeader &headers) override;
void onResponseCompleted(const SockException &ex) override;
void onResponseHeader(const std::string &status, const HttpHeader &headers) override;
void onResponseCompleted(const toolkit::SockException &ex) override;
private:
void closeFile();
private:
FILE *_save_file = nullptr;
string _file_path;
std::string _file_path;
onDownloadResult _on_result;
};

3
src/Http/HttpFileManager.cpp
View File

@@ -20,6 +20,9 @@
#include "Record/HlsMediaSource.h"
#include "Common/Parser.h"
using namespace std;
using namespace toolkit;
namespace mediakit {
// hls的播放cookie缓存时间默认60秒，

16
src/Http/HttpFileManager.h
View File

@@ -22,20 +22,20 @@ namespace mediakit {
class HttpResponseInvokerImp{
public:
typedef std::function<void(int code, const StrCaseMap &headerOut, const HttpBody::Ptr &body)> HttpResponseInvokerLambda0;
typedef std::function<void(int code, const StrCaseMap &headerOut, const string &body)> HttpResponseInvokerLambda1;
typedef std::function<void(int code, const StrCaseMap &headerOut, const std::string &body)> HttpResponseInvokerLambda1;
HttpResponseInvokerImp(){}
~HttpResponseInvokerImp(){}
template<typename C>
HttpResponseInvokerImp(const C &c):HttpResponseInvokerImp(typename function_traits<C>::stl_function_type(c)) {}
HttpResponseInvokerImp(const C &c):HttpResponseInvokerImp(typename toolkit::function_traits<C>::stl_function_type(c)) {}
HttpResponseInvokerImp(const HttpResponseInvokerLambda0 &lambda);
HttpResponseInvokerImp(const HttpResponseInvokerLambda1 &lambda);
void operator()(int code, const StrCaseMap &headerOut, const Buffer::Ptr &body) const;
void operator()(int code, const StrCaseMap &headerOut, const toolkit::Buffer::Ptr &body) const;
void operator()(int code, const StrCaseMap &headerOut, const HttpBody::Ptr &body) const;
void operator()(int code, const StrCaseMap &headerOut, const string &body) const;
void operator()(int code, const StrCaseMap &headerOut, const std::string &body) const;
void responseFile(const StrCaseMap &requestHeader,const StrCaseMap &responseHeader,const string &filePath, bool use_mmap = true) const;
void responseFile(const StrCaseMap &requestHeader,const StrCaseMap &responseHeader,const std::string &filePath, bool use_mmap = true) const;
operator bool();
private:
HttpResponseInvokerLambda0 _lambad;
@@ -46,7 +46,7 @@ private:
*/
class HttpFileManager {
public:
typedef function<void(int code, const string &content_type, const StrCaseMap &responseHeader, const HttpBody::Ptr &body)> invoker;
typedef std::function<void(int code, const std::string &content_type, const StrCaseMap &responseHeader, const HttpBody::Ptr &body)> invoker;
/**
* 访问文件或文件夹
@@ -54,14 +54,14 @@ public:
* @param parser http请求
* @param cb 回调对象
*/
static void onAccessPath(TcpSession &sender, Parser &parser, const invoker &cb);
static void onAccessPath(toolkit::TcpSession &sender, Parser &parser, const invoker &cb);
/**
* 获取mime值
* @param name 文件后缀
* @return mime值
*/
static const string &getContentType(const char *name);
static const std::string &getContentType(const char *name);
private:
HttpFileManager() = delete;
~HttpFileManager() = delete;

1
src/Http/HttpRequestSplitter.cpp
View File

@@ -12,6 +12,7 @@
#include "Util/logger.h"
#include "Util/util.h"
using namespace toolkit;
using namespace std;
//协议解析最大缓存1兆数据
static constexpr size_t kMaxCacheSize = 1 * 1024 * 1024;

4
src/Http/HttpRequestSplitter.h
View File

@@ -13,8 +13,6 @@
#include <string>
#include "Network/Buffer.h"
using namespace std;
using namespace toolkit;
namespace mediakit {
@@ -83,7 +81,7 @@ protected:
private:
ssize_t _content_len = 0;
size_t _remain_data_size = 0;
BufferLikeString _remain_data;
toolkit::BufferLikeString _remain_data;
};
} /* namespace mediakit */

3
src/Http/HttpRequester.cpp
View File

@@ -10,6 +10,9 @@
#include "HttpRequester.h"
using namespace std;
using namespace toolkit;
namespace mediakit {
void HttpRequester::onResponseHeader(const string &status, const HttpHeader &headers) {

10
src/Http/HttpRequester.h
View File

@@ -18,22 +18,22 @@ namespace mediakit {
class HttpRequester : public HttpClientImp {
public:
using Ptr = std::shared_ptr<HttpRequester>;
using HttpRequesterResult = std::function<void(const SockException &ex, const Parser &response)>;
using HttpRequesterResult = std::function<void(const toolkit::SockException &ex, const Parser &response)>;
HttpRequester() = default;
~HttpRequester() override = default;
void setOnResult(const HttpRequesterResult &onResult);
void startRequester(const string &url, const HttpRequesterResult &on_result, float timeout_sec = 10);
void startRequester(const std::string &url, const HttpRequesterResult &on_result, float timeout_sec = 10);
void clear() override;
private:
void onResponseHeader(const string &status, const HttpHeader &headers) override;
void onResponseHeader(const std::string &status, const HttpHeader &headers) override;
void onResponseBody(const char *buf, size_t size) override;
void onResponseCompleted(const SockException &ex) override;
void onResponseCompleted(const toolkit::SockException &ex) override;
private:
string _res_body;
std::string _res_body;
HttpRequesterResult _on_result;
};

2
src/Http/HttpSession.cpp
View File

@@ -17,6 +17,8 @@
#include "HttpConst.h"
#include "Util/base64.h"
#include "Util/SHA1.h"
using namespace std;
using namespace toolkit;
namespace mediakit {

38
src/Http/HttpSession.h
View File

@@ -22,12 +22,9 @@
#include "TS/TSMediaSource.h"
#include "FMP4/FMP4MediaSource.h"
using namespace std;
using namespace toolkit;
namespace mediakit {
class HttpSession: public TcpSession,
class HttpSession: public toolkit::TcpSession,
public FlvMuxer,
public HttpRequestSplitter,
public WebSocketSplitter {
@@ -40,19 +37,19 @@ public:
* @param accessPath 运行或禁止访问的根目录
* @param cookieLifeSecond 鉴权cookie有效期
**/
typedef std::function<void(const string &errMsg,const string &accessPath, int cookieLifeSecond)> HttpAccessPathInvoker;
typedef std::function<void(const std::string &errMsg,const std::string &accessPath, int cookieLifeSecond)> HttpAccessPathInvoker;
HttpSession(const Socket::Ptr &pSock);
HttpSession(const toolkit::Socket::Ptr &pSock);
~HttpSession() override;
void onRecv(const Buffer::Ptr &) override;
void onError(const SockException &err) override;
void onRecv(const toolkit::Buffer::Ptr &) override;
void onError(const toolkit::SockException &err) override;
void onManager() override;
static string urlDecode(const string &str);
static std::string urlDecode(const std::string &str);
protected:
//FlvMuxer override
void onWrite(const Buffer::Ptr &data, bool flush) override ;
void onWrite(const toolkit::Buffer::Ptr &data, bool flush) override ;
void onDetach() override;
std::shared_ptr<FlvMuxer> getSharedPtr() override;
@@ -74,7 +71,7 @@ protected:
size_t len,
size_t totalSize,
size_t recvedSize){
shutdown(SockException(Err_shutdown,"http post content is too huge,default closed"));
shutdown(toolkit::SockException(toolkit::Err_shutdown,"http post content is too huge,default closed"));
}
/**
@@ -92,7 +89,7 @@ protected:
* 发送数据进行websocket协议打包后回调
* @param buffer websocket协议数据
*/
void onWebSocketEncodeData(Buffer::Ptr buffer) override;
void onWebSocketEncodeData(toolkit::Buffer::Ptr buffer) override;
/**
* 接收到完整的一个webSocket数据包后回调
@@ -107,11 +104,11 @@ private:
void Handle_Req_HEAD(ssize_t &content_len);
void Handle_Req_OPTIONS(ssize_t &content_len);
bool checkLiveStream(const string &schema, const string &url_suffix, const function<void(const MediaSource::Ptr &src)> &cb);
bool checkLiveStream(const std::string &schema, const std::string &url_suffix, const std::function<void(const MediaSource::Ptr &src)> &cb);
bool checkLiveStreamFlv(const function<void()> &cb = nullptr);
bool checkLiveStreamTS(const function<void()> &cb = nullptr);
bool checkLiveStreamFMP4(const function<void()> &fmp4_list = nullptr);
bool checkLiveStreamFlv(const std::function<void()> &cb = nullptr);
bool checkLiveStreamTS(const std::function<void()> &cb = nullptr);
bool checkLiveStreamFMP4(const std::function<void()> &fmp4_list = nullptr);
bool checkWebSocket();
bool emitHttpEvent(bool doInvoke);
@@ -129,18 +126,17 @@ private:
bool _live_over_websocket = false;
//消耗的总流量
uint64_t _total_bytes_usage = 0;
string _origin;
std::string _origin;
Parser _parser;
Ticker _ticker;
toolkit::Ticker _ticker;
MediaInfo _mediaInfo;
TSMediaSource::RingType::RingReader::Ptr _ts_reader;
FMP4MediaSource::RingType::RingReader::Ptr _fmp4_reader;
//处理content数据的callback
function<bool (const char *data,size_t len) > _contentCallBack;
std::function<bool (const char *data,size_t len) > _contentCallBack;
};
typedef TcpSessionWithSSL<HttpSession> HttpsSession;
using HttpsSession = toolkit::TcpSessionWithSSL<HttpSession>;
} /* namespace mediakit */

3
src/Http/HttpTSPlayer.cpp
View File

@@ -10,6 +10,9 @@
#include "HttpTSPlayer.h"
using namespace std;
using namespace toolkit;
namespace mediakit {
HttpTSPlayer::HttpTSPlayer(const EventPoller::Ptr &poller, bool split_ts) {

12
src/Http/HttpTSPlayer.h
View File

@@ -15,17 +15,15 @@
#include "Player/MediaPlayer.h"
#include "Rtp/TSDecoder.h"
using namespace toolkit;
namespace mediakit {
//http-ts播发器，未实现ts解复用
class HttpTSPlayer : public HttpClientImp {
public:
using Ptr = std::shared_ptr<HttpTSPlayer>;
using onComplete = std::function<void(const SockException &)>;
using onComplete = std::function<void(const toolkit::SockException &)>;
HttpTSPlayer(const EventPoller::Ptr &poller = nullptr, bool split_ts = true);
HttpTSPlayer(const toolkit::EventPoller::Ptr &poller = nullptr, bool split_ts = true);
~HttpTSPlayer() override = default;
/**
@@ -40,9 +38,9 @@ public:
protected:
///HttpClient override///
void onResponseHeader(const string &status, const HttpHeader &header) override;
void onResponseHeader(const std::string &status, const HttpHeader &header) override;
void onResponseBody(const char *buf, size_t size) override;
void onResponseCompleted(const SockException &ex) override;
void onResponseCompleted(const toolkit::SockException &ex) override;
protected:
/**
@@ -51,7 +49,7 @@ protected:
virtual void onPacket(const char *data, size_t len);
private:
void emitOnComplete(const SockException &ex);
void emitOnComplete(const toolkit::SockException &ex);
private:
bool _split_ts;

3
src/Http/TsPlayer.cpp
View File

@@ -10,6 +10,9 @@
#include "TsPlayer.h"
using namespace std;
using namespace toolkit;
namespace mediakit {
TsPlayer::TsPlayer(const EventPoller::Ptr &poller) : HttpTSPlayer(poller, true) {}

7
src/Http/TsPlayer.h
View File

@@ -14,18 +14,17 @@
#include "HttpTSPlayer.h"
#include "Player/PlayerBase.h"
using namespace toolkit;
namespace mediakit {
class TsPlayer : public HttpTSPlayer , public PlayerBase {
public:
TsPlayer(const EventPoller::Ptr &poller);
TsPlayer(const toolkit::EventPoller::Ptr &poller);
~TsPlayer() override = default;
/**
* 开始播放
*/
void play(const string &url) override;
void play(const std::string &url) override;
/**
* 停止播放
@@ -34,7 +33,7 @@ public:
protected:
void onResponseBody(const char *buf, size_t size) override;
void onResponseCompleted(const SockException &ex) override;
void onResponseCompleted(const toolkit::SockException &ex) override;
private:
bool _play_result = true;

10
src/Http/TsPlayerImp.h
View File

@@ -14,15 +14,13 @@
#include <unordered_set>
#include "TsPlayer.h"
using namespace toolkit;
namespace mediakit {
class TsPlayerImp : public PlayerImp<TsPlayer, PlayerBase>, private TrackListener {
public:
using Ptr = std::shared_ptr<TsPlayerImp>;
TsPlayerImp(const EventPoller::Ptr &poller = nullptr);
TsPlayerImp(const toolkit::EventPoller::Ptr &poller = nullptr);
~TsPlayerImp() override = default;
private:
@@ -31,9 +29,9 @@ private:
private:
//// PlayerBase override////
void onPlayResult(const SockException &ex) override;
vector<Track::Ptr> getTracks(bool ready = true) const override;
void onShutdown(const SockException &ex) override;
void onPlayResult(const toolkit::SockException &ex) override;
std::vector<Track::Ptr> getTracks(bool ready = true) const override;
void onShutdown(const toolkit::SockException &ex) override;
private:
//// TrackListener override////

3
src/Http/TsplayerImp.cpp
View File

@@ -11,6 +11,9 @@
#include "TsPlayerImp.h"
#include "HlsPlayer.h"
using namespace std;
using namespace toolkit;
namespace mediakit {
TsPlayerImp::TsPlayerImp(const EventPoller::Ptr &poller) : PlayerImp<TsPlayer, PlayerBase>(poller) {}

72
src/Http/WebSocketClient.h
View File

@@ -17,7 +17,6 @@
#include "Network/TcpClient.h"
#include "HttpClientImp.h"
#include "WebSocketSplitter.h"
using namespace toolkit;
namespace mediakit{
@@ -32,8 +31,9 @@ class HttpWsClient;
template <typename ClientType,WebSocketHeader::Type DataType>
class ClientTypeImp : public ClientType {
public:
typedef function<ssize_t (const Buffer::Ptr &buf)> onBeforeSendCB;
friend class HttpWsClient<ClientType,DataType>;
friend class HttpWsClient<ClientType, DataType>;
using onBeforeSendCB = std::function<ssize_t(const toolkit::Buffer::Ptr &buf)>;
template<typename ...ArgsType>
ClientTypeImp(ArgsType &&...args): ClientType(std::forward<ArgsType>(args)...){}
@@ -43,7 +43,7 @@ protected:
/**
* 发送前拦截并打包为websocket协议
*/
ssize_t send(Buffer::Ptr buf) override{
ssize_t send(toolkit::Buffer::Ptr buf) override{
if(_beforeSendCB){
return _beforeSendCB(buf);
}
@@ -70,11 +70,11 @@ private:
template <typename ClientType,WebSocketHeader::Type DataType = WebSocketHeader::TEXT>
class HttpWsClient : public HttpClientImp , public WebSocketSplitter{
public:
typedef shared_ptr<HttpWsClient> Ptr;
typedef std::shared_ptr<HttpWsClient> Ptr;
HttpWsClient(const std::shared_ptr<ClientTypeImp<ClientType, DataType> > &delegate) : _weak_delegate(delegate),
_delegate(*delegate) {
_Sec_WebSocket_Key = encodeBase64(makeRandStr(16, false));
_Sec_WebSocket_Key = encodeBase64(toolkit::makeRandStr(16, false));
setPoller(_delegate.getPoller());
}
~HttpWsClient(){}
@@ -84,10 +84,10 @@ public:
* @param ws_url ws连接url
* @param fTimeOutSec 超时时间
*/
void startWsClient(const string &ws_url, float fTimeOutSec) {
string http_url = ws_url;
replace(http_url, "ws://", "http://");
replace(http_url, "wss://", "https://");
void startWsClient(const std::string &ws_url, float fTimeOutSec) {
std::string http_url = ws_url;
toolkit::replace(http_url, "ws://", "http://");
toolkit::replace(http_url, "wss://", "https://");
setMethod("GET");
addHeader("Upgrade", "websocket");
addHeader("Connection", "Upgrade");
@@ -120,27 +120,27 @@ protected:
* @param status 状态码，譬如:200 OK
* @param headers http头
*/
void onResponseHeader(const string &status,const HttpHeader &headers) override {
void onResponseHeader(const std::string &status, const HttpHeader &headers) override {
if(status == "101"){
auto Sec_WebSocket_Accept = encodeBase64(SHA1::encode_bin(_Sec_WebSocket_Key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"));
auto Sec_WebSocket_Accept = encodeBase64(toolkit::SHA1::encode_bin(_Sec_WebSocket_Key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"));
if(Sec_WebSocket_Accept == const_cast<HttpHeader &>(headers)["Sec-WebSocket-Accept"]){
//success
onWebSocketException(SockException());
onWebSocketException(toolkit::SockException());
//防止ws服务器返回Content-Length
const_cast<HttpHeader &>(headers).erase("Content-Length");
return;
}
shutdown(SockException(Err_shutdown, StrPrinter << "Sec-WebSocket-Accept mismatch"));
shutdown(toolkit::SockException(toolkit::Err_shutdown, StrPrinter << "Sec-WebSocket-Accept mismatch"));
return;
}
shutdown(SockException(Err_shutdown,StrPrinter << "bad http status code:" << status));
shutdown(toolkit::SockException(toolkit::Err_shutdown,StrPrinter << "bad http status code:" << status));
};
/**
* 接收http回复完毕,
*/
void onResponseCompleted(const SockException &ex) override {}
void onResponseCompleted(const toolkit::SockException &ex) override {}
/**
* 接收websocket负载数据
@@ -154,7 +154,7 @@ protected:
//TcpClient override
void onRecv(const Buffer::Ptr &buf) override {
void onRecv(const toolkit::Buffer::Ptr &buf) override {
auto strong_ref = _weak_delegate.lock();;
HttpClientImp::onRecv(buf);
}
@@ -190,7 +190,7 @@ protected:
/**
* tcp连接结果
*/
void onConnect(const SockException &ex) override {
void onConnect(const toolkit::SockException &ex) override {
auto strong_ref = _weak_delegate.lock();;
if (ex) {
//tcp连接失败，直接返回失败
@@ -204,7 +204,7 @@ protected:
/**
* tcp连接断开
*/
void onErr(const SockException &ex) override {
void onErr(const toolkit::SockException &ex) override {
auto strong_ref = _weak_delegate.lock();;
//tcp断开或者shutdown导致的断开
onWebSocketException(ex);
@@ -245,14 +245,14 @@ protected:
case WebSocketHeader::CLOSE:{
//服务器主动关闭
WebSocketSplitter::encode(header,nullptr);
shutdown(SockException(Err_eof,"websocket server close the connection"));
shutdown(toolkit::SockException(toolkit::Err_eof,"websocket server close the connection"));
break;
}
case WebSocketHeader::PING:{
//心跳包
header._opcode = WebSocketHeader::PONG;
WebSocketSplitter::encode(header,std::make_shared<BufferString>(std::move(_payload_section)));
WebSocketSplitter::encode(header,std::make_shared<toolkit::BufferString>(std::move(_payload_section)));
break;
}
@@ -294,17 +294,17 @@ protected:
* @param ptr 数据指针
* @param len 数据指针长度
*/
void onWebSocketEncodeData(Buffer::Ptr buffer) override{
void onWebSocketEncodeData(toolkit::Buffer::Ptr buffer) override{
HttpClientImp::send(std::move(buffer));
}
private:
void onWebSocketException(const SockException &ex){
void onWebSocketException(const toolkit::SockException &ex){
if(!ex){
//websocket握手成功
//此处截取TcpClient派生类发送的数据并进行websocket协议打包
weak_ptr<HttpWsClient> weakSelf = dynamic_pointer_cast<HttpWsClient>(shared_from_this());
_delegate.setOnBeforeSendCB([weakSelf](const Buffer::Ptr &buf){
std::weak_ptr<HttpWsClient> weakSelf = std::dynamic_pointer_cast<HttpWsClient>(shared_from_this());
_delegate.setOnBeforeSendCB([weakSelf](const toolkit::Buffer::Ptr &buf){
auto strongSelf = weakSelf.lock();
if(strongSelf){
WebSocketHeader header;
@@ -343,12 +343,12 @@ private:
}
private:
string _Sec_WebSocket_Key;
function<void(const char *data, size_t len)> _onRecv;
weak_ptr<ClientTypeImp<ClientType,DataType> > _weak_delegate;
ClientTypeImp<ClientType,DataType> &_delegate;
string _payload_section;
string _payload_cache;
std::string _Sec_WebSocket_Key;
std::function<void(const char *data, size_t len)> _onRecv;
std::weak_ptr<ClientTypeImp<ClientType, DataType>> _weak_delegate;
ClientTypeImp<ClientType, DataType> &_delegate;
std::string _payload_section;
std::string _payload_cache;
};
/**
@@ -378,8 +378,8 @@ public:
* @param timeout_sec 超时时间
* @param local_port 本地监听端口，此处不起作用
*/
void startConnect(const string &host, uint16_t port, float timeout_sec = 3, uint16_t local_port = 0) override {
string ws_url;
void startConnect(const std::string &host, uint16_t port, float timeout_sec = 3, uint16_t local_port = 0) override {
std::string ws_url;
if (useWSS) {
//加密的ws
ws_url = StrPrinter << "wss://" + host << ":" << port << "/";
@@ -390,9 +390,9 @@ public:
startWebSocket(ws_url, timeout_sec);
}
void startWebSocket(const string &ws_url,float fTimeOutSec = 3){
_wsClient = std::make_shared<HttpWsClient<ClientType,DataType> >(static_pointer_cast<WebSocketClient>(this->shared_from_this()));
_wsClient->setOnCreateSocket([this](const EventPoller::Ptr &){
void startWebSocket(const std::string &ws_url, float fTimeOutSec = 3) {
_wsClient = std::make_shared<HttpWsClient<ClientType, DataType> >(std::static_pointer_cast<WebSocketClient>(this->shared_from_this()));
_wsClient->setOnCreateSocket([this](const toolkit::EventPoller::Ptr &){
return this->createSocket();
});
_wsClient->startWsClient(ws_url,fTimeOutSec);

75
src/Http/WebSocketSession.h
View File

@@ -19,7 +19,8 @@
*/
class SendInterceptor{
public:
typedef function<ssize_t (const Buffer::Ptr &buf)> onBeforeSendCB;
using onBeforeSendCB =std::function<ssize_t (const toolkit::Buffer::Ptr &buf)>;
SendInterceptor() = default;
virtual ~SendInterceptor() = default;
virtual void setOnBeforeSendCB(const onBeforeSendCB &cb) = 0;
@@ -34,7 +35,7 @@ class TcpSessionTypeImp : public TcpSessionType, public SendInterceptor{
public:
typedef std::shared_ptr<TcpSessionTypeImp> Ptr;
TcpSessionTypeImp(const Parser &header, const HttpSession &parent, const Socket::Ptr &pSock) :
TcpSessionTypeImp(const mediakit::Parser &header, const mediakit::HttpSession &parent, const toolkit::Socket::Ptr &pSock) :
TcpSessionType(pSock), _identifier(parent.getIdentifier()) {}
~TcpSessionTypeImp() {}
@@ -53,19 +54,19 @@ protected:
* @param buf 需要截取的数据
* @return 数据字节数
*/
ssize_t send(Buffer::Ptr buf) override {
ssize_t send(toolkit::Buffer::Ptr buf) override {
if (_beforeSendCB) {
return _beforeSendCB(buf);
}
return TcpSessionType::send(std::move(buf));
}
string getIdentifier() const override {
std::string getIdentifier() const override {
return _identifier;
}
private:
string _identifier;
std::string _identifier;
onBeforeSendCB _beforeSendCB;
};
@@ -73,7 +74,7 @@ template <typename TcpSessionType>
class TcpSessionCreator {
public:
//返回的TcpSession必须派生于SendInterceptor，可以返回null
TcpSession::Ptr operator()(const Parser &header, const HttpSession &parent, const Socket::Ptr &pSock){
toolkit::TcpSession::Ptr operator()(const mediakit::Parser &header, const mediakit::HttpSession &parent, const toolkit::Socket::Ptr &pSock){
return std::make_shared<TcpSessionTypeImp<TcpSessionType> >(header,parent,pSock);
}
};
@@ -82,14 +83,14 @@ public:
* 通过该模板类可以透明化WebSocket协议，
* 用户只要实现WebSock协议下的具体业务协议，譬如基于WebSocket协议的Rtmp协议等
*/
template<typename Creator, typename HttpSessionType = HttpSession, WebSocketHeader::Type DataType = WebSocketHeader::TEXT>
template<typename Creator, typename HttpSessionType = mediakit::HttpSession, mediakit::WebSocketHeader::Type DataType = mediakit::WebSocketHeader::TEXT>
class WebSocketSessionBase : public HttpSessionType {
public:
WebSocketSessionBase(const Socket::Ptr &pSock) : HttpSessionType(pSock){}
WebSocketSessionBase(const toolkit::Socket::Ptr &pSock) : HttpSessionType(pSock){}
virtual ~WebSocketSessionBase(){}
//收到eof或其他导致脱离TcpServer事件的回调
void onError(const SockException &err) override{
void onError(const toolkit::SockException &err) override{
HttpSessionType::onError(err);
if(_session){
_session->onError(err);
@@ -104,9 +105,9 @@ public:
}
}
void attachServer(const Server &server) override{
void attachServer(const toolkit::Server &server) override{
HttpSessionType::attachServer(server);
_weak_server = const_cast<Server &>(server).shared_from_this();
_weak_server = const_cast<toolkit::Server &>(server).shared_from_this();
}
protected:
@@ -115,7 +116,7 @@ protected:
* @param header http头
* @return true代表允许websocket连接，否则拒绝
*/
bool onWebSocketConnect(const Parser &header) override{
bool onWebSocketConnect(const mediakit::Parser &header) override{
//创建websocket session类
_session = _creator(header, *this,HttpSessionType::getSock());
if(!_session){
@@ -128,16 +129,16 @@ protected:
}
//此处截取数据并进行websocket协议打包
weak_ptr<WebSocketSessionBase> weakSelf = dynamic_pointer_cast<WebSocketSessionBase>(HttpSessionType::shared_from_this());
dynamic_pointer_cast<SendInterceptor>(_session)->setOnBeforeSendCB([weakSelf](const Buffer::Ptr &buf) {
std::weak_ptr<WebSocketSessionBase> weakSelf = std::dynamic_pointer_cast<WebSocketSessionBase>(HttpSessionType::shared_from_this());
std::dynamic_pointer_cast<SendInterceptor>(_session)->setOnBeforeSendCB([weakSelf](const toolkit::Buffer::Ptr &buf) {
auto strongSelf = weakSelf.lock();
if (strongSelf) {
WebSocketHeader header;
mediakit::WebSocketHeader header;
header._fin = true;
header._reserved = 0;
header._opcode = DataType;
header._mask_flag = false;
strongSelf->WebSocketSplitter::encode(header, buf);
strongSelf->HttpSessionType::encode(header, buf);
}
return buf->size();
});
@@ -149,7 +150,7 @@ protected:
/**
* 开始收到一个webSocket数据包
*/
void onWebSocketDecodeHeader(const WebSocketHeader &packet) override{
void onWebSocketDecodeHeader(const mediakit::WebSocketHeader &packet) override{
//新包，原来的包残余数据清空掉
_payload_section.clear();
}
@@ -157,7 +158,7 @@ protected:
/**
* 收到websocket数据包负载
*/
void onWebSocketDecodePayload(const WebSocketHeader &packet,const uint8_t *ptr,size_t len,size_t recved) override {
void onWebSocketDecodePayload(const mediakit::WebSocketHeader &packet,const uint8_t *ptr,size_t len,size_t recved) override {
_payload_section.append((char *)ptr,len);
}
@@ -165,27 +166,27 @@ protected:
* 接收到完整的一个webSocket数据包后回调
* @param header 数据包包头
*/
void onWebSocketDecodeComplete(const WebSocketHeader &header_in) override {
WebSocketHeader& header = const_cast<WebSocketHeader&>(header_in);
void onWebSocketDecodeComplete(const mediakit::WebSocketHeader &header_in) override {
auto header = const_cast<mediakit::WebSocketHeader&>(header_in);
auto flag = header._mask_flag;
header._mask_flag = false;
switch (header._opcode){
case WebSocketHeader::CLOSE:{
case mediakit::WebSocketHeader::CLOSE:{
HttpSessionType::encode(header,nullptr);
HttpSessionType::shutdown(SockException(Err_shutdown, "recv close request from client"));
HttpSessionType::shutdown(toolkit::SockException(toolkit::Err_shutdown, "recv close request from client"));
break;
}
case WebSocketHeader::PING:{
header._opcode = WebSocketHeader::PONG;
HttpSessionType::encode(header,std::make_shared<BufferString>(_payload_section));
case mediakit::WebSocketHeader::PING:{
header._opcode = mediakit::WebSocketHeader::PONG;
HttpSessionType::encode(header,std::make_shared<toolkit::BufferString>(_payload_section));
break;
}
case WebSocketHeader::CONTINUATION:
case WebSocketHeader::TEXT:
case WebSocketHeader::BINARY:{
case mediakit::WebSocketHeader::CONTINUATION:
case mediakit::WebSocketHeader::TEXT:
case mediakit::WebSocketHeader::BINARY:{
if (!header._fin) {
//还有后续分片数据, 我们先缓存数据，所有分片收集完成才一次性输出
_payload_cache.append(std::move(_payload_section));
@@ -199,13 +200,13 @@ protected:
//最后一个包
if (_payload_cache.empty()) {
//这个包是唯一个分片
_session->onRecv(std::make_shared<WebSocketBuffer>(header._opcode, header._fin, std::move(_payload_section)));
_session->onRecv(std::make_shared<mediakit::WebSocketBuffer>(header._opcode, header._fin, std::move(_payload_section)));
break;
}
//这个包由多个分片组成
_payload_cache.append(std::move(_payload_section));
_session->onRecv(std::make_shared<WebSocketBuffer>(header._opcode, header._fin, std::move(_payload_cache)));
_session->onRecv(std::make_shared<mediakit::WebSocketBuffer>(header._opcode, header._fin, std::move(_payload_cache)));
_payload_cache.clear();
break;
}
@@ -219,23 +220,23 @@ protected:
/**
* 发送数据进行websocket协议打包后回调
*/
void onWebSocketEncodeData(Buffer::Ptr buffer) override{
void onWebSocketEncodeData(toolkit::Buffer::Ptr buffer) override{
HttpSessionType::send(std::move(buffer));
}
private:
string _payload_cache;
string _payload_section;
weak_ptr<Server> _weak_server;
TcpSession::Ptr _session;
std::string _payload_cache;
std::string _payload_section;
std::weak_ptr<toolkit::Server> _weak_server;
toolkit::TcpSession::Ptr _session;
Creator _creator;
};
template<typename TcpSessionType,typename HttpSessionType = HttpSession,WebSocketHeader::Type DataType = WebSocketHeader::TEXT>
template<typename TcpSessionType,typename HttpSessionType = mediakit::HttpSession, mediakit::WebSocketHeader::Type DataType = mediakit::WebSocketHeader::TEXT>
class WebSocketSession : public WebSocketSessionBase<TcpSessionCreator<TcpSessionType>,HttpSessionType,DataType>{
public:
WebSocketSession(const Socket::Ptr &pSock) : WebSocketSessionBase<TcpSessionCreator<TcpSessionType>,HttpSessionType,DataType>(pSock){}
WebSocketSession(const toolkit::Socket::Ptr &pSock) : WebSocketSessionBase<TcpSessionCreator<TcpSessionType>,HttpSessionType,DataType>(pSock){}
virtual ~WebSocketSession(){}
};

2
src/Http/WebSocketSplitter.cpp
View File

@@ -17,6 +17,8 @@
#include "Util/logger.h"
#include "Util/util.h"
using namespace std;
using namespace toolkit;
namespace mediakit {

14
src/Http/WebSocketSplitter.h
View File

@@ -16,8 +16,6 @@
#include <vector>
#include <memory>
#include "Network/Buffer.h"
using namespace std;
using namespace toolkit;
//websocket组合包最大不得超过4MB(防止内存爆炸)
#define MAX_WS_PACKET (4 * 1024 * 1024)
@@ -61,17 +59,17 @@ public:
Type _opcode;
bool _mask_flag;
size_t _payload_len;
vector<uint8_t > _mask;
std::vector<uint8_t > _mask;
};
//websocket协议收到的字符串类型缓存，用户协议层获取该数据传输的方式
class WebSocketBuffer : public BufferString {
class WebSocketBuffer : public toolkit::BufferString {
public:
typedef std::shared_ptr<WebSocketBuffer> Ptr;
template<typename ...ARGS>
WebSocketBuffer(WebSocketHeader::Type headType, bool fin, ARGS &&...args)
: BufferString(std::forward<ARGS>(args)...), _fin(fin), _head_type(headType){}
: toolkit::BufferString(std::forward<ARGS>(args)...), _fin(fin), _head_type(headType){}
~WebSocketBuffer() override {}
@@ -103,7 +101,7 @@ public:
* @param header 数据头
* @param buffer 负载数据
*/
void encode(const WebSocketHeader &header,const Buffer::Ptr &buffer);
void encode(const WebSocketHeader &header,const toolkit::Buffer::Ptr &buffer);
protected:
/**
@@ -132,7 +130,7 @@ protected:
* @param ptr 数据指针
* @param len 数据指针长度
*/
virtual void onWebSocketEncodeData(Buffer::Ptr buffer){};
virtual void onWebSocketEncodeData(toolkit::Buffer::Ptr buffer){};
private:
void onPayloadData(uint8_t *data, size_t len);
@@ -141,7 +139,7 @@ private:
bool _got_header = false;
int _mask_offset = 0;
size_t _payload_offset = 0;
string _remain_data;
std::string _remain_data;
};
} /* namespace mediakit */

2
src/Http/strCoding.cpp
View File

@@ -15,6 +15,8 @@
#include <windows.h>
#endif//defined(_WIN32)
using namespace std;
namespace mediakit {
//////////////////////////通用///////////////////////

10
src/Http/strCoding.h
View File

@@ -14,17 +14,15 @@
#include <iostream>
#include <string>
using namespace std;
namespace mediakit {
class strCoding {
public:
static string UrlEncode(const string &str); //urlutf8 编码
static string UrlDecode(const string &str); //urlutf8解码
static std::string UrlEncode(const std::string &str); //urlutf8 编码
static std::string UrlDecode(const std::string &str); //urlutf8解码
#if defined(_WIN32)
static string UTF8ToGB2312(const string &str);//utf_8转为gb2312
static string GB2312ToUTF8(const string &str); //gb2312 转utf_8
static std::string UTF8ToGB2312(const std::string &str);//utf_8转为gb2312
static std::string GB2312ToUTF8(const std::string &str); //gb2312 转utf_8
#endif//defined(_WIN32)
private:
strCoding(void);