ZLMediaKit/src/Http/HttpFileManager.cpp

/*
 * Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved.
 *
 * This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit).
 *
 * 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.
 */

#include <sys/stat.h>
#if !defined(_WIN32)
#include <dirent.h>
#endif //!defined(_WIN32)
#include <iomanip>
#include "HttpFileManager.h"
#include "Util/File.h"
#include "HttpConst.h"
#include "HttpSession.h"
#include "Record/HlsMediaSource.h"
#include "Common/Parser.h"

using namespace std;
using namespace toolkit;

namespace mediakit {

// hls的播放cookie缓存时间默认60秒，
// 每次访问一次该cookie，那么将重新刷新cookie有效期
// 假如播放器在60秒内都未访问该cookie，那么将重新触发hls播放鉴权
static int kHlsCookieSecond = 60;
static const string kCookieName = "ZL_COOKIE";
static const string kHlsSuffix = "/hls.m3u8";

class 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;
};

const string &HttpFileManager::getContentType(const char *name) {
    return getHttpContentType(name);
}

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) {
        static set<const char *, StrCaseCompare> indexSet = {"index.html", "index.htm", "index"};
        if (indexSet.find(pDirent->d_name) != indexSet.end()) {
            string ret = pDirent->d_name;
            closedir(pDir);
            return ret;
        }
    }
    closedir(pDir);
    return "";
}

static bool makeFolderMenu(const string &httpPath, const string &strFullPath, string &strRet) {
    GET_CONFIG(bool, dirMenu, Http::kDirMenu);
    if (!dirMenu) {
        //不允许浏览文件夹
        return false;
    }
    string strPathPrefix(strFullPath);
    //url后缀有没有'/'访问文件夹，处理逻辑不一致
    string last_dir_name;
    if (strPathPrefix.back() == '/') {
        strPathPrefix.pop_back();
    } else {
        last_dir_name = split(strPathPrefix, "/").back();
    }

    if (!File::is_dir(strPathPrefix.data())) {
        return false;
    }
    stringstream ss;
    ss << "<html>\r\n"
          "<head>\r\n"
          "<title>文件索引</title>\r\n"
          "</head>\r\n"
          "<body>\r\n"
          "<h1>文件索引:";

    ss << httpPath;
    ss << "</h1>\r\n";
    if (httpPath != "/") {
        ss << "<li><a href=\"";
        ss << "/";
        ss << "\">";
        ss << "根目录";
        ss << "</a></li>\r\n";

        ss << "<li><a href=\"";
        if (!last_dir_name.empty()) {
            ss << "./";
        } else {
            ss << "../";
        }
        ss << "\">";
        ss << "上级目录";
        ss << "</a></li>\r\n";
    }

    DIR *pDir;
    dirent *pDirent;
    if ((pDir = opendir(strPathPrefix.data())) == NULL) {
        return false;
    }
    multimap<string/*url name*/, std::pair<string/*note name*/, string/*file path*/> > file_map;
    while ((pDirent = readdir(pDir)) != NULL) {
        if (File::is_special_dir(pDirent->d_name)) {
            continue;
        }
        if (pDirent->d_name[0] == '.') {
            continue;
        }
        file_map.emplace(pDirent->d_name, std::make_pair(pDirent->d_name, strPathPrefix + "/" + pDirent->d_name));
    }
    //如果是root目录，添加虚拟目录
    if (httpPath == "/") {
        GET_CONFIG_FUNC(StrCaseMap, virtualPathMap, Http::kVirtualPath, [](const string &str) {
            return Parser::parseArgs(str, ";", ",");
        });
        for (auto &pr : virtualPathMap) {
            file_map.emplace(pr.first, std::make_pair(string("虚拟目录:") + pr.first, File::absolutePath("", pr.second)));
        }
    }
    int i = 0;
    for (auto &pr :file_map) {
        auto &strAbsolutePath = pr.second.second;
        bool isDir = File::is_dir(strAbsolutePath.data());
        ss << "<li><span>" << i++ << "</span>\t";
        ss << "<a href=\"";
        //路径链接地址
        if (!last_dir_name.empty()) {
            ss << last_dir_name << "/" << pr.first;
        } else {
            ss << pr.first;
        }

        if (isDir) {
            ss << "/";
        }
        ss << "\">";
        //路径名称
        ss << pr.second.first;
        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的播放请求
static bool emitHlsPlayed(const Parser &parser, const MediaInfo &mediaInfo, const HttpSession::HttpAccessPathInvoker &invoker,TcpSession &sender){
    //访问的hls.m3u8结尾，我们转换成kBroadcastMediaPlayed事件
    Broadcast::AuthInvoker auth_invoker = [invoker](const string &err) {
        //cookie有效期为kHlsCookieSecond
        invoker(err, "", kHlsCookieSecond);
    };
    bool flag = NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastMediaPlayed, mediaInfo, auth_invoker, static_cast<SockInfo &>(sender));
    if (!flag) {
        //未开启鉴权，那么允许播放
        auth_invoker("");
    }
    return flag;
}

class SockInfoImp : public SockInfo{
public:
    typedef std::shared_ptr<SockInfoImp> Ptr;
    SockInfoImp() = default;
    ~SockInfoImp() override = default;

    string get_local_ip() override {
        return _local_ip;
    }

    uint16_t get_local_port() override {
        return _local_port;
    }

    string get_peer_ip() override {
        return _peer_ip;
    }

    uint16_t get_peer_port() override {
        return _peer_port;
    }

    string getIdentifier() const override {
        return _identifier;
    }

    string _local_ip;
    string _peer_ip;
    string _identifier;
    uint16_t _local_port;
    uint16_t _peer_port;
};

/**
 * 判断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
    HttpServerCookie::Ptr cookie = HttpCookieManager::Instance().getCookie(kCookieName, parser.getHeader());
    //如果不是从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& attach = cookie->getAttach<HttpCookieAttachment>();
        if (path.find(attach._path) == 0) {
            //上次cookie是限定本目录
            if (attach._err_msg.empty()) {
                //上次鉴权成功
                if (attach._is_hls) {
                    //如果播放的是hls，那么刷新hls的cookie(获取ts文件也会刷新)
                    cookie->updateTime();
                    cookie_from_header = false;
                }
                callback("", cookie_from_header ? nullptr : cookie);
                return;
            }
            //上次鉴权失败，但是如果url参数发生变更，那么也重新鉴权下
            if (parser.Params().empty() || parser.Params() == cookie->getUid()) {
                //url参数未变，或者本来就没有url参数，那么判断本次请求为重复请求，无访问权限
                callback(attach._err_msg, cookie_from_header ? nullptr : cookie);
                return;
            }
        }
        //如果url参数变了或者不是限定本目录，那么旧cookie失效，重新鉴权
        HttpCookieManager::Instance().delCookie(cookie);
    }

    bool is_hls = mediaInfo._schema == HLS_SCHEMA;

    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();

    //该用户从来未获取过cookie，这个时候我们广播是否允许该用户访问该http目录
    HttpSession::HttpAccessPathInvoker accessPathInvoker = [callback, uid, path, is_dir, is_hls, mediaInfo, info]
            (const string &err_msg, const string &cookie_path_in, int life_second) {
        HttpServerCookie::Ptr cookie;
        if (life_second) {
            //本次鉴权设置了有效期，我们把鉴权结果缓存在cookie中
            string cookie_path = cookie_path_in;
            if (cookie_path.empty()) {
                //如果未设置鉴权目录，那么我们采用当前目录
                cookie_path = is_dir ? path : path.substr(0, path.rfind("/") + 1);
            }

            auto attach = std::make_shared<HttpCookieAttachment>();
            //记录用户能访问的路径
            attach->_path = cookie_path;
            //记录能否访问
            attach->_err_msg = err_msg;
            //记录访问的是否为hls
            attach->_is_hls = is_hls;
            if (is_hls) {
                // hls相关信息
                attach->_hls_data = std::make_shared<HlsCookieData>(mediaInfo, info);
                // hls未查找MediaSource
                attach->_have_find_media_source = false;
            }
            callback(err_msg, HttpCookieManager::Instance().addCookie(kCookieName, uid, life_second, attach));
        } else {
            callback(err_msg, nullptr);
        }
    };

    if (is_hls) {
        //是hls的播放鉴权,拦截之
        emitHlsPlayed(parser, mediaInfo, accessPathInvoker, sender);
        return;
    }

    //事件未被拦截，则认为是http下载请求
    bool flag = NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastHttpAccess, parser, path, is_dir, accessPathInvoker, static_cast<SockInfo &>(sender));
    if (!flag) {
        //此事件无人监听，我们默认都有权限访问
        callback("", nullptr);
    }
}

/**
 * 发送404 Not Found
 */
static void sendNotFound(const HttpFileManager::invoker &cb) {
    GET_CONFIG(string, notFound, Http::kNotFound);
    cb(404, "text/html", StrCaseMap(), std::make_shared<HttpStringBody>(notFound));
}

/**
 * 拼接文件路径
 */
static string pathCat(const string &a, const string &b){
    if (a.back() == '/') {
        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) {
    bool is_hls = end_with(strFile, kHlsSuffix);
    bool file_exist = File::is_file(strFile.data());
    if (!is_hls && !file_exist) {
        //文件不存在且不是hls,那么直接返回404
        sendNotFound(cb);
        return;
    }

    if (is_hls) {
        //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();
    //判断是否有权限访问该文件
    canAccessPath(sender, parser, mediaInfo, false, [cb, strFile, parser, is_hls, mediaInfo, weakSession , file_exist](const string &errMsg, const HttpServerCookie::Ptr &cookie) {
        auto strongSession = weakSession.lock();
        if (!strongSession) {
            //http客户端已经断开，不需要回复
            return;
        }
        if (!errMsg.empty()) {
            //文件鉴权失败
            StrCaseMap headerOut;
            if (cookie) {
                headerOut["Set-Cookie"] = cookie->getCookie(cookie->getAttach<HttpCookieAttachment>()._path);
            }
            cb(401, "text/html", headerOut, std::make_shared<HttpStringBody>(errMsg));
            return;
        }

        auto response_file = [file_exist, is_hls](const HttpServerCookie::Ptr &cookie, const HttpFileManager::invoker &cb, const string &strFile, const Parser &parser) {
            StrCaseMap httpHeader;
            if (cookie) {
                httpHeader["Set-Cookie"] = cookie->getCookie(cookie->getAttach<HttpCookieAttachment>()._path);
            }
            HttpSession::HttpResponseInvoker invoker = [&](int code, const StrCaseMap &headerOut, const HttpBody::Ptr &body) {
                if (cookie && file_exist) {
                    auto& attach = cookie->getAttach<HttpCookieAttachment>();
                    if (attach._is_hls) {
                        attach._hls_data->addByteUsage(body->remainSize());
                    }
                }
                cb(code, HttpFileManager::getContentType(strFile.data()), headerOut, body);
            };
            invoker.responseFile(parser.getHeader(), httpHeader, strFile, !is_hls);
        };

        if (!is_hls) {
            //不是hls,直接回复文件或404
            response_file(cookie, cb, strFile, parser);
            return;
        }

        //是hls直播，判断HLS直播流是否已经注册
        bool have_find_media_src = false;
        if (cookie) {
            auto& attach = cookie->getAttach<HttpCookieAttachment>();
            have_find_media_src = attach._have_find_media_source;
            if (!have_find_media_src) {
                const_cast<HttpCookieAttachment &>(attach)._have_find_media_source = true;
            }
        }
        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) {
                //尝试添加HlsMediaSource的观看人数(HLS是按需生成的，这样可以触发HLS文件的生成)
                cookie->getAttach<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流的注册))
                response_file(cookie, cb, strFile, parser);
                return;
            }

            //流存在，但是m3u8文件不存在，那么等待生成m3u8文件(HLS源注册后，并不会立即生成HLS文件，有人观看才会按需生成HLS文件)
            hls->waitForFile([response_file, cookie, cb, strFile, parser]() {
                response_file(cookie, cb, strFile, parser);
            });
        });
    });
}

static string getFilePath(const Parser &parser,const MediaInfo &mediaInfo, TcpSession &sender){
    GET_CONFIG(bool, enableVhost, General::kEnableVhost);
    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
        path = rootPath;
        url = parser.Url();
    }
    auto ret = File::absolutePath(enableVhost ? mediaInfo._vhost + url : url, path);
    NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastHttpBeforeAccess, parser, ret, static_cast<SockInfo &>(sender));
    return ret;
}

/**
 * 访问文件或文件夹
 * @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);
    auto strFile = getFilePath(parser, mediaInfo, sender);
    //访问的是文件夹
    if (File::is_dir(strFile.data())) {
        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;
        }
        //判断是否有权限访问该目录
        canAccessPath(sender, parser, mediaInfo, true, [strMenu, cb](const string &errMsg, const HttpServerCookie::Ptr &cookie) mutable{
            if (!errMsg.empty()) {
                strMenu = errMsg;
            }
            StrCaseMap headerOut;
            if (cookie) {
                headerOut["Set-Cookie"] = cookie->getCookie(cookie->getAttach<HttpCookieAttachment>()._path);
            }
            cb(errMsg.empty() ? 200 : 401, "text/html", headerOut, std::make_shared<HttpStringBody>(strMenu));
        });
        return;
    }

    //访问的是文件
    accessFile(sender, parser, mediaInfo, strFile, cb);
};


////////////////////////////////////HttpResponseInvokerImp//////////////////////////////////////

void HttpResponseInvokerImp::operator()(int code, const StrCaseMap &headerOut, const Buffer::Ptr &body) const {
    return operator()(code, headerOut, std::make_shared<HttpBufferBody>(body));
}

void HttpResponseInvokerImp::operator()(int code, const StrCaseMap &headerOut, const HttpBody::Ptr &body) const{
    if (_lambad) {
        _lambad(code, headerOut, body);
    }
}

void HttpResponseInvokerImp::operator()(int code, const StrCaseMap &headerOut, const string &body) const{
    this->operator()(code, headerOut, std::make_shared<HttpStringBody>(body));
}

HttpResponseInvokerImp::HttpResponseInvokerImp(const HttpResponseInvokerImp::HttpResponseInvokerLambda0 &lambda){
    _lambad = lambda;
}

HttpResponseInvokerImp::HttpResponseInvokerImp(const HttpResponseInvokerImp::HttpResponseInvokerLambda1 &lambda){
    if (!lambda) {
        _lambad = nullptr;
        return;
    }
    _lambad = [lambda](int code, const StrCaseMap &headerOut, const HttpBody::Ptr &body) {
        string str;
        if (body && body->remainSize()) {
            str = body->readData(body->remainSize())->toString();
        }
        lambda(code, headerOut, str);
    };
}

void HttpResponseInvokerImp::responseFile(const StrCaseMap &requestHeader,
                                          const StrCaseMap &responseHeader,
                                          const string &filePath,
                                          bool use_mmap) const {
    StrCaseMap &httpHeader = const_cast<StrCaseMap &>(responseHeader);
    auto fileBody = std::make_shared<HttpFileBody>(filePath, use_mmap);
    if (fileBody->remainSize() < 0) {
        //打开文件失败
        GET_CONFIG(string, notFound, Http::kNotFound);
        GET_CONFIG(string, charSet, Http::kCharSet);

        auto strContentType = StrPrinter << "text/html; charset=" << charSet << endl;
        httpHeader["Content-Type"] = strContentType;
        (*this)(404, httpHeader, notFound);
        return;
    }

    auto &strRange = const_cast<StrCaseMap &>(requestHeader)["Range"];
    int code = 200;
    if (!strRange.empty()) {
        //分节下载
        code = 206;
        auto iRangeStart = atoll(FindField(strRange.data(), "bytes=", "-").data());
        auto iRangeEnd = atoll(FindField(strRange.data(), "-", nullptr).data());
        auto fileSize = fileBody->remainSize();
        if (iRangeEnd == 0) {
            iRangeEnd = fileSize - 1;
        }
        //设置文件范围
        fileBody->setRange(iRangeStart, iRangeEnd - iRangeStart + 1);
        //分节下载返回Content-Range头
        httpHeader.emplace("Content-Range", StrPrinter << "bytes " << iRangeStart << "-" << iRangeEnd << "/" << fileSize << endl);
    }

    //回复文件
    (*this)(code, httpHeader, fileBody);
}

HttpResponseInvokerImp::operator bool(){
    return _lambad.operator bool();
}


}//namespace mediakit
-												整理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
-												整理命名空间 (#1409)

* 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>
											
										
										
											2022-02-02 20:34:50 +08:00
+								using namespace std;
 								using namespace toolkit;
-												整理http文件服务器相关代码

											
										
										
											2019-11-30 11:38:00 +08:00
+								namespace mediakit {
-、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";
-、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:
 								    //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上锁先
-												http cookie减少互斥锁，优化性能

											
										
										
											2022-02-11 14:33:11 +08:00
+								        auto& attach = cookie->getAttach<HttpCookieAttachment>();
 								        if (path.find(attach._path) == 0) {
-												整理http文件服务器相关代码

											
										
										
											2019-11-30 11:38:00 +08:00
+								            //上次cookie是限定本目录
-												http cookie减少互斥锁，优化性能

											
										
										
											2022-02-11 14:33:11 +08:00
+								            if (attach._err_msg.empty()) {
-												整理http文件服务器相关代码

											
										
										
											2019-11-30 11:38:00 +08:00
+								                //上次鉴权成功
-												http cookie减少互斥锁，优化性能

											
										
										
											2022-02-11 14:33:11 +08:00
+								                if (attach._is_hls) {
-												解决hls中断恢复时播放器计数不准确的问题

											
										
										
											2019-12-29 17:55:02 +08:00
+								                    //如果播放的是hls，那么刷新hls的cookie(获取ts文件也会刷新)
-、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参数，那么判断本次请求为重复请求，无访问权限
-												http cookie减少互斥锁，优化性能

											
										
										
											2022-02-11 14:33:11 +08:00
+								                callback(attach._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]
-												http cookie减少互斥锁，优化性能

											
										
										
											2022-02-11 14:33:11 +08:00
+								            (const string &err_msg, const string &cookie_path_in, int life_second) {
-												整理http文件服务器相关代码

											
										
										
											2019-11-30 11:38:00 +08:00
+								        HttpServerCookie::Ptr cookie;
-												http cookie减少互斥锁，优化性能

											
										
										
											2022-02-11 14:33:11 +08:00
+								        if (life_second) {
-												整理http文件服务器相关代码

											
										
										
											2019-11-30 11:38:00 +08:00
+								            //本次鉴权设置了有效期，我们把鉴权结果缓存在cookie中
 								            string cookie_path = cookie_path_in;
 								            if (cookie_path.empty()) {
 								                //如果未设置鉴权目录，那么我们采用当前目录
 								                cookie_path = is_dir ? path : path.substr(0, path.rfind("/") + 1);
 								            }
-												http cookie减少互斥锁，优化性能

											
										
										
											2022-02-11 14:33:11 +08:00
+								            auto attach = std::make_shared<HttpCookieAttachment>();
-												整理http文件服务器相关代码

											
										
										
											2019-11-30 11:38:00 +08:00
+								            //记录用户能访问的路径
-												http cookie减少互斥锁，优化性能

											
										
										
											2022-02-11 14:33:11 +08:00
+								            attach->_path = cookie_path;
-												整理http文件服务器相关代码

											
										
										
											2019-11-30 11:38:00 +08:00
+								            //记录能否访问
-												http cookie减少互斥锁，优化性能

											
										
										
											2022-02-11 14:33:11 +08:00
+								            attach->_err_msg = err_msg;
-、hls cookie改成60秒有效期并且访问时刷新cookie
2、去除keep-alive下最大请求次数限制

											
										
										
											2019-11-30 14:29:44 +08:00
+								            //记录访问的是否为hls
-												http cookie减少互斥锁，优化性能

											
										
										
											2022-02-11 14:33:11 +08:00
+								            attach->_is_hls = is_hls;
-												优化HLS直播相关代码

											
										
										
											2020-09-20 10:13:15 +08:00
+								            if (is_hls) {
-												http cookie减少互斥锁，优化性能

											
										
										
											2022-02-11 14:33:11 +08:00
+								                // hls相关信息
 								                attach->_hls_data = std::make_shared<HlsCookieData>(mediaInfo, info);
 								                // hls未查找MediaSource
 								                attach->_have_find_media_source = false;
-												初步实现hls播放器个数计数

											
										
										
											2019-12-28 16:48:11 +08:00
+								            }
-												http cookie减少互斥锁，优化性能

											
										
										
											2022-02-11 14:33:11 +08:00
+								            callback(err_msg, HttpCookieManager::Instance().addCookie(kCookieName, uid, life_second, attach));
-												优化HLS直播相关代码

											
										
										
											2020-09-20 10:13:15 +08:00
+								        } else {
-												http cookie减少互斥锁，优化性能

											
										
										
											2022-02-11 14:33:11 +08:00
+								            callback(err_msg, 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) {
-												修复设置cookie错误的bug

											
										
										
											2022-02-11 15:14:34 +08:00
+								                headerOut["Set-Cookie"] = cookie->getCookie(cookie->getAttach<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: 修复hls直播ts/m3u8文件更新导致mmap失效，触发bus error的bug

											
										
										
											2021-12-22 15:42:03 +08:00
+								        auto response_file = [file_exist, is_hls](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) {
-												修复设置cookie错误的bug

											
										
										
											2022-02-11 15:14:34 +08:00
+								                httpHeader["Set-Cookie"] = cookie->getCookie(cookie->getAttach<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) {
-												http cookie减少互斥锁，优化性能

											
										
										
											2022-02-11 14:33:11 +08:00
+								                    auto& attach = cookie->getAttach<HttpCookieAttachment>();
 								                    if (attach._is_hls) {
 								                        attach._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
+								            };
-												HLS: 修复hls直播ts/m3u8文件更新导致mmap失效，触发bus error的bug

											
										
										
											2021-12-22 15:42:03 +08:00
+								            invoker.responseFile(parser.getHeader(), httpHeader, strFile, !is_hls);
-												实现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) {
-												http cookie减少互斥锁，优化性能

											
										
										
											2022-02-11 14:33:11 +08:00
+								            auto& attach = cookie->getAttach<HttpCookieAttachment>();
 								            have_find_media_src = attach._have_find_media_source;
-												优化HLS直播相关代码

											
										
										
											2020-09-20 10:13:15 +08:00
+								            if (!have_find_media_src) {
-												http cookie减少互斥锁，优化性能

											
										
										
											2022-02-11 14:33:11 +08:00
+								                const_cast<HttpCookieAttachment &>(attach)._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) {
 								                //尝试添加HlsMediaSource的观看人数(HLS是按需生成的，这样可以触发HLS文件的生成)
-												http cookie减少互斥锁，优化性能

											
										
										
											2022-02-11 14:33:11 +08:00
+								                cookie->getAttach<HttpCookieAttachment>()._hls_data->addByteUsage(0);
-												优化HLS直播相关代码

											
										
										
											2020-09-20 10:13:15 +08:00
+								            }
 								            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) {
-												修复设置cookie错误的bug

											
										
										
											2022-02-11 15:14:34 +08:00
+								                headerOut["Set-Cookie"] = cookie->getCookie(cookie->getAttach<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,
-												HLS: 修复hls直播ts/m3u8文件更新导致mmap失效，触发bus error的bug

											
										
										
											2021-12-22 15:42:03 +08:00
+								                                          const string &filePath,
 								                                          bool use_mmap) const {
-												优化HLS直播相关代码

											
										
										
											2020-09-20 10:13:15 +08:00
+								    StrCaseMap &httpHeader = const_cast<StrCaseMap &>(responseHeader);
-												http文件服务器mmap方案采用共享方式

											
										
										
											2022-02-10 20:23:37 +08:00
+								    auto fileBody = std::make_shared<HttpFileBody>(filePath, use_mmap);
 								    if (fileBody->remainSize() < 0) {
-												整理http文件服务器相关代码

											
										
										
											2019-11-30 11:38:00 +08:00
+								        //打开文件失败
-												优化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"];
-												http文件服务器mmap方案采用共享方式

											
										
										
											2022-02-10 20:23:37 +08:00
+								    int code = 200;
 								    if (!strRange.empty()) {
-												整理http文件服务器相关代码

											
										
										
											2019-11-30 11:38:00 +08:00
+								        //分节下载
-												http回复根据状态码自动生成status message: #602

											
										
										
											2021-01-02 21:24:06 +08:00
+								        code = 206;
-												http文件服务器mmap方案采用共享方式

											
										
										
											2022-02-10 20:23:37 +08:00
+								        auto iRangeStart = atoll(FindField(strRange.data(), "bytes=", "-").data());
 								        auto iRangeEnd = atoll(FindField(strRange.data(), "-", nullptr).data());
 								        auto fileSize = fileBody->remainSize();
-												整理http文件服务器相关代码

											
										
										
											2019-11-30 11:38:00 +08:00
+								        if (iRangeEnd == 0) {
 								            iRangeEnd = fileSize - 1;
 								        }
-												http文件服务器mmap方案采用共享方式

											
										
										
											2022-02-10 20:23:37 +08:00
+								        //设置文件范围
 								        fileBody->setRange(iRangeStart, iRangeEnd - iRangeStart + 1);
-												整理http文件服务器相关代码

											
										
										
											2019-11-30 11:38:00 +08:00
+								        //分节下载返回Content-Range头
 								        httpHeader.emplace("Content-Range", StrPrinter << "bytes " << iRangeStart << "-" << iRangeEnd << "/" << fileSize << endl);
 								    }
 								    //回复文件
-												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