SRS源码框架，配置文件(SrsConfig)的使用
本章内容解读SRS开源代码框架，无二次开发，以学习交流为目的。
SRS是国人开发的开源流媒体服务器，C++语言开发，本章使用版本：https://github.com/ossrs/srs/tree/5.0release。
目录
-
- SRS配置文件的使用
- 源码
- 源码测试
SRS配置文件的使用
SRS封装了SrsConfig类，定义了使用方便且功能强大的配置文件，部分参考了nginx的配置文件，形式上类似与JSON，一个配置项里面可以包含子配置项，套娃的形式和JSON数组很像；可重新加载配置，重载配置时通过回调函数的形式执行其他模块的重载。
功能概述：
1、通过命令行传参，解析main()函数命令行参数（parse_options），定义了传参选项：-h（打印帮助），-t（测试配置文件），-e（使用环境变量配置），-v（打印版本号），-g（打印签名），-c（读配置文件）。
2、SRS支持从系统环境变量读取配置信息，不使用配置文件（env_only_），包括配置文件名也可以从环境变量读取（srs_getenv(“srs.config.file”)）。
3、SRS默认策略是：如果系统环境变量有配置，优先使用系统环境变量的配置，其次使用配置文件的配置，最后使用默认值。
4、SRS封装了配置指令类（SrsConfDirective），一个配置指令包括：指令所在配置文件的行号（conf_line），指令名称，指令值数组（args，多个参数），子指令数组（directives，一个指令可包含多个子指令，数据结构一样）。
5、定义了根指令对象（root = new SrsConfDirective），先把配置文件读入缓存区（SrsConfigBuffer），再从缓存区解析配置，存入根指令（parse_conf）。
6、SRS提供了检测配置是否合法的接口（check_config），检测内容包括：各项配置字段是否合法，配置指令值是否合法（很细致的检测，配置文件一个标点符号都不能错）；检测配置的最大连接数是否小于等于系统支持的最大连接数（sysconf(_SC_OPEN_MAX)）。
7、提供了重载配置文件的接口（reload），可通过linux信号量实现配置文件重新加载。
8、当重载配置文件时，可执行各模块的回调函数，实现重载模块功能，模块类继承于ISrsReloadHandler，使用_srs_config->subscribe(this)注册重载，unsubscribe可取消注册重载，注册重载的模块加入数组（subscribes），重载时遍历执行数组（subscribes）里的回调函数。
9、配置重载流程：收到信号SRS_SIGNAL_RELOAD，_srs_config->reload()，重新解析配置文件parse_file，检测配置check_config，重载配置reload_conf，遍历执行subscribes注册的回调。
10、配置文件包括大量vhost内容，本章不讨论。
上述功能结合源码看，方便理解。
源码
配置模块代码量1W+，本章做了裁剪，基本可以直接运行，代码结构如下：
├── chw_adapt.cpp
├── chw_adapt.h
├── main.cpp
├── srs_app_config.cpp
├── srs_app_config.hpp
├── srs_app_reload.cpp
├── srs_app_reload.hpp
├── srs_kernel_error.cpp
├── srs_kernel_error.hpp
├── srs_kernel_file.cpp
├── srs_kernel_file.hpp
├── srs_kernel_io.cpp
├── srs_kernel_io.hpp
├── srs_protocol_json.cpp
├── srs_protocol_json.hpp
├── Test_ReloadWork.cpp
└── Test_ReloadWork.h
其中srs_app_reload、srs_kernel_file、srs_kernel_io、srs_protocol_json源码和开源类似，这里不贴了。
srs_kernel_error源码参考：https://blog.csdn.net/weixin_40355471/article/details/131940488?spm=1001.2014.3001.5502。
此外还包括配置文件模板，使用开源自带的：srs.conf。
srs_app_config.hpp
#ifndef SRS_APP_CONFIG_HPP
#define SRS_APP_CONFIG_HPP
#include
// 从子指令数组directives中获取第index个指令
virtual SrsConfDirective* at(int index);
// Get the directive by name, return the first match.
// 按名称获取指令，返回第一个匹配项。
virtual SrsConfDirective* get(std::string _name);
// Get the directive by name and its arg0, return the first match.
//获取指令及其第一个参数arg0，返回第一个匹配。
virtual SrsConfDirective* get(std::string _name, std::string _arg0);
// RAW
public:
virtual SrsConfDirective* get_or_create(std::string n);
virtual SrsConfDirective* get_or_create(std::string n, std::string a0);
virtual SrsConfDirective* get_or_create(std::string n, std::string a0, std::string a1);
virtual SrsConfDirective* set_arg0(std::string a0);
// Remove the v from sub directives, user must free the v.
// 从子指令数组directives中删除一个指令v，用户自己管理释放v
virtual void remove(SrsConfDirective* v);
// help utilities
public:
// Whether current directive is vhost.
// 当前指令是不是vhost
virtual bool is_vhost();
// Whether current directive is stream_caster.
// 当前指令是不是stream_caster
virtual bool is_stream_caster();
// Parse utilities
public:
// Parse config directive from file buffer.
// 从配置缓冲区中解析指令
virtual srs_error_t parse(srs_internal::SrsConfigBuffer* buffer, SrsConfig* conf = NULL);
// Marshal the directive to writer.
// @param level, the root is level0, all its directives are level1, and so on.
// 将指令写入writer，level是级别，根指令是level0，根指令的所有子指令都是level1，以此类推。
virtual srs_error_t persistence(SrsFileWriter* writer, int level);
// Dumps the args[0-N] to array(string).
// 将参数转储到JSON数组（字符串）中。
virtual SrsJsonArray* dumps_args();
// Dumps arg0 to str, number or boolean.
// 把第一个参数arg0转换为字符串，数字，或布尔类型
virtual SrsJsonAny* dumps_arg0_to_str();
virtual SrsJsonAny* dumps_arg0_to_integer();
virtual SrsJsonAny* dumps_arg0_to_number();
virtual SrsJsonAny* dumps_arg0_to_boolean();
// private parse.
private:
// The directive parsing context.指令解析上下文
enum SrsDirectiveContext {
// The root directives, parsing file.
// 根指令，解析文件。
SrsDirectiveContextFile,
// For each directive, parsing text block.
// 对每个指令，解析文本
SrsDirectiveContextBlock,
};
enum SrsDirectiveState {//指令解析状态
// Init state
SrsDirectiveStateInit,
// The directive terminated by ';' found
SrsDirectiveStateEntire,
// The token terminated by '{' found
SrsDirectiveStateBlockStart,
// The '}' found
SrsDirectiveStateBlockEnd,
// The config file is done
SrsDirectiveStateEOF,
};
// Parse the conf from buffer. the work flow:
// 1. read a token(directive args and a ret flag),
// 2. initialize the directive by args, args[0] is name, args[1-N] is args of directive,
// 3. if ret flag indicates there are child-directives, read_conf(directive, block) recursively.
//从缓冲区解析conf。工作流程：
//1. 读取一个标记（指令args和一个ret标志），
//2. 通过args初始化指令，args[0]是名称，args[1-N]是指令的args，
//3. 如果ret标志表示有子指令，则read_conf（指令，块）递归化。
virtual srs_error_t parse_conf(srs_internal::SrsConfigBuffer* buffer, SrsDirectiveContext ctx, SrsConfig* conf);
// Read a token from buffer.
// A token, is the directive args and a flag indicates whether has child-directives.
// @param args, the output directive args, the first is the directive name, left is the args.
// @param line_start, the actual start line of directive.
// @return, an error code indicates error or has child-directives.
// 从缓冲区中读取一个标记。
// 一个标记，是指令参数，并有一个标志指示是否有子指令。
// @param args,输出指令的args，第一个是指令名，左边是args。
// @param line_start,指令的实际起始行。
// @return,错误代码指示错误或有子指令。
virtual srs_error_t read_token(srs_internal::SrsConfigBuffer* buffer, std::vector<std::string>& args, int& line_start, SrsDirectiveState& state);
};
// The config service provider.
// For the config supports reload, so never keep the reference cross st-thread,
// that is, never save the SrsConfDirective* get by any api of config,
// For it maybe free in the reload st-thread cycle.
// You could keep it before st-thread switch, or simply never keep it.
// 提供配置服务，因为配置支持重新加载，不要在多协程中使用SrsConfDirective的引用或保存其指针，因为其可能在重新加载时被释放
// 可以在st线程切换之前保存它，或者干脆永远不要保存它。
class SrsConfig
{
friend class SrsConfDirective;
// user command
private:
// Whether show help and exit.是否显示帮助并退出
bool show_help;
// Whether test config file and exit.是否测试配置文件并退出
bool test_conf;
// Whether show SRS version and exit.是否显示SRS版本并退出
bool show_version;
// Whether show SRS signature and exit.是否显示SRS签名并退出
bool show_signature;
// Whether only use environment variable, ignore config file.
// Set it by argv "-e" or env "SRS_ENV_ONLY=on".
bool env_only_;//是否使用用户环境变量，忽略配置文件
// global env variables.
private://全局环境变量
// The user parameters, the argc and argv.
// The argv is " ".join(argv), where argv is from main(argc, argv).
std::string _argv;//从main函数传参过来的argv参数组合
// current working directory.
std::string _cwd;//当前工作目录
// Config section
private:
// The last parsed config file.
// If reload, reload the config file.
// 最后一次解析的配置文件名，重载会更新
std::string config_file;
protected:
// The directive root. 根指令
SrsConfDirective* root;
// Reload section
private:
// The reload subscribers, when reload, callback all handlers.
// 重新加载订阅集，在重新加载时，会回调所有处理程序。
std::vector<ISrsReloadHandler*> subscribes;
public:
SrsConfig();
virtual ~SrsConfig();
// Reload
public:
// For reload handler to register itself,
// when config service do the reload, callback the handler.
// 重载注册，当配置服务进行重新加载时，回调处理程序。
virtual void subscribe(ISrsReloadHandler* handler);
// For reload handler to unregister itself.
// 取消重载注册
virtual void unsubscribe(ISrsReloadHandler* handler);
// Reload the config file.
// @remark, user can test the config before reload it.
virtual srs_error_t reload();//重载配置文件
protected:
// Reload from the config. 从SrsConfig中重载配置
// @remark, use protected for the utest to override with mock.
virtual srs_error_t reload_conf(SrsConfig* conf);
// Parse options and file
public:
// Parse the cli, the main(argc,argv) function.
// 解析main函数传参
virtual srs_error_t parse_options(int argc, char** argv);
// initialize the cwd for server,
// because we may change the workdir.
// 初始化当前工作目录，因为可能会改变
virtual srs_error_t initialize_cwd();
// Marshal current config to file.
// 将当前配置转换到文件。
virtual srs_error_t persistence();
private:
virtual srs_error_t do_persistence(SrsFileWriter* fw);
public:
// Dumps the http_api sections to json for raw api info.
private:
virtual srs_error_t do_reload_testwork();//chw
public:
// Get the config file path.
virtual std::string config();//获取配置文件路径
private:
// Parse each argv.解析每一个参数
virtual srs_error_t parse_argv(int& i, char** argv);
// Print help and exit.打印帮助并退出
virtual void print_help(char** argv);
public:
// Parse the config file, which is specified by cli.
// 解析由cli指定的配置文件。
virtual srs_error_t parse_file(const char* filename);
private:
// Build a buffer from a src, which is string content or filename.
// 从src构建一个缓冲区，它是字符串内容或文件名。
virtual srs_error_t build_buffer(std::string src, srs_internal::SrsConfigBuffer** pbuffer);
public:
// Check the parsed config. 检查配置文件
virtual srs_error_t check_config();
protected:
virtual srs_error_t check_normal_config();
virtual srs_error_t check_number_connections();
protected:
// Parse config from the buffer. 从缓冲区解析配置
// @param buffer, the config buffer, user must delete it.
// @remark, use protected for the utest to override with mock.
virtual srs_error_t parse_buffer(srs_internal::SrsConfigBuffer* buffer);
// global env
public:
// Get the current work directory. 获取当前工作目录
virtual std::string cwd();
// Get the cli, the main(argc,argv), program start command.
// 获取main函数的传参
virtual std::string argv();
// global section
public:
// Get the directive root, corresponding to the config file.
// The root directive, no name and args, contains directives.
// All directive parsed can retrieve from root.
//获取对应于配置文件的指令根目录。
//根指令，没有名称和根参数，包含指令。
//所有被解析的指令都可以从根目录中检索。
virtual SrsConfDirective* get_root();
// Get the daemon config.
// If true, SRS will run in daemon mode, fork and fork to reap the
// grand-child process to init process.
//获取守护进程配置。
//如果为真，SRS将在守护进程模式、fork和fork中运行，以获取孙子进程到init进程。
virtual bool get_daemon();
// Whether srs in docker.
virtual bool get_in_docker();
private:
// Whether user use full.conf
virtual bool is_full_config();
public:
// Get the server id, generated a random one if not configured.
// 获取服务器id，如果未配置，则生成一个随机的服务器id。
virtual std::string get_server_id();
// Get the max connections limit of system.
// If exceed the max connection, SRS will disconnect the connection.
// @remark, linux will limit the connections of each process,
// for example, when you need SRS to service 10000+ connections,
// user must use "ulimit -HSn 10000" and config the max connections
// of SRS.
//获取系统的最大连接限制。如果超过最大连接，SRS将断开连接。
virtual int get_max_connections();
// Get the listen port of SRS.
// user can specifies multiple listen ports,
// each args of directive is a listen port.
//获取SRS的监听端口。
//用户可以指定多个监听端口，
//指令的每个参数都是一个侦听端口。
virtual std::vector<std::string> get_listens();
// Get the pid file path.
// The pid file is used to save the pid of SRS,
// use file lock to prevent multiple SRS starting.
// @remark, if user need to run multiple SRS instance,
// for example, to start multiple SRS for multiple CPUs,
// user can use different pid file for each process.
//获取pid文件路径。
//pid文件用于保存SRS的pid，
//使用文件锁定来防止多个SRS启动。
virtual std::string get_pid_file();
// Get pithy print pulse in srs_utime_t,
// For example, all rtmp connections only print one message
// every this interval in ms.
// 在srs_utime_t中获得简洁的打印脉冲，例如，所有rtmp连接在ms内每此间隔只打印一条消息。
virtual srs_utime_t get_pithy_print();
// Whether use utc-time to format the time.
// 是否使用utc时间来格式化时间。
virtual bool get_utc_time();
// Get the configed work dir.
// ignore if empty string.
virtual std::string get_work_dir();
// Whether use asprocess mode.
virtual bool get_asprocess();
// Whether query the latest available version of SRS.
virtual bool whether_query_latest_version();
private:
SrsConfDirective* get_srt(std::string vhost);
public:
bool get_srt_enabled(std::string vhost);
bool get_srt_to_rtmp(std::string vhost);
public:
// Whether log to file.
virtual bool get_log_tank_file();
// Get the log level.
virtual std::string get_log_level();
virtual std::string get_log_level_v2();
// Get the log file path.
virtual std::string get_log_file();
// Whether ffmpeg log enabled
virtual bool get_ff_log_enabled();
// The ffmpeg log dir.
// @remark, /dev/null to disable it.
virtual std::string get_ff_log_dir();
// The ffmpeg log level.
virtual std::string get_ff_log_level();
// The MPEG-DASH section.
virtual std::string get_http_server_listen();
private:
private:
SrsConfDirective* get_https_api();
};
#endif
srs_app_config.cpp
#include chw_adapt.h
#ifndef CHW_ADAPT_H
#define CHW_ADAPT_H
#include chw_adapt.cpp
#include "chw_adapt.h"
vector<SrsIPAddress*> _srs_system_ips;
bool srs_string_ends_with(string str, string flag)
{
const size_t pos = str.rfind(flag);
return (pos != string::npos) && (pos == str.length() - flag.length());
}
extern std::vector<SrsIPAddress*>& srs_get_local_ips();
void srs_free_global_system_ips()
{
vector<SrsIPAddress*>& ips = _srs_system_ips;
// Release previous IPs.
for (int i = 0; i < (int)ips.size(); i++) {
SrsIPAddress* ip = ips[i];
srs_freep(ip);
}
ips.clear();
}
// we detect all network device as internet or intranet device, by its ip address.
// key is device name, for instance, eth0
// value is whether internet, for instance, true.
bool srs_net_device_is_internet(const sockaddr* addr)
{
if(addr->sa_family == AF_INET) {
const in_addr inaddr = ((sockaddr_in*)addr)->sin_addr;
const uint32_t addr_h = ntohl(inaddr.s_addr);
// lo, 127.0.0.0-127.0.0.1
if (addr_h >= 0x7f000000 && addr_h <= 0x7f000001) {
return false;
}
// Class A 10.0.0.0-10.255.255.255
if (addr_h >= 0x0a000000 && addr_h <= 0x0affffff) {
return false;
}
// Class B 172.16.0.0-172.31.255.255
if (addr_h >= 0xac100000 && addr_h <= 0xac1fffff) {
return false;
}
// Class C 192.168.0.0-192.168.255.255
if (addr_h >= 0xc0a80000 && addr_h <= 0xc0a8ffff) {
return false;
}
} else if(addr->sa_family == AF_INET6) {
const sockaddr_in6* a6 = (const sockaddr_in6*)addr;
// IPv6 loopback is ::1
if (IN6_IS_ADDR_LOOPBACK(&a6->sin6_addr)) {
return false;
}
// IPv6 unspecified is ::
if (IN6_IS_ADDR_UNSPECIFIED(&a6->sin6_addr)) {
return false;
}
// From IPv4, you might know APIPA (Automatic Private IP Addressing) or AutoNet.
// Whenever automatic IP configuration through DHCP fails.
// The prefix of a site-local address is FE80::/10.
if (IN6_IS_ADDR_LINKLOCAL(&a6->sin6_addr)) {
return false;
}
// Site-local addresses are equivalent to private IP addresses in IPv4.
// The prefix of a site-local address is FEC0::/10.
// https://4sysops.com/archives/ipv6-tutorial-part-6-site-local-addresses-and-link-local-addresses/
if (IN6_IS_ADDR_SITELOCAL(&a6->sin6_addr)) {
return false;
}
// Others.
if (IN6_IS_ADDR_MULTICAST(&a6->sin6_addr)) {
return false;
}
if (IN6_IS_ADDR_MC_NODELOCAL(&a6->sin6_addr)) {
return false;
}
if (IN6_IS_ADDR_MC_LINKLOCAL(&a6->sin6_addr)) {
return false;
}
if (IN6_IS_ADDR_MC_SITELOCAL(&a6->sin6_addr)) {
return false;
}
if (IN6_IS_ADDR_MC_ORGLOCAL(&a6->sin6_addr)) {
return false;
}
if (IN6_IS_ADDR_MC_GLOBAL(&a6->sin6_addr)) {
return false;
}
}
return true;
}
void discover_network_iface(ifaddrs* cur, vector<SrsIPAddress*>& ips, stringstream& ss0, stringstream& ss1, bool ipv6, bool loopback)
{
char saddr[64];
char* h = (char*)saddr;
socklen_t nbh = (socklen_t)sizeof(saddr);
const int r0 = getnameinfo(cur->ifa_addr, sizeof(sockaddr_storage), h, nbh, NULL, 0, NI_NUMERICHOST);
if(r0) {
printf("convert local ip failed: %s", gai_strerror(r0));
return;
}
std::string ip(saddr, strlen(saddr));
ss0 << ", iface[" << (int)ips.size() << "] " << cur->ifa_name << " " << (ipv6? "ipv6":"ipv4")
<< " 0x" << std::hex << cur->ifa_flags << std::dec << " " << ip;
SrsIPAddress* ip_address = new SrsIPAddress();
ip_address->ip = ip;
ip_address->is_ipv4 = !ipv6;
ip_address->is_loopback = loopback;
ip_address->ifname = cur->ifa_name;
ip_address->is_internet = srs_net_device_is_internet(cur->ifa_addr);
ips.push_back(ip_address);
// set the device internet status.
if (!ip_address->is_internet) {
ss1 << ", intranet ";
_srs_device_ifs[cur->ifa_name] = false;
} else {
ss1 << ", internet ";
_srs_device_ifs[cur->ifa_name] = true;
}
ss1 << cur->ifa_name << " " << ip;
}
void retrieve_local_ips()
{
// Release previous IPs.
srs_free_global_system_ips();
vector<SrsIPAddress*>& ips = _srs_system_ips;
// Get the addresses.
ifaddrs* ifap;
if (getifaddrs(&ifap) == -1) {
printf("retrieve local ips, getifaddrs failed.");
return;
}
stringstream ss0;
ss0 << "ips";
stringstream ss1;
ss1 << "devices";
// Discover IPv4 first.
for (ifaddrs* p = ifap; p ; p = p->ifa_next) {
ifaddrs* cur = p;
// Ignore if no address for this interface.
// @see https://github.com/ossrs/srs/issues/1087#issuecomment-408847115
if (!cur->ifa_addr) {
continue;
}
// retrieve IP address, ignore the tun0 network device, whose addr is NULL.
// @see: https://github.com/ossrs/srs/issues/141
bool ipv4 = (cur->ifa_addr->sa_family == AF_INET);
bool ready = (cur->ifa_flags & IFF_UP) && (cur->ifa_flags & IFF_RUNNING);
// Ignore IFF_PROMISC(Interface is in promiscuous mode), which may be set by Wireshark.
bool ignored = (!cur->ifa_addr) || (cur->ifa_flags & IFF_LOOPBACK) || (cur->ifa_flags & IFF_POINTOPOINT);
bool loopback = (cur->ifa_flags & IFF_LOOPBACK);
if (ipv4 && ready && !ignored) {
discover_network_iface(cur, ips, ss0, ss1, false, loopback);
}
}
// Then, discover IPv6 addresses.
for (ifaddrs* p = ifap; p ; p = p->ifa_next) {
ifaddrs* cur = p;
// Ignore if no address for this interface.
// @see https://github.com/ossrs/srs/issues/1087#issuecomment-408847115
if (!cur->ifa_addr) {
continue;
}
// retrieve IP address, ignore the tun0 network device, whose addr is NULL.
// @see: https://github.com/ossrs/srs/issues/141
bool ipv6 = (cur->ifa_addr->sa_family == AF_INET6);
bool ready = (cur->ifa_flags & IFF_UP) && (cur->ifa_flags & IFF_RUNNING);
bool ignored = (!cur->ifa_addr) || (cur->ifa_flags & IFF_POINTOPOINT) || (cur->ifa_flags & IFF_PROMISC) || (cur->ifa_flags & IFF_LOOPBACK);
bool loopback = (cur->ifa_flags & IFF_LOOPBACK);
if (ipv6 && ready && !ignored) {
discover_network_iface(cur, ips, ss0, ss1, true, loopback);
}
}
// If empty, disover IPv4 loopback.
if (ips.empty()) {
for (ifaddrs* p = ifap; p ; p = p->ifa_next) {
ifaddrs* cur = p;
// Ignore if no address for this interface.
// @see https://github.com/ossrs/srs/issues/1087#issuecomment-408847115
if (!cur->ifa_addr) {
continue;
}
// retrieve IP address, ignore the tun0 network device, whose addr is NULL.
// @see: https://github.com/ossrs/srs/issues/141
bool ipv4 = (cur->ifa_addr->sa_family == AF_INET);
bool ready = (cur->ifa_flags & IFF_UP) && (cur->ifa_flags & IFF_RUNNING);
bool ignored = (!cur->ifa_addr) || (cur->ifa_flags & IFF_POINTOPOINT) || (cur->ifa_flags & IFF_PROMISC);
bool loopback = (cur->ifa_flags & IFF_LOOPBACK);
if (ipv4 && ready && !ignored) {
discover_network_iface(cur, ips, ss0, ss1, false, loopback);
}
}
}
printf("%s", ss0.str().c_str());
printf("%s", ss1.str().c_str());
freeifaddrs(ifap);
}
vector<SrsIPAddress*>& srs_get_local_ips()
{
if (_srs_system_ips.empty()) {
retrieve_local_ips();
}
return _srs_system_ips;
}
bool srs_check_ip_addr_valid(string ip)
{
unsigned char buf[sizeof(struct in6_addr)];
// check ipv4
int ret = inet_pton(AF_INET, ip.data(), buf);
if (ret > 0) {
return true;
}
ret = inet_pton(AF_INET6, ip.data(), buf);
if (ret > 0) {
return true;
}
return false;
}
string srs_any_address_for_listener()
{
bool ipv4_active = false;
bool ipv6_active = false;
if (true) {
int fd = socket(AF_INET, SOCK_DGRAM, 0);
if(fd != -1) {
ipv4_active = true;
close(fd);
}
}
if (true) {
int fd = socket(AF_INET6, SOCK_DGRAM, 0);
if(fd != -1) {
ipv6_active = true;
close(fd);
}
}
if (ipv6_active && !ipv4_active) {
return SRS_CONSTS_LOOPBACK6;
}
return SRS_CONSTS_LOOPBACK;
}
void srs_parse_endpoint(string hostport, string& ip, int& port)
{
const size_t pos = hostport.rfind(":"); // Look for ":" from the end, to work with IPv6.
if (pos != std::string::npos) {
if ((pos >= 1) && (hostport[0] == '[') && (hostport[pos - 1] == ']')) {
// Handle IPv6 in RFC 2732 format, e.g. [3ffe:dead:beef::1]:1935
ip = hostport.substr(1, pos - 2);
} else {
// Handle IP address
ip = hostport.substr(0, pos);
}
const string sport = hostport.substr(pos + 1);
port = ::atoi(sport.c_str());
} else {
ip = srs_any_address_for_listener();
port = ::atoi(hostport.c_str());
}
}
std::string srs_fmt(const char* fmt, ...)
{
va_list ap;
va_start(ap, fmt);
static char buf[8192];
int r0 = vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
string v;
if (r0 > 0 && r0 < (int)sizeof(buf)) {
v.append(buf, r0);
}
return v;
}
string srs_int2str(int64_t value)
{
return srs_fmt("%" PRId64, value);
}
bool srs_path_exists(std::string path)
{
struct stat st;
// stat current dir, if exists, return error.
if (stat(path.c_str(), &st) == 0) {
return true;
}
return false;
}
vector<string> srs_string_split(string s, string seperator)
{
vector<string> result;
if(seperator.empty()){
result.push_back(s);
return result;
}
size_t posBegin = 0;
size_t posSeperator = s.find(seperator);
while (posSeperator != string::npos) {
result.push_back(s.substr(posBegin, posSeperator - posBegin));
posBegin = posSeperator + seperator.length(); // next byte of seperator
posSeperator = s.find(seperator, posBegin);
}
// push the last element
result.push_back(s.substr(posBegin));
return result;
}
string srs_string_replace(string str, string old_str, string new_str)
{
std::string ret = str;
if (old_str == new_str) {
return ret;
}
size_t pos = 0;
while ((pos = ret.find(old_str, pos)) != std::string::npos) {
ret = ret.replace(pos, old_str.length(), new_str);
pos += new_str.length();
}
return ret;
}
bool srs_string_starts_with(string str, string flag)
{
return str.find(flag) == 0;
}
string srs_getenv(const string& key)
{
string ekey = key;
if (srs_string_starts_with(key, "$")) {
ekey = key.substr(1);
}
if (ekey.empty()) {
return "";
}
std::string::iterator it;
for (it = ekey.begin(); it != ekey.end(); ++it) {
if (*it >= 'a' && *it <= 'z') {
*it += ('A' - 'a');
} else if (*it == '.') {
*it = '_';
}
}
char* value = ::getenv(ekey.c_str());
if (value) {
return value;
}
return "";
}
srs.conf
# main config for srs.
# @see full.conf for detail config.
listen 1935;
max_connections 500;
#srs_log_tank file;
#srs_log_file ./objs/srs.log;
daemon on;
http_api {
enabled on;
listen 1985;
}
http_server {
enabled on;
listen 8080;
dir ./objs/nginx/html;
}
rtc_server {
enabled on;
listen 8000; # UDP port
# @see https://ossrs.net/lts/zh-cn/docs/v4/doc/webrtc#config-candidate
candidate $CANDIDATE;
}
vhost __defaultVhost__ {
hls {
enabled on;
}
http_remux {
enabled on;
mount [vhost]/[app]/[stream].flv;
}
rtc {
enabled on;
# @see https://ossrs.net/lts/zh-cn/docs/v4/doc/webrtc#rtmp-to-rtc
rtmp_to_rtc off;
# @see https://ossrs.net/lts/zh-cn/docs/v4/doc/webrtc#rtc-to-rtmp
rtc_to_rtmp off;
}
play{
gop_cache_max_frames 2500;
}
}
Test_ReloadWork.h
#ifndef TEST_RELOADWORK_H
#define TEST_RELOADWORK_H
#include "srs_app_reload.hpp"
class Test_ReloadWork : public ISrsReloadHandler
{
public:
Test_ReloadWork();
virtual srs_error_t on_reload_testwork();
};
#endif // TEST_RELOADWORK_H
Test_ReloadWork.cpp
#include "Test_ReloadWork.h"
Test_ReloadWork::Test_ReloadWork()
{
}
srs_error_t Test_ReloadWork::on_reload_testwork()
{
printf("\non_reload_testwork\n");
return srs_success;
}
源码测试
main.cpp
#include "srs_app_config.hpp"
#include "Test_ReloadWork.h"
SrsConfig* _srs_config = NULL;
int main(int argc, char *argv[])
{
setbuf(stdout,NULL);
_srs_config = new SrsConfig();
_srs_config->parse_options(argc, argv);
_srs_config->check_config();
_srs_config->get_http_server_listen();
Test_ReloadWork* pTest_ReloadWork = new Test_ReloadWork;
_srs_config->subscribe(pTest_ReloadWork);
_srs_config->reload();
while(1){}
}
打印：
XCORE-SRS/5.0.168(Bee)config parse complete
you can check log by: tail -n 30 -f ./objs/srs.log
please check SRS by: ./etc/init.d/srs status
srs checking config...
you can check log by: tail -n 30 -f ./objs/srs.log
please check SRS by: ./etc/init.d/srs status
http_server,listen=8080
config parse complete
config reloader parse file success.
srs checking config...
you can check log by: tail -n 30 -f ./objs/srs.log
please check SRS by: ./etc/init.d/srs status
on_reload_testwork
reload testwork success.