添加完整的服务器用例

3rdpart/jsoncpp/assertions.h

+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef CPPTL_JSON_ASSERTIONS_H_INCLUDED
+#define CPPTL_JSON_ASSERTIONS_H_INCLUDED
+
+#include <stdlib.h>
+#include <sstream>
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "../jsoncpp/config.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+/** It should not be possible for a maliciously designed file to
+ *  cause an abort() or seg-fault, so these macros are used only
+ *  for pre-condition violations and internal logic errors.
+ */
+#if JSON_USE_EXCEPTION
+
+// @todo <= add detail about condition in exception
+# define JSON_ASSERT(condition)                                                \
+  {if (!(condition)) {Json::throwLogicError( "assert json failed" );}}
+
+# define JSON_FAIL_MESSAGE(message)                                            \
+  {                                                                            \
+    std::ostringstream oss; oss << message;                                    \
+    Json::throwLogicError(oss.str());                                          \
+  }
+
+#else // JSON_USE_EXCEPTION
+
+# define JSON_ASSERT(condition) assert(condition)
+
+// The call to assert() will show the failure message in debug builds. In
+// release builds we abort, for a core-dump or debugger.
+# define JSON_FAIL_MESSAGE(message)                                            \
+  {                                                                            \
+    std::ostringstream oss; oss << message;                                    \
+    assert(false && oss.str().c_str());                                        \
+    abort();                                                                   \
+  }
+
+
+#endif
+
+#define JSON_ASSERT_MESSAGE(condition, message)                                \
+  if (!(condition)) {                                                          \
+    JSON_FAIL_MESSAGE(message);                                                \
+  }
+
+#endif // CPPTL_JSON_ASSERTIONS_H_INCLUDED

3rdpart/jsoncpp/autolink.h

+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_AUTOLINK_H_INCLUDED
+#define JSON_AUTOLINK_H_INCLUDED
+
+#include "../jsoncpp/config.h"
+
+#ifdef JSON_IN_CPPTL
+#include <cpptl/cpptl_autolink.h>
+#endif
+
+#if !defined(JSON_NO_AUTOLINK) && !defined(JSON_DLL_BUILD) &&                  \
+    !defined(JSON_IN_CPPTL)
+#define CPPTL_AUTOLINK_NAME "json"
+#undef CPPTL_AUTOLINK_DLL
+#ifdef JSON_DLL
+#define CPPTL_AUTOLINK_DLL
+#endif
+#include "autolink.h"
+#endif
+
+#endif // JSON_AUTOLINK_H_INCLUDED

3rdpart/jsoncpp/config.h

+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_CONFIG_H_INCLUDED
+#define JSON_CONFIG_H_INCLUDED
+
+/// If defined, indicates that json library is embedded in CppTL library.
+//# define JSON_IN_CPPTL 1
+
+/// If defined, indicates that json may leverage CppTL library
+//#  define JSON_USE_CPPTL 1
+/// If defined, indicates that cpptl vector based map should be used instead of
+/// std::map
+/// as Value container.
+//#  define JSON_USE_CPPTL_SMALLMAP 1
+
+// If non-zero, the library uses exceptions to report bad input instead of C
+// assertion macros. The default is to use exceptions.
+#ifndef JSON_USE_EXCEPTION
+#define JSON_USE_EXCEPTION 1
+#endif
+
+/// If defined, indicates that the source file is amalgated
+/// to prevent private header inclusion.
+/// Remarks: it is automatically defined in the generated amalgated header.
+// #define JSON_IS_AMALGAMATION
+
+#ifdef JSON_IN_CPPTL
+#include <cpptl/config.h>
+#ifndef JSON_USE_CPPTL
+#define JSON_USE_CPPTL 1
+#endif
+#endif
+
+#ifdef JSON_IN_CPPTL
+#define JSON_API CPPTL_API
+#elif defined(JSON_DLL_BUILD)
+#if defined(_MSC_VER)
+#define JSON_API __declspec(dllexport)
+#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
+#endif // if defined(_MSC_VER)
+#elif defined(JSON_DLL)
+#if defined(_MSC_VER)
+#define JSON_API __declspec(dllimport)
+#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
+#endif // if defined(_MSC_VER)
+#endif // ifdef JSON_IN_CPPTL
+#if !defined(JSON_API)
+#define JSON_API
+#endif
+
+// If JSON_NO_INT64 is defined, then Json only support C++ "int" type for
+// integer
+// Storages, and 64 bits integer support is disabled.
+// #define JSON_NO_INT64 1
+
+#if defined(_MSC_VER) && _MSC_VER <= 1200 // MSVC 6
+// Microsoft Visual Studio 6 only support conversion from __int64 to double
+// (no conversion from unsigned __int64).
+#define JSON_USE_INT64_DOUBLE_CONVERSION 1
+// Disable warning 4786 for VS6 caused by STL (identifier was truncated to '255'
+// characters in the debug information)
+// All projects I've ever seen with VS6 were using this globally (not bothering
+// with pragma push/pop).
+#pragma warning(disable : 4786)
+#endif // if defined(_MSC_VER)  &&  _MSC_VER < 1200 // MSVC 6
+
+#if defined(_MSC_VER) && _MSC_VER >= 1500 // MSVC 2008
+/// Indicates that the following function is deprecated.
+#define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
+#elif defined(__clang__) && defined(__has_feature)
+#if __has_feature(attribute_deprecated_with_message)
+#define JSONCPP_DEPRECATED(message)  __attribute__ ((deprecated(message)))
+#endif
+#elif defined(__GNUC__) &&  (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
+#define JSONCPP_DEPRECATED(message)  __attribute__ ((deprecated(message)))
+#elif defined(__GNUC__) &&  (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
+#define JSONCPP_DEPRECATED(message)  __attribute__((__deprecated__))
+#endif
+
+#if !defined(JSONCPP_DEPRECATED)
+#define JSONCPP_DEPRECATED(message)
+#endif // if !defined(JSONCPP_DEPRECATED)
+
+namespace Json {
+typedef int Int;
+typedef unsigned int UInt;
+#if defined(JSON_NO_INT64)
+typedef int LargestInt;
+typedef unsigned int LargestUInt;
+#undef JSON_HAS_INT64
+#else                 // if defined(JSON_NO_INT64)
+// For Microsoft Visual use specific types as long long is not supported
+#if defined(_MSC_VER) // Microsoft Visual Studio
+typedef __int64 Int64;
+typedef unsigned __int64 UInt64;
+#else                 // if defined(_MSC_VER) // Other platforms, use long long
+typedef long long int Int64;
+typedef unsigned long long int UInt64;
+#endif // if defined(_MSC_VER)
+typedef Int64 LargestInt;
+typedef UInt64 LargestUInt;
+#define JSON_HAS_INT64
+#endif // if defined(JSON_NO_INT64)
+} // end namespace Json
+
+#endif // JSON_CONFIG_H_INCLUDED

3rdpart/jsoncpp/features.h

+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef CPPTL_JSON_FEATURES_H_INCLUDED
+#define CPPTL_JSON_FEATURES_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "../jsoncpp/forwards.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+
+/** \brief Configuration passed to reader and writer.
+ * This configuration object can be used to force the Reader or Writer
+ * to behave in a standard conforming way.
+ */
+class JSON_API Features {
+public:
+  /** \brief A configuration that allows all features and assumes all strings
+   * are UTF-8.
+   * - C & C++ comments are allowed
+   * - Root object can be any JSON value
+   * - Assumes Value strings are encoded in UTF-8
+   */
+  static Features all();
+
+  /** \brief A configuration that is strictly compatible with the JSON
+   * specification.
+   * - Comments are forbidden.
+   * - Root object must be either an array or an object value.
+   * - Assumes Value strings are encoded in UTF-8
+   */
+  static Features strictMode();
+
+  /** \brief Initialize the configuration like JsonConfig::allFeatures;
+   */
+  Features();
+
+  /// \c true if comments are allowed. Default: \c true.
+  bool allowComments_;
+
+  /// \c true if root must be either an array or an object value. Default: \c
+  /// false.
+  bool strictRoot_;
+
+  /// \c true if dropped null placeholders are allowed. Default: \c false.
+  bool allowDroppedNullPlaceholders_;
+
+  /// \c true if numeric object key are allowed. Default: \c false.
+  bool allowNumericKeys_;
+};
+
+} // namespace Json
+
+#endif // CPPTL_JSON_FEATURES_H_INCLUDED

3rdpart/jsoncpp/forwards.h

+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_FORWARDS_H_INCLUDED
+#define JSON_FORWARDS_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "config.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+
+// writer.h
+class FastWriter;
+class StyledWriter;
+
+// reader.h
+class Reader;
+
+// features.h
+class Features;
+
+// value.h
+typedef unsigned int ArrayIndex;
+class StaticString;
+class Path;
+class PathArgument;
+class Value;
+class ValueIteratorBase;
+class ValueIterator;
+class ValueConstIterator;
+
+} // namespace Json
+
+#endif // JSON_FORWARDS_H_INCLUDED

3rdpart/jsoncpp/json.h

+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_JSON_H_INCLUDED
+#define JSON_JSON_H_INCLUDED
+
+#include "autolink.h"
+#include "features.h"
+#include "reader.h"
+#include "writer.h"
+#include "value.h"
+
+#endif // JSON_JSON_H_INCLUDED

3rdpart/jsoncpp/json_tool.h

+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef LIB_JSONCPP_JSON_TOOL_H_INCLUDED
+#define LIB_JSONCPP_JSON_TOOL_H_INCLUDED
+
+/* This header provides common string manipulation support, such as UTF-8,
+ * portable conversion from/to string...
+ *
+ * It is an internal header that must not be exposed.
+ */
+
+namespace Json {
+
+/// Converts a unicode code-point to UTF-8.
+static inline std::string codePointToUTF8(unsigned int cp) {
+  std::string result;
+
+  // based on description from http://en.wikipedia.org/wiki/UTF-8
+
+  if (cp <= 0x7f) {
+    result.resize(1);
+    result[0] = static_cast<char>(cp);
+  } else if (cp <= 0x7FF) {
+    result.resize(2);
+    result[1] = static_cast<char>(0x80 | (0x3f & cp));
+    result[0] = static_cast<char>(0xC0 | (0x1f & (cp >> 6)));
+  } else if (cp <= 0xFFFF) {
+    result.resize(3);
+    result[2] = static_cast<char>(0x80 | (0x3f & cp));
+    result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
+    result[0] = static_cast<char>(0xE0 | (0xf & (cp >> 12)));
+  } else if (cp <= 0x10FFFF) {
+    result.resize(4);
+    result[3] = static_cast<char>(0x80 | (0x3f & cp));
+    result[2] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
+    result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 12)));
+    result[0] = static_cast<char>(0xF0 | (0x7 & (cp >> 18)));
+  }
+
+  return result;
+}
+
+/// Returns true if ch is a control character (in range [1,31]).
+static inline bool isControlCharacter(char ch) { return ch > 0 && ch <= 0x1F; }
+
+enum {
+  /// Constant that specify the size of the buffer that must be passed to
+  /// uintToString.
+  uintToStringBufferSize = 3 * sizeof(LargestUInt) + 1
+};
+
+// Defines a char buffer for use with uintToString().
+typedef char UIntToStringBuffer[uintToStringBufferSize];
+
+/** Converts an unsigned integer to string.
+ * @param value Unsigned interger to convert to string
+ * @param current Input/Output string buffer.
+ *        Must have at least uintToStringBufferSize chars free.
+ */
+static inline void uintToString(LargestUInt value, char*& current) {
+  *--current = 0;
+  do {
+    *--current = static_cast<signed char>(value % 10U + static_cast<unsigned>('0'));
+    value /= 10;
+  } while (value != 0);
+}
+
+/** Change ',' to '.' everywhere in buffer.
+ *
+ * We had a sophisticated way, but it did not work in WinCE.
+ * @see https://github.com/open-source-parsers/jsoncpp/pull/9
+ */
+static inline void fixNumericLocale(char* begin, char* end) {
+  while (begin < end) {
+    if (*begin == ',') {
+      *begin = '.';
+    }
+    ++begin;
+  }
+}
+
+} // namespace Json {
+
+#endif // LIB_JSONCPP_JSON_TOOL_H_INCLUDED

3rdpart/jsoncpp/json_valueiterator.inl

+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+// included by json_value.cpp
+
+namespace Json {
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class ValueIteratorBase
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+ValueIteratorBase::ValueIteratorBase()
+    : current_(), isNull_(true) {
+}
+
+ValueIteratorBase::ValueIteratorBase(
+    const Value::ObjectValues::iterator& current)
+    : current_(current), isNull_(false) {}
+
+Value& ValueIteratorBase::deref() const {
+  return current_->second;
+}
+
+void ValueIteratorBase::increment() {
+  ++current_;
+}
+
+void ValueIteratorBase::decrement() {
+  --current_;
+}
+
+ValueIteratorBase::difference_type
+ValueIteratorBase::computeDistance(const SelfType& other) const {
+#ifdef JSON_USE_CPPTL_SMALLMAP
+  return other.current_ - current_;
+#else
+  // Iterator for null value are initialized using the default
+  // constructor, which initialize current_ to the default
+  // std::map::iterator. As begin() and end() are two instance
+  // of the default std::map::iterator, they can not be compared.
+  // To allow this, we handle this comparison specifically.
+  if (isNull_ && other.isNull_) {
+    return 0;
+  }
+
+  // Usage of std::distance is not portable (does not compile with Sun Studio 12
+  // RogueWave STL,
+  // which is the one used by default).
+  // Using a portable hand-made version for non random iterator instead:
+  //   return difference_type( std::distance( current_, other.current_ ) );
+  difference_type myDistance = 0;
+  for (Value::ObjectValues::iterator it = current_; it != other.current_;
+       ++it) {
+    ++myDistance;
+  }
+  return myDistance;
+#endif
+}
+
+bool ValueIteratorBase::isEqual(const SelfType& other) const {
+  if (isNull_) {
+    return other.isNull_;
+  }
+  return current_ == other.current_;
+}
+
+void ValueIteratorBase::copy(const SelfType& other) {
+  current_ = other.current_;
+  isNull_ = other.isNull_;
+}
+
+Value ValueIteratorBase::key() const {
+  const Value::CZString czstring = (*current_).first;
+  if (czstring.data()) {
+    if (czstring.isStaticString())
+      return Value(StaticString(czstring.data()));
+    return Value(czstring.data(), czstring.data() + czstring.length());
+  }
+  return Value(czstring.index());
+}
+
+UInt ValueIteratorBase::index() const {
+  const Value::CZString czstring = (*current_).first;
+  if (!czstring.data())
+    return czstring.index();
+  return Value::UInt(-1);
+}
+
+std::string ValueIteratorBase::name() const {
+  char const* keey;
+  char const* end;
+  keey = memberName(&end);
+  if (!keey) return std::string();
+  return std::string(keey, end);
+}
+
+char const* ValueIteratorBase::memberName() const {
+  const char* cname = (*current_).first.data();
+  return cname ? cname : "";
+}
+
+char const* ValueIteratorBase::memberName(char const** end) const {
+  const char* cname = (*current_).first.data();
+  if (!cname) {
+    *end = NULL;
+    return NULL;
+  }
+  *end = cname + (*current_).first.length();
+  return cname;
+}
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class ValueConstIterator
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+ValueConstIterator::ValueConstIterator() {}
+
+ValueConstIterator::ValueConstIterator(
+    const Value::ObjectValues::iterator& current)
+    : ValueIteratorBase(current) {}
+
+ValueConstIterator& ValueConstIterator::
+operator=(const ValueIteratorBase& other) {
+  copy(other);
+  return *this;
+}
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class ValueIterator
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+ValueIterator::ValueIterator() {}
+
+ValueIterator::ValueIterator(const Value::ObjectValues::iterator& current)
+    : ValueIteratorBase(current) {}
+
+ValueIterator::ValueIterator(const ValueConstIterator& other)
+    : ValueIteratorBase(other) {}
+
+ValueIterator::ValueIterator(const ValueIterator& other)
+    : ValueIteratorBase(other) {}
+
+ValueIterator& ValueIterator::operator=(const SelfType& other) {
+  copy(other);
+  return *this;
+}
+
+} // namespace Json

3rdpart/jsoncpp/version.h

+// DO NOT EDIT. This file (and "version") is generated by CMake.
+// Run CMake configure step to update it.
+#ifndef JSON_VERSION_H_INCLUDED
+# define JSON_VERSION_H_INCLUDED
+
+# define JSONCPP_VERSION_STRING "1.6.5"
+# define JSONCPP_VERSION_MAJOR 1
+# define JSONCPP_VERSION_MINOR 6
+# define JSONCPP_VERSION_PATCH 5
+# define JSONCPP_VERSION_QUALIFIER
+# define JSONCPP_VERSION_HEXA ((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) | (JSONCPP_VERSION_PATCH << 8))
+
+#endif // JSON_VERSION_H_INCLUDED

3rdpart/jsoncpp/version.h.in

+// DO NOT EDIT. This file (and "version") is generated by CMake.
+// Run CMake configure step to update it.
+#ifndef JSON_VERSION_H_INCLUDED
+# define JSON_VERSION_H_INCLUDED
+
+# define JSONCPP_VERSION_STRING "@JSONCPP_VERSION@"
+# define JSONCPP_VERSION_MAJOR @JSONCPP_VERSION_MAJOR@
+# define JSONCPP_VERSION_MINOR @JSONCPP_VERSION_MINOR@
+# define JSONCPP_VERSION_PATCH @JSONCPP_VERSION_PATCH@
+# define JSONCPP_VERSION_QUALIFIER
+# define JSONCPP_VERSION_HEXA ((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) | (JSONCPP_VERSION_PATCH << 8))
+
+#endif // JSON_VERSION_H_INCLUDED

CMakeLists.txt

@@ -113,7 +113,12 @@ endif ()
 #测试程序
 add_subdirectory(tests)
 
-
+#主服务器
+if (CMAKE_SYSTEM_NAME MATCHES "Linux")
+    add_subdirectory(server)
+elseif (CMAKE_SYSTEM_NAME MATCHES "Darwin")
+    add_subdirectory(server)
+endif ()
 
 
 

server/CMakeLists.txt

+include_directories(../3rdpart)
+file(GLOB jsoncpp_src_list ../3rdpart/jsoncpp/*.cpp ../3rdpart/jsoncpp/*.h )
+add_library(jsoncpp STATIC ${jsoncpp_src_list})
+
+file(GLOB MediaServer_src_list ./*.cpp ./*.h)
+add_executable(MediaServer ${MediaServer_src_list})
+target_link_libraries(MediaServer jsoncpp ${LINK_LIB_LIST})
+
+

server/Process.cpp

+//
+// Created by xzl on 2018/5/24.
+//
+#include <unistd.h>
+#include <stdexcept>
+#include <signal.h>
+#include "Util/util.h"
+#include "Util/File.h"
+#include "Util/logger.h"
+#include "Util/uv_errno.h"
+#include "Util/TimeTicker.h"
+#include "Process.h"
+#include "Poller/Timer.h"
+using namespace toolkit;
+
+void Process::run(const string &cmd, const string &log_file_tmp) {
+    kill(2000);
+    _pid = fork();
+    if (_pid < 0) {
+        throw std::runtime_error(StrPrinter << "fork child process falied,err:" << get_uv_errmsg());
+    }
+    if (_pid == 0) {
+        //子进程
+        // ignore the SIGINT and SIGTERM
+        signal(SIGINT, SIG_IGN);
+        signal(SIGTERM, SIG_IGN);
+
+        string log_file ;
+        if(log_file_tmp.empty()){
+            log_file = "/dev/null";
+        }else{
+            log_file = StrPrinter << log_file_tmp << "." << getpid();
+        }
+
+        int log_fd = -1;
+        int flags = O_CREAT | O_WRONLY | O_APPEND;
+        mode_t mode = S_IRWXO | S_IRWXG | S_IRWXU;// S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH;
+        File::createfile_path(log_file.data(), mode);
+        if ((log_fd = ::open(log_file.c_str(), flags, mode)) < 0) {
+            fprintf(stderr, "open log file %s failed:%d(%s)\r\n", log_file.data(), errno, strerror(errno));
+        } else {
+            // dup to stdout and stderr.
+            if (dup2(log_fd, STDOUT_FILENO) < 0) {
+                fprintf(stderr, "dup2 stdout file %s failed:%d(%s)\r\n", log_file.data(), errno, strerror(errno));
+            }
+            if (dup2(log_fd, STDERR_FILENO) < 0) {
+                fprintf(stderr, "dup2 stderr file  %s failed:%d(%s)\r\n", log_file.data(), errno, strerror(errno));
+            }
+            // close log fd
+            ::close(log_fd);
+        }
+        fprintf(stderr, "\r\n\r\n#### pid=%d,cmd=%s #####\r\n\r\n", getpid(), cmd.data());
+
+        // close other fds
+        // TODO: do in right way.
+        for (int i = 3; i < 1024; i++) {
+            ::close(i);
+        }
+
+        auto params = split(cmd, " ");
+        // memory leak in child process, it's ok.
+        char **charpv_params = new char *[params.size() + 1];
+        for (int i = 0; i < (int) params.size(); i++) {
+            std::string &p = params[i];
+            charpv_params[i] = (char *) p.data();
+        }
+        // EOF: NULL
+        charpv_params[params.size()] = NULL;
+
+        // TODO: execv or execvp
+        auto ret = execv(params[0].c_str(), charpv_params);
+        if (ret < 0) {
+            fprintf(stderr, "fork process failed, errno=%d(%s)\r\n", errno, strerror(errno));
+        }
+        exit(ret);
+    }
+
+    InfoL << "start child proces " << _pid;
+}
+
+void Process::kill(int max_delay) {
+    if (_pid <= 0) {
+        return;
+    }
+    if (::kill(_pid, SIGTERM) == -1) {
+        WarnL << "kill process " << _pid << " falied,err:" << get_uv_errmsg();
+    } else {
+        //等待子进程退出
+        auto pid = _pid;
+        EventPollerPool::Instance().getPoller()->doDelayTask(max_delay,[pid](){
+            //最多等待２秒，２秒后强制杀掉程序
+            if (waitpid(pid, NULL, WNOHANG) == 0) {
+                ::kill(pid, SIGKILL);
+                WarnL << "force kill process " << pid;
+            }
+            return 0;
+        });
+    }
+    _pid = -1;
+}
+
+Process::~Process() {
+    kill(2000);
+}
+
+Process::Process() {
+}
+
+bool Process::wait(bool block) {
+    if (_pid <= 0) {
+        return false;
+    }
+    int status = 0;
+    pid_t p = waitpid(_pid, &status, block ? 0 : WNOHANG);
+
+    _exit_code = (status & 0xFF00) >> 8;
+    if (p < 0) {
+        WarnL << "waitpid failed, pid=" << _pid << ", err=" << get_uv_errmsg();
+        return false;
+    }
+    if (p > 0) {
+        InfoL << "process terminated, pid=" << _pid << ", exit code=" << _exit_code;
+        return false;
+    }
+
+    //WarnL << "process is running, pid=" << _pid;
+    return true;
+}
+
+int Process::exit_code() {
+    return _exit_code;
+}

server/Process.h

+//
+// Created by xzl on 2018/5/24.
+//
+
+#ifndef IPTV_PROCESS_H
+#define IPTV_PROCESS_H
+
+#include <sys/wait.h>
+#include <sys/fcntl.h>
+#include <string>
+using namespace std;
+
+class Process {
+public:
+    Process();
+    ~Process();
+    void run(const string &cmd,const string &log_file);
+    void kill(int max_delay);
+    bool wait(bool block = true);
+    int exit_code();
+private:
+    pid_t _pid = -1;
+    int _exit_code = 0;
+};
+
+
+#endif //IPTV_PROCESS_H

server/System.h

+//
+// Created by xzl on 2018/9/5.
+//
+
+#ifndef IPTV_BASH_H
+#define IPTV_BASH_H
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <map>
+#include "Util/NoticeCenter.h"
+
+using namespace std;
+using namespace toolkit;
+
+class System {
+public:
+    typedef struct {
+        uint32_t task_total;
+        uint32_t task_running;
+        uint32_t task_sleeping;
+        uint32_t task_stopped;
+
+        uint64_t mem_total;
+        uint64_t mem_free;
+        uint64_t mem_used;
+
+        float cpu_user;
+        float cpu_sys;
+        float cpu_idle;
+    } SystemUsage;
+
+    typedef struct {
+        uint64_t recv_bytes;
+        uint64_t recv_packets;
+        uint64_t snd_bytes;
+        uint64_t snd_packets;
+        string interface;
+    } NetworkUsage;
+
+    typedef struct {
+        uint64_t available;
+        uint64_t used;
+        float used_per;
+        string mounted_on;
+        string filesystem;
+        bool mounted;
+    } DiskUsage;
+
+    typedef struct {
+        uint32_t established;
+        uint32_t syn_recv;
+        uint32_t time_wait;
+        uint32_t close_wait;
+    } TcpUsage;
+
+    static bool getSystemUsage(SystemUsage &usage);
+    static bool getNetworkUsage(vector<NetworkUsage> &usage);
+    static bool getTcpUsage(TcpUsage &usage);
+    static string execute(const string &cmd);
+    static void startDaemon();
+    static void systemSetup();
+
+};
+
+
+#endif //IPTV_BASH_H

server/WebHook.cpp

+#include <sstream>
+#include <unordered_map>
+#include <mutex>
+#include "System.h"
+#include "jsoncpp/json.h"
+#include "Util/logger.h"
+#include "Util/util.h"
+#include "Util/onceToken.h"
+#include "Util/NoticeCenter.h"
+#include "Common/config.h"
+#include "Common/MediaSource.h"
+#include "Http/HttpRequester.h"
+#include "Network/TcpSession.h"
+
+using namespace Json;
+using namespace toolkit;
+using namespace mediakit;
+
+namespace Hook {
+#define HOOK_FIELD "hook."
+
+const char kEnable[] = HOOK_FIELD"enable";
+const char kTimeoutSec[] = HOOK_FIELD"timeoutSec";
+const char kOnPublish[] = HOOK_FIELD"on_publish";
+const char kOnPlay[] = HOOK_FIELD"on_play";
+const char kOnFlowReport[] = HOOK_FIELD"on_flow_report";
+const char kAdminParams[] = HOOK_FIELD"admin_params";
+
+onceToken token([](){
+    mINI::Instance()[kEnable] = false;
+    mINI::Instance()[kTimeoutSec] = 10;
+    mINI::Instance()[kOnPublish] = "http://127.0.0.1/index/hook/on_publish";
+    mINI::Instance()[kOnPlay] = "http://127.0.0.1/index/hook/on_play";
+    mINI::Instance()[kOnFlowReport] = "http://127.0.0.1/index/hook/on_flow_report";
+    mINI::Instance()[kAdminParams] = "token=035c73f7-bb6b-4889-a715-d9eb2d1925cc";
+},nullptr);
+}//namespace Hook
+
+
+static void parse_http_response(const SockException &ex,
+                                const string &status,
+                                const HttpClient::HttpHeader &header,
+                                const string &strRecvBody,
+                                const function<void(const Value &,const string &)> &fun){
+    if(ex){
+        auto errStr = StrPrinter << "[network err]:" << ex.what() << endl;
+        fun(Json::nullValue,errStr);
+        return;
+    }
+    if(status != "200"){
+        auto errStr = StrPrinter << "[bad http status code]:" << status << endl;
+        fun(Json::nullValue,errStr);
+        return;
+    }
+    try {
+        stringstream ss(strRecvBody);
+        Value result;
+        ss >> result;
+        if(result["code"].asInt() != 0) {
+            auto errStr = StrPrinter << "[json code]:" << "code=" << result["code"] << ",msg=" << result["msg"] << endl;
+            fun(Json::nullValue,errStr);
+            return;
+        }
+        fun(result,"");
+    }catch (std::exception &ex){
+        auto errStr = StrPrinter << "[parse json failed]:" << ex.what() << endl;
+        fun(Json::nullValue,errStr);
+    }
+}
+
+static void do_http_hook(const string &url,const Value &body,const function<void(const Value &,const string &)> &fun){
+    GET_CONFIG_AND_REGISTER(float,hook_timeoutSec,Hook::kTimeoutSec);
+    HttpRequester::Ptr requester(new HttpRequester);
+    requester->setMethod("POST");
+    requester->setBody(body.toStyledString());
+    requester->addHeader("Content-Type","application/json; charset=utf-8");
+    std::shared_ptr<Ticker> pTicker(new Ticker);
+    requester->startRequester(url,[url,fun,body,requester,pTicker](const SockException &ex,
+                                                    const string &status,
+                                                    const HttpClient::HttpHeader &header,
+                                                    const string &strRecvBody){
+        onceToken token(nullptr,[&](){
+            const_cast<HttpRequester::Ptr &>(requester).reset();
+        });
+        parse_http_response(ex,status,header,strRecvBody,[&](const Value &obj,const string &err){
+            if(fun){
+                fun(obj,err);
+            }
+            if(!err.empty()) {
+                WarnL << "hook " << url << " " <<pTicker->elapsedTime() << "ms,failed" << err << ":" << body;
+            }else if(pTicker->elapsedTime() > 500){
+                DebugL << "hook " << url << " " <<pTicker->elapsedTime() << "ms,success:" << body;
+            }
+        });
+    },hook_timeoutSec);
+}
+
+static Value make_json(const MediaInfo &args){
+    Value body;
+    body["schema"] = args._schema;
+    body["vhost"] = args._vhost;
+    body["app"] = args._app;
+    body["stream"] = args._streamid;
+    body["params"] = args._param_strs;
+    return body;
+}
+
+
+void installWebHook(){
+    GET_CONFIG_AND_REGISTER(bool,hook_enable,Hook::kEnable);
+    GET_CONFIG_AND_REGISTER(string,hook_publish,Hook::kOnPublish);
+    GET_CONFIG_AND_REGISTER(string,hook_play,Hook::kOnPlay);
+    GET_CONFIG_AND_REGISTER(string,hook_flowreport,Hook::kOnFlowReport);
+    GET_CONFIG_AND_REGISTER(string,hook_adminparams,Hook::kAdminParams);
+
+    NoticeCenter::Instance().addListener(nullptr,Broadcast::kBroadcastRtmpPublish,[](BroadcastRtmpPublishArgs){
+        if(!hook_enable || args._param_strs == hook_adminparams){
+            invoker("");
+            return;
+        }
+        //异步执行该hook api，防止阻塞NoticeCenter
+        Value body = make_json(args);
+        body["ip"] = sender.get_peer_ip();
+        body["port"] = sender.get_peer_port();
+        body["id"] = sender.getIdentifier();
+        EventPollerPool::Instance().getExecutor()->async([body,invoker](){
+            //执行hook
+            do_http_hook(hook_publish,body,[invoker](const Value &obj,const string &err){
+                invoker(err);
+            });
+        });
+    });
+
+    NoticeCenter::Instance().addListener(nullptr,Broadcast::kBroadcastMediaPlayed,[](BroadcastMediaPlayedArgs){
+        if(!hook_enable || args._param_strs == hook_adminparams){
+            invoker("");
+            return;
+        }
+        Value body = make_json(args);
+        body["ip"] = sender.get_peer_ip();
+        body["port"] = sender.get_peer_port();
+        body["id"] = sender.getIdentifier();
+        //异步执行该hook api，防止阻塞NoticeCenter
+        EventPollerPool::Instance().getExecutor()->async([body,invoker](){
+            //执行hook
+            do_http_hook(hook_play,body,[invoker](const Value &obj,const string &err){
+                invoker(err);
+            });
+        });
+    });
+
+    NoticeCenter::Instance().addListener(nullptr,Broadcast::kBroadcastFlowReport,[](BroadcastFlowReportArgs){
+        if(!hook_enable || args._param_strs == hook_adminparams){
+            return;
+        }
+        Value body = make_json(args);
+        body["ip"] = sender.get_peer_ip();
+        body["port"] = sender.get_peer_port();
+        body["id"] = sender.getIdentifier();
+        body["totalBytes"] = (Json::UInt64)totalBytes;
+        body["duration"] = (Json::UInt64)totalDuration;
+
+        //流量统计事件
+        EventPollerPool::Instance().getExecutor()->async([body,totalBytes](){
+            //执行hook
+            do_http_hook(hook_flowreport,body, nullptr);
+        });
+    });
+}
\ No newline at end of file

src/Common/config.cpp

@@ -37,7 +37,7 @@ namespace mediakit {
 
 bool loadIniConfig(const char *ini_path){
     string ini;
-    if(ini_path){
+    if(ini_path && ini_path[0] != '\0'){
         ini = ini_path;
     }else{
         ini = exePath() + ".ini";