amass/ZLMediaKit
1
0
Fork 0
mirror of https://github.com/ZLMediaKit/ZLMediaKit.git synced 2024-11-27 05:38:31 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
0e0608dc27
ZLMediaKit/src/Http/HttpFileManager.cpp

630 lines
24 KiB
C++
Raw Normal View History

整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
/*
整理授权协议
2020-04-04 20:30:09 +08:00
* Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved.
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
*
全面整理代码，去除编译警告
2021-01-17 18:31:50 +08:00
* This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit).
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
*
整理授权协议
2020-04-04 20:30:09 +08:00
* Use of this source code is governed by MIT license that can be found in the
* LICENSE file in the root of the source tree. All contributing project authors
* may be found in the AUTHORS file in the root of the source tree.
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
*/
#include <sys/stat.h>
#if !defined(_WIN32)
#include <dirent.h>
#endif //!defined(_WIN32)
#include <iomanip>
#include "HttpFileManager.h"
#include "Util/File.h"
http回复根据状态码自动生成status message: #602
2021-01-02 21:24:06 +08:00
#include "HttpConst.h"
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
#include "HttpSession.h"
初步添加HlsMediaSource
2019-12-28 18:50:56 +08:00
#include "Record/HlsMediaSource.h"
添加http文件服务可挂载物理目录，新增ENABLE_API_STATIC_LIB sa
2021-08-25 14:30:31 +08:00
#include "Common/Parser.h"
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
namespace mediakit {
1、hls cookie改成60秒有效期并且访问时刷新cookie 2、去除keep-alive下最大请求次数限制
2019-11-30 14:29:44 +08:00
// hls的播放cookie缓存时间默认60秒，
// 每次访问一次该cookie，那么将重新刷新cookie有效期
// 假如播放器在60秒内都未访问该cookie，那么将重新触发hls播放鉴权
static int kHlsCookieSecond = 60;
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
static const string kCookieName = "ZL_COOKIE";
1、hls cookie改成60秒有效期并且访问时刷新cookie 2、去除keep-alive下最大请求次数限制
2019-11-30 14:29:44 +08:00
static const string kHlsSuffix = "/hls.m3u8";
简化hls cookie相关逻辑
2020-01-02 17:46:20 +08:00
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
class HttpCookieAttachment {
简化hls cookie相关逻辑
2020-01-02 17:46:20 +08:00
public:
HttpCookieAttachment() {};
~HttpCookieAttachment() {};
public:
//cookie生效作用域，本cookie只对该目录下的文件生效
string _path;
//上次鉴权失败信息,为空则上次鉴权成功
string _err_msg;
//本cookie是否为hls直播的
bool _is_hls = false;
//hls直播时的其他一些信息，主要用于播放器个数计数以及流量计数
HlsCookieData::Ptr _hls_data;
//如果是hls直播，那么判断该cookie是否使用过MediaSource::findAsync查找过
//如果程序未正常退出，会残余上次的hls文件，所以判断hls直播是否存在的关键不是文件存在与否
//而是应该判断HlsMediaSource是否已注册，但是这样会每次获取m3u8文件时都会用MediaSource::findAsync判断一次
//会导致程序性能低下，所以我们应该在cookie声明周期的第一次判断HlsMediaSource是否已经注册，后续通过文件存在与否判断
bool _have_find_media_source = false;
};
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
完善http服务器mime类别
2020-01-02 18:24:11 +08:00
const string &HttpFileManager::getContentType(const char *name) {
http回复根据状态码自动生成status message: #602
2021-01-02 21:24:06 +08:00
return getHttpContentType(name);
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
}
static string searchIndexFile(const string &dir){
DIR *pDir;
dirent *pDirent;
if ((pDir = opendir(dir.data())) == NULL) {
return "";
}
set<string> setFile;
while ((pDirent = readdir(pDir)) != NULL) {
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
static set<const char *, StrCaseCompare> indexSet = {"index.html", "index.htm", "index"};
if (indexSet.find(pDirent->d_name) != indexSet.end()) {
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
string ret = pDirent->d_name;
closedir(pDir);
return ret;
}
}
closedir(pDir);
return "";
}
static bool makeFolderMenu(const string &httpPath, const string &strFullPath, string &strRet) {
新增是否开启浏览http目录的配置选项:#367
2020-06-30 09:16:02 +08:00
GET_CONFIG(bool, dirMenu, Http::kDirMenu);
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
if (!dirMenu) {
新增是否开启浏览http目录的配置选项:#367
2020-06-30 09:16:02 +08:00
//不允许浏览文件夹
return false;
}
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
string strPathPrefix(strFullPath);
合并并完善http虚拟目录相关代码
2021-08-26 19:36:38 +08:00
//url后缀有没有'/'访问文件夹，处理逻辑不一致
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
string last_dir_name;
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
if (strPathPrefix.back() == '/') {
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
strPathPrefix.pop_back();
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
} else {
last_dir_name = split(strPathPrefix, "/").back();
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
}
if (!File::is_dir(strPathPrefix.data())) {
return false;
}
stringstream ss;
合并并完善http虚拟目录相关代码
2021-08-26 19:36:38 +08:00
ss << "<html>\r\n"
"<head>\r\n"
"<title>文件索引</title>\r\n"
"</head>\r\n"
"<body>\r\n"
"<h1>文件索引:";
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
ss << httpPath;
ss << "</h1>\r\n";
if (httpPath != "/") {
ss << "<li><a href=\"";
ss << "/";
ss << "\">";
ss << "根目录";
ss << "</a></li>\r\n";
ss << "<li><a href=\"";
合并并完善http虚拟目录相关代码
2021-08-26 19:36:38 +08:00
if (!last_dir_name.empty()) {
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
ss << "./";
合并并完善http虚拟目录相关代码
2021-08-26 19:36:38 +08:00
} else {
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
ss << "../";
}
ss << "\">";
ss << "上级目录";
ss << "</a></li>\r\n";
}
DIR *pDir;
dirent *pDirent;
if ((pDir = opendir(strPathPrefix.data())) == NULL) {
return false;
}
合并并完善http虚拟目录相关代码
2021-08-26 19:36:38 +08:00
multimap<string/*url name*/, std::pair<string/*note name*/, string/*file path*/> > file_map;
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
while ((pDirent = readdir(pDir)) != NULL) {
if (File::is_special_dir(pDirent->d_name)) {
continue;
}
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
if (pDirent->d_name[0] == '.') {
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
continue;
}
合并并完善http虚拟目录相关代码
2021-08-26 19:36:38 +08:00
file_map.emplace(pDirent->d_name, std::make_pair(pDirent->d_name, strPathPrefix + "/" + pDirent->d_name));
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
}
添加http文件服务可挂载物理目录，新增ENABLE_API_STATIC_LIB sa
2021-08-25 14:30:31 +08:00
//如果是root目录，添加虚拟目录
if (httpPath == "/") {
优化解析复杂数据结构配置项时的性能
2021-08-27 11:05:26 +08:00
GET_CONFIG_FUNC(StrCaseMap, virtualPathMap, Http::kVirtualPath, [](const string &str) {
return Parser::parseArgs(str, ";", ",");
});
for (auto &pr : virtualPathMap) {
合并并完善http虚拟目录相关代码
2021-08-26 19:36:38 +08:00
file_map.emplace(pr.first, std::make_pair(string("虚拟目录:") + pr.first, File::absolutePath("", pr.second)));
添加http文件服务可挂载物理目录，新增ENABLE_API_STATIC_LIB sa
2021-08-25 14:30:31 +08:00
}
}
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
int i = 0;
合并并完善http虚拟目录相关代码
2021-08-26 19:36:38 +08:00
for (auto &pr :file_map) {
auto &strAbsolutePath = pr.second.second;
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
bool isDir = File::is_dir(strAbsolutePath.data());
ss << "<li><span>" << i++ << "</span>\t";
ss << "<a href=\"";
合并并完善http虚拟目录相关代码
2021-08-26 19:36:38 +08:00
//路径链接地址
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
if (!last_dir_name.empty()) {
合并并完善http虚拟目录相关代码
2021-08-26 19:36:38 +08:00
ss << last_dir_name << "/" << pr.first;
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
} else {
合并并完善http虚拟目录相关代码
2021-08-26 19:36:38 +08:00
ss << pr.first;
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
}
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
if (isDir) {
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
ss << "/";
}
ss << "\">";
合并并完善http虚拟目录相关代码
2021-08-26 19:36:38 +08:00
//路径名称
ss << pr.second.first;
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
if (isDir) {
ss << "/</a></li>\r\n";
continue;
}
//是文件
struct stat fileData;
if (0 == stat(strAbsolutePath.data(), &fileData)) {
auto &fileSize = fileData.st_size;
if (fileSize < 1024) {
ss << " (" << fileData.st_size << "B)" << endl;
} else if (fileSize < 1024 * 1024) {
ss << fixed << setprecision(2) << " (" << fileData.st_size / 1024.0 << "KB)";
} else if (fileSize < 1024 * 1024 * 1024) {
ss << fixed << setprecision(2) << " (" << fileData.st_size / 1024 / 1024.0 << "MB)";
} else {
ss << fixed << setprecision(2) << " (" << fileData.st_size / 1024 / 1024 / 1024.0 << "GB)";
}
}
ss << "</a></li>\r\n";
}
closedir(pDir);
ss << "<ul>\r\n";
ss << "</ul>\r\n</body></html>";
ss.str().swap(strRet);
return true;
}
//拦截hls的播放请求
实现hls按需拉流
2019-12-29 11:52:02 +08:00
static bool emitHlsPlayed(const Parser &parser, const MediaInfo &mediaInfo, const HttpSession::HttpAccessPathInvoker &invoker,TcpSession &sender){
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
//访问的hls.m3u8结尾，我们转换成kBroadcastMediaPlayed事件
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
Broadcast::AuthInvoker auth_invoker = [invoker](const string &err) {
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
//cookie有效期为kHlsCookieSecond
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
invoker(err, "", kHlsCookieSecond);
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
};
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
bool flag = NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastMediaPlayed, mediaInfo, auth_invoker, static_cast<SockInfo &>(sender));
if (!flag) {
修复hls播放鉴权相关bug
2020-09-12 19:14:35 +08:00
//未开启鉴权，那么允许播放
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
auth_invoker("");
修复hls播放鉴权相关bug
2020-09-12 19:14:35 +08:00
}
return flag;
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
}
统一事件参数类型
2020-04-23 22:04:59 +08:00
class SockInfoImp : public SockInfo{
public:
typedef std::shared_ptr<SockInfoImp> Ptr;
SockInfoImp() = default;
~SockInfoImp() override = default;
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
string get_local_ip() override {
统一事件参数类型
2020-04-23 22:04:59 +08:00
return _local_ip;
}
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
uint16_t get_local_port() override {
统一事件参数类型
2020-04-23 22:04:59 +08:00
return _local_port;
}
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
string get_peer_ip() override {
统一事件参数类型
2020-04-23 22:04:59 +08:00
return _peer_ip;
}
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
uint16_t get_peer_port() override {
统一事件参数类型
2020-04-23 22:04:59 +08:00
return _peer_port;
}
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
string getIdentifier() const override {
统一事件参数类型
2020-04-23 22:04:59 +08:00
return _identifier;
}
string _local_ip;
string _peer_ip;
string _identifier;
uint16_t _local_port;
uint16_t _peer_port;
};
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
/**
* 判断http客户端是否有权限访问文件的逻辑步骤
* 1、根据http请求头查找cookie，找到进入步骤3
* 2、根据http url参数查找cookie，如果还是未找到cookie则进入步骤5
* 3、cookie标记是否有权限访问文件，如果有权限，直接返回文件
* 4、cookie中记录的url参数是否跟本次url参数一致，如果一致直接返回客户端错误码
* 5、触发kBroadcastHttpAccess事件
*/
static void canAccessPath(TcpSession &sender, const Parser &parser, const MediaInfo &mediaInfo, bool is_dir,
const function<void(const string &errMsg, const HttpServerCookie::Ptr &cookie)> &callback) {
//获取用户唯一id
auto uid = parser.Params();
auto path = parser.Url();
//先根据http头中的cookie字段获取cookie
整理解析器
2020-04-20 18:13:45 +08:00
HttpServerCookie::Ptr cookie = HttpCookieManager::Instance().getCookie(kCookieName, parser.getHeader());
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
//如果不是从http头中找到的cookie,我们让http客户端设置下cookie
bool cookie_from_header = true;
if (!cookie && !uid.empty()) {
//客户端请求中无cookie,再根据该用户的用户id获取cookie
cookie = HttpCookieManager::Instance().getCookieByUid(kCookieName, uid);
cookie_from_header = false;
}
if (cookie) {
//找到了cookie，对cookie上锁先
auto lck = cookie->getLock();
简化hls cookie相关逻辑
2020-01-02 17:46:20 +08:00
auto attachment = (*cookie)[kCookieName].get<HttpCookieAttachment>();
if (path.find(attachment._path) == 0) {
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
//上次cookie是限定本目录
简化hls cookie相关逻辑
2020-01-02 17:46:20 +08:00
if (attachment._err_msg.empty()) {
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
//上次鉴权成功
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
if (attachment._is_hls) {
解决hls中断恢复时播放器计数不准确的问题
2019-12-29 17:55:02 +08:00
//如果播放的是hls，那么刷新hls的cookie(获取ts文件也会刷新)
1、hls cookie改成60秒有效期并且访问时刷新cookie 2、去除keep-alive下最大请求次数限制
2019-11-30 14:29:44 +08:00
cookie->updateTime();
cookie_from_header = false;
}
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
callback("", cookie_from_header ? nullptr : cookie);
return;
}
//上次鉴权失败，但是如果url参数发生变更，那么也重新鉴权下
if (parser.Params().empty() || parser.Params() == cookie->getUid()) {
//url参数未变，或者本来就没有url参数，那么判断本次请求为重复请求，无访问权限
简化hls cookie相关逻辑
2020-01-02 17:46:20 +08:00
callback(attachment._err_msg, cookie_from_header ? nullptr : cookie);
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
return;
}
}
//如果url参数变了或者不是限定本目录，那么旧cookie失效，重新鉴权
HttpCookieManager::Instance().delCookie(cookie);
}
实现hls按需拉流
2019-12-29 11:52:02 +08:00
bool is_hls = mediaInfo._schema == HLS_SCHEMA;
统一事件参数类型
2020-04-23 22:04:59 +08:00
SockInfoImp::Ptr info = std::make_shared<SockInfoImp>();
info->_identifier = sender.getIdentifier();
info->_peer_ip = sender.get_peer_ip();
info->_peer_port = sender.get_peer_port();
info->_local_ip = sender.get_local_ip();
info->_local_port = sender.get_local_port();
流量汇报事件添加客户端ip和端口参数
2020-02-13 11:33:59 +08:00
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
//该用户从来未获取过cookie，这个时候我们广播是否允许该用户访问该http目录
统一事件参数类型
2020-04-23 22:04:59 +08:00
HttpSession::HttpAccessPathInvoker accessPathInvoker = [callback, uid, path, is_dir, is_hls, mediaInfo, info]
解决hls中断恢复时播放器计数不准确的问题
2019-12-29 17:55:02 +08:00
(const string &errMsg, const string &cookie_path_in, int cookieLifeSecond) {
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
HttpServerCookie::Ptr cookie;
if (cookieLifeSecond) {
//本次鉴权设置了有效期，我们把鉴权结果缓存在cookie中
string cookie_path = cookie_path_in;
if (cookie_path.empty()) {
//如果未设置鉴权目录，那么我们采用当前目录
cookie_path = is_dir ? path : path.substr(0, path.rfind("/") + 1);
}
cookie = HttpCookieManager::Instance().addCookie(kCookieName, uid, cookieLifeSecond);
//对cookie上锁
auto lck = cookie->getLock();
简化hls cookie相关逻辑
2020-01-02 17:46:20 +08:00
HttpCookieAttachment attachment;
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
//记录用户能访问的路径
简化hls cookie相关逻辑
2020-01-02 17:46:20 +08:00
attachment._path = cookie_path;
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
//记录能否访问
简化hls cookie相关逻辑
2020-01-02 17:46:20 +08:00
attachment._err_msg = errMsg;
1、hls cookie改成60秒有效期并且访问时刷新cookie 2、去除keep-alive下最大请求次数限制
2019-11-30 14:29:44 +08:00
//记录访问的是否为hls
简化hls cookie相关逻辑
2020-01-02 17:46:20 +08:00
attachment._is_hls = is_hls;
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
if (is_hls) {
初步实现hls播放器个数计数
2019-12-28 16:48:11 +08:00
//hls相关信息
统一事件参数类型
2020-04-23 22:04:59 +08:00
attachment._hls_data = std::make_shared<HlsCookieData>(mediaInfo, info);
实现hls的流量汇报事件
2019-12-29 15:38:29 +08:00
//hls未查找MediaSource
简化hls cookie相关逻辑
2020-01-02 17:46:20 +08:00
attachment._have_find_media_source = false;
初步实现hls播放器个数计数
2019-12-28 16:48:11 +08:00
}
简化hls cookie相关逻辑
2020-01-02 17:46:20 +08:00
(*cookie)[kCookieName].set<HttpCookieAttachment>(std::move(attachment));
初步实现hls播放器个数计数
2019-12-28 16:48:11 +08:00
callback(errMsg, cookie);
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
} else {
初步实现hls播放器个数计数
2019-12-28 16:48:11 +08:00
callback(errMsg, nullptr);
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
}
};
修复hls播放鉴权相关bug
2020-09-12 19:14:35 +08:00
if (is_hls) {
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
//是hls的播放鉴权,拦截之
修复hls播放鉴权相关bug
2020-09-12 19:14:35 +08:00
emitHlsPlayed(parser, mediaInfo, accessPathInvoker, sender);
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
return;
}
//事件未被拦截，则认为是http下载请求
事件广播触发者改成SockInfo对象
2020-04-23 21:38:44 +08:00
bool flag = NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastHttpAccess, parser, path, is_dir, accessPathInvoker, static_cast<SockInfo &>(sender));
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
if (!flag) {
//此事件无人监听，我们默认都有权限访问
callback("", nullptr);
}
}
/**
* 发送404 Not Found
*/
static void sendNotFound(const HttpFileManager::invoker &cb) {
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
GET_CONFIG(string, notFound, Http::kNotFound);
http回复根据状态码自动生成status message: #602
2021-01-02 21:24:06 +08:00
cb(404, "text/html", StrCaseMap(), std::make_shared<HttpStringBody>(notFound));
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
}
/**
* 拼接文件路径
*/
static string pathCat(const string &a, const string &b){
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
if (a.back() == '/') {
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
return a + b;
}
return a + '/' + b;
}
/**
* 访问文件
* @param sender 事件触发者
* @param parser http请求
* @param mediaInfo http url信息
* @param strFile 文件绝对路径
* @param cb 回调对象
*/
static void accessFile(TcpSession &sender, const Parser &parser, const MediaInfo &mediaInfo, const string &strFile, const HttpFileManager::invoker &cb) {
复用代码
2020-09-26 09:39:38 +08:00
bool is_hls = end_with(strFile, kHlsSuffix);
优化hls直播性能
2019-12-29 14:00:20 +08:00
bool file_exist = File::is_file(strFile.data());
if (!is_hls && !file_exist) {
实现hls按需拉流
2019-12-29 11:52:02 +08:00
//文件不存在且不是hls,那么直接返回404
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
sendNotFound(cb);
return;
}
实现hls按需拉流
2019-12-29 11:52:02 +08:00
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
if (is_hls) {
实现hls按需拉流
2019-12-29 11:52:02 +08:00
//hls，那么移除掉后缀获取真实的stream_id并且修改协议为HLS
const_cast<string &>(mediaInfo._schema) = HLS_SCHEMA;
replace(const_cast<string &>(mediaInfo._streamid), kHlsSuffix, "");
}
weak_ptr<TcpSession> weakSession = sender.shared_from_this();
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
//判断是否有权限访问该文件
优化hls直播性能
2019-12-29 14:00:20 +08:00
canAccessPath(sender, parser, mediaInfo, false, [cb, strFile, parser, is_hls, mediaInfo, weakSession , file_exist](const string &errMsg, const HttpServerCookie::Ptr &cookie) {
实现hls的流量汇报事件
2019-12-29 15:38:29 +08:00
auto strongSession = weakSession.lock();
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
if (!strongSession) {
实现hls的流量汇报事件
2019-12-29 15:38:29 +08:00
//http客户端已经断开，不需要回复
return;
}
if (!errMsg.empty()) {
//文件鉴权失败
StrCaseMap headerOut;
if (cookie) {
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
auto lck = cookie->getLock();
简化hls cookie相关逻辑
2020-01-02 17:46:20 +08:00
headerOut["Set-Cookie"] = cookie->getCookie((*cookie)[kCookieName].get<HttpCookieAttachment>()._path);
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
}
http回复根据状态码自动生成status message: #602
2021-01-02 21:24:06 +08:00
cb(401, "text/html", headerOut, std::make_shared<HttpStringBody>(errMsg));
实现hls的流量汇报事件
2019-12-29 15:38:29 +08:00
return;
}
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
解决hls中断恢复时播放器计数不准确的问题
2019-12-29 17:55:02 +08:00
auto response_file = [file_exist](const HttpServerCookie::Ptr &cookie, const HttpFileManager::invoker &cb, const string &strFile, const Parser &parser) {
实现hls的流量汇报事件
2019-12-29 15:38:29 +08:00
StrCaseMap httpHeader;
if (cookie) {
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
auto lck = cookie->getLock();
简化hls cookie相关逻辑
2020-01-02 17:46:20 +08:00
httpHeader["Set-Cookie"] = cookie->getCookie((*cookie)[kCookieName].get<HttpCookieAttachment>()._path);
实现hls的流量汇报事件
2019-12-29 15:38:29 +08:00
}
http回复根据状态码自动生成status message: #602
2021-01-02 21:24:06 +08:00
HttpSession::HttpResponseInvoker invoker = [&](int code, const StrCaseMap &headerOut, const HttpBody::Ptr &body) {
解决hls中断恢复时播放器计数不准确的问题
2019-12-29 17:55:02 +08:00
if (cookie && file_exist) {
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
auto lck = cookie->getLock();
简化hls cookie相关逻辑
2020-01-02 17:46:20 +08:00
auto is_hls = (*cookie)[kCookieName].get<HttpCookieAttachment>()._is_hls;
实现hls的流量汇报事件
2019-12-29 15:38:29 +08:00
if (is_hls) {
简化hls cookie相关逻辑
2020-01-02 17:46:20 +08:00
(*cookie)[kCookieName].get<HttpCookieAttachment>()._hls_data->addByteUsage(body->remainSize());
实现hls按需拉流
2019-12-29 11:52:02 +08:00
}
实现hls的流量汇报事件
2019-12-29 15:38:29 +08:00
}
http回复根据状态码自动生成status message: #602
2021-01-02 21:24:06 +08:00
cb(code, HttpFileManager::getContentType(strFile.data()), headerOut, body);
实现hls按需拉流
2019-12-29 11:52:02 +08:00
};
整理解析器
2020-04-20 18:13:45 +08:00
invoker.responseFile(parser.getHeader(), httpHeader, strFile);
实现hls的流量汇报事件
2019-12-29 15:38:29 +08:00
};
实现hls按需拉流
2019-12-29 11:52:02 +08:00
实现hls的流量汇报事件
2019-12-29 15:38:29 +08:00
if (!is_hls) {
//不是hls,直接回复文件或404
response_file(cookie, cb, strFile, parser);
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
return;
}
//是hls直播，判断HLS直播流是否已经注册
bool have_find_media_src = false;
if (cookie) {
auto lck = cookie->getLock();
have_find_media_src = (*cookie)[kCookieName].get<HttpCookieAttachment>()._have_find_media_source;
if (!have_find_media_src) {
(*cookie)[kCookieName].get<HttpCookieAttachment>()._have_find_media_source = true;
初步实现hls播放器个数计数
2019-12-28 16:48:11 +08:00
}
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
}
if (have_find_media_src) {
//之前该cookie已经通过MediaSource::findAsync查找过了，所以现在只以文件系统查找结果为准
response_file(cookie, cb, strFile, parser);
return;
}
//hls文件不存在，我们等待其生成并延后回复
MediaSource::findAsync(mediaInfo, strongSession, [response_file, cookie, cb, strFile, parser](const MediaSource::Ptr &src) {
if (cookie) {
auto lck = cookie->getLock();
//尝试添加HlsMediaSource的观看人数(HLS是按需生成的，这样可以触发HLS文件的生成)
(*cookie)[kCookieName].get<HttpCookieAttachment>()._hls_data->addByteUsage(0);
}
if (src && File::is_file(strFile.data())) {
//流和m3u8文件都存在，那么直接返回文件
response_file(cookie, cb, strFile, parser);
return;
}
auto hls = dynamic_pointer_cast<HlsMediaSource>(src);
if (!hls) {
//流不存在，那么直接返回文件(相当于纯粹的HLS文件服务器,但是会挂起播放器15秒左右(用于等待HLS流的注册))
实现hls的流量汇报事件
2019-12-29 15:38:29 +08:00
response_file(cookie, cb, strFile, parser);
return;
}
完善按需转协议(包括hls)
2020-09-12 19:20:18 +08:00
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
//流存在，但是m3u8文件不存在，那么等待生成m3u8文件(HLS源注册后，并不会立即生成HLS文件，有人观看才会按需生成HLS文件)
hls->waitForFile([response_file, cookie, cb, strFile, parser]() {
response_file(cookie, cb, strFile, parser);
实现hls的流量汇报事件
2019-12-29 15:38:29 +08:00
});
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
});
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
});
}
添加kBroadcastHttpBeforeAccess事件，拦截http文件下载事件
2019-12-23 12:47:04 +08:00
static string getFilePath(const Parser &parser,const MediaInfo &mediaInfo, TcpSession &sender){
GET_CONFIG(bool, enableVhost, General::kEnableVhost);
优化解析复杂数据结构配置项时的性能
2021-08-27 11:05:26 +08:00
GET_CONFIG(string, rootPath, Http::kRootPath);
GET_CONFIG_FUNC(StrCaseMap, virtualPathMap, Http::kVirtualPath, [](const string &str) {
return Parser::parseArgs(str, ";", ",");
});
string url, path;
auto it = virtualPathMap.find(mediaInfo._app);
if (it != virtualPathMap.end()) {
//访问的是virtualPath
path = it->second;
url = parser.Url().substr(1 + mediaInfo._app.size());
} else {
//访问的是rootPath
合并并完善http虚拟目录相关代码
2021-08-26 19:36:38 +08:00
path = rootPath;
url = parser.Url();
添加http文件服务可挂载物理目录，新增ENABLE_API_STATIC_LIB sa
2021-08-25 14:30:31 +08:00
}
合并并完善http虚拟目录相关代码
2021-08-26 19:36:38 +08:00
auto ret = File::absolutePath(enableVhost ? mediaInfo._vhost + url : url, path);
事件广播触发者改成SockInfo对象
2020-04-23 21:38:44 +08:00
NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastHttpBeforeAccess, parser, ret, static_cast<SockInfo &>(sender));
返回值去除std::move
2020-09-21 14:32:56 +08:00
return ret;
添加kBroadcastHttpBeforeAccess事件，拦截http文件下载事件
2019-12-23 12:47:04 +08:00
}
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
/**
* 访问文件或文件夹
* @param sender 事件触发者
* @param parser http请求
* @param cb 回调对象
*/
void HttpFileManager::onAccessPath(TcpSession &sender, Parser &parser, const HttpFileManager::invoker &cb) {
auto fullUrl = string(HTTP_SCHEMA) + "://" + parser["Host"] + parser.FullUrl();
MediaInfo mediaInfo(fullUrl);
添加kBroadcastHttpBeforeAccess事件，拦截http文件下载事件
2019-12-23 12:47:04 +08:00
auto strFile = getFilePath(parser, mediaInfo, sender);
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
//访问的是文件夹
精简代码
2019-11-30 11:56:40 +08:00
if (File::is_dir(strFile.data())) {
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
auto indexFile = searchIndexFile(strFile);
if (!indexFile.empty()) {
//发现该文件夹下有index文件
strFile = pathCat(strFile, indexFile);
parser.setUrl(pathCat(parser.Url(), indexFile));
accessFile(sender, parser, mediaInfo, strFile, cb);
return;
}
string strMenu;
//生成文件夹菜单索引
if (!makeFolderMenu(parser.Url(), strFile, strMenu)) {
//文件夹不存在
sendNotFound(cb);
return;
}
//判断是否有权限访问该目录
完善代码
2021-03-14 10:29:17 +08:00
canAccessPath(sender, parser, mediaInfo, true, [strMenu, cb](const string &errMsg, const HttpServerCookie::Ptr &cookie) mutable{
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
if (!errMsg.empty()) {
完善代码
2021-03-14 10:29:17 +08:00
strMenu = errMsg;
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
}
StrCaseMap headerOut;
if (cookie) {
简化hls cookie相关逻辑
2020-01-02 17:46:20 +08:00
headerOut["Set-Cookie"] = cookie->getCookie((*cookie)[kCookieName].get<HttpCookieAttachment>()._path);
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
}
http回复根据状态码自动生成status message: #602
2021-01-02 21:24:06 +08:00
cb(errMsg.empty() ? 200 : 401, "text/html", headerOut, std::make_shared<HttpStringBody>(strMenu));
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
});
return;
}
//访问的是文件
accessFile(sender, parser, mediaInfo, strFile, cb);
};
////////////////////////////////////HttpResponseInvokerImp//////////////////////////////////////
优化http调试日志性能
2021-08-12 21:02:07 +08:00
void HttpResponseInvokerImp::operator()(int code, const StrCaseMap &headerOut, const Buffer::Ptr &body) const {
return operator()(code, headerOut, std::make_shared<HttpBufferBody>(body));
}
http回复根据状态码自动生成status message: #602
2021-01-02 21:24:06 +08:00
void HttpResponseInvokerImp::operator()(int code, const StrCaseMap &headerOut, const HttpBody::Ptr &body) const{
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
if (_lambad) {
http回复根据状态码自动生成status message: #602
2021-01-02 21:24:06 +08:00
_lambad(code, headerOut, body);
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
}
}
http回复根据状态码自动生成status message: #602
2021-01-02 21:24:06 +08:00
void HttpResponseInvokerImp::operator()(int code, const StrCaseMap &headerOut, const string &body) const{
this->operator()(code, headerOut, std::make_shared<HttpStringBody>(body));
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
}
HttpResponseInvokerImp::HttpResponseInvokerImp(const HttpResponseInvokerImp::HttpResponseInvokerLambda0 &lambda){
_lambad = lambda;
}
HttpResponseInvokerImp::HttpResponseInvokerImp(const HttpResponseInvokerImp::HttpResponseInvokerLambda1 &lambda){
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
if (!lambda) {
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
_lambad = nullptr;
return;
}
http回复根据状态码自动生成status message: #602
2021-01-02 21:24:06 +08:00
_lambad = [lambda](int code, const StrCaseMap &headerOut, const HttpBody::Ptr &body) {
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
string str;
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
if (body && body->remainSize()) {
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
str = body->readData(body->remainSize())->toString();
}
http回复根据状态码自动生成status message: #602
2021-01-02 21:24:06 +08:00
lambda(code, headerOut, str);
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
};
}
void HttpResponseInvokerImp::responseFile(const StrCaseMap &requestHeader,
const StrCaseMap &responseHeader,
const string &filePath) const {
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
StrCaseMap &httpHeader = const_cast<StrCaseMap &>(responseHeader);
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
std::shared_ptr<FILE> fp(fopen(filePath.data(), "rb"), [](FILE *fp) {
if (fp) {
fclose(fp);
}
});
if (!fp) {
//打开文件失败
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
GET_CONFIG(string, notFound, Http::kNotFound);
GET_CONFIG(string, charSet, Http::kCharSet);
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
auto strContentType = StrPrinter << "text/html; charset=" << charSet << endl;
httpHeader["Content-Type"] = strContentType;
http回复根据状态码自动生成status message: #602
2021-01-02 21:24:06 +08:00
(*this)(404, httpHeader, notFound);
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
return;
}
auto &strRange = const_cast<StrCaseMap &>(requestHeader)["Range"];
全面整理代码，去除编译警告
2021-01-17 18:31:50 +08:00
size_t iRangeStart = 0;
size_t iRangeEnd = 0;
size_t fileSize = HttpMultiFormBody::fileSize(fp.get());
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
修复编译警告
2021-01-02 21:58:14 +08:00
int code;
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
if (strRange.size() == 0) {
//全部下载
http回复根据状态码自动生成status message: #602
2021-01-02 21:24:06 +08:00
code = 200;
优化HLS直播相关代码
2020-09-20 10:13:15 +08:00
iRangeEnd = fileSize - 1;
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
} else {
//分节下载
http回复根据状态码自动生成status message: #602
2021-01-02 21:24:06 +08:00
code = 206;
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
iRangeStart = atoll(FindField(strRange.data(), "bytes=", "-").data());
修复http文件服务器相关bug
2021-05-22 09:28:19 +08:00
iRangeEnd = atoll(FindField(strRange.data(), "-", nullptr).data());
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
if (iRangeEnd == 0) {
iRangeEnd = fileSize - 1;
}
//分节下载返回Content-Range头
httpHeader.emplace("Content-Range", StrPrinter << "bytes " << iRangeStart << "-" << iRangeEnd << "/" << fileSize << endl);
}
//回复文件
HttpBody::Ptr fileBody = std::make_shared<HttpFileBody>(fp, iRangeStart, iRangeEnd - iRangeStart + 1);
http回复根据状态码自动生成status message: #602
2021-01-02 21:24:06 +08:00
(*this)(code, httpHeader, fileBody);
整理http文件服务器相关代码
2019-11-30 11:38:00 +08:00
}
HttpResponseInvokerImp::operator bool(){
return _lambad.operator bool();
}
}//namespace mediakit
Reference in New Issue Copy Permalink