Rename service to protocol files.

trunk/configure

@@ -226,8 +226,8 @@ ModuleLibIncs=(${SRS_OBJS_DIR} ${LibSTRoot} ${LibSSLRoot})
 MODULE_FILES=("srs_protocol_amf0" "srs_protocol_io" "srs_rtmp_stack"
         "srs_rtmp_handshake" "srs_protocol_utility" "srs_rtmp_msg_array" "srs_protocol_stream"
         "srs_raw_avc" "srs_rtsp_stack" "srs_http_stack" "srs_protocol_kbps" "srs_protocol_json"
-        "srs_protocol_format" "srs_service_log" "srs_service_st" "srs_service_http_client" "srs_service_http_conn"
-        "srs_service_rtmp_conn" "srs_service_utility" "srs_service_conn")
+        "srs_protocol_format" "srs_protocol_log" "srs_protocol_st" "srs_protocol_http_client"
+        "srs_protocol_http_conn" "srs_protocol_rtmp_conn" "srs_protocol_conn")
 if [[ $SRS_RTC == YES ]]; then
     MODULE_FILES+=("srs_rtc_stun_stack")
     ModuleLibIncs+=(${LibSrtpRoot})

trunk/src/app/srs_app_conn.cpp

@@ -14,7 +14,7 @@ using namespace std;
 #include <srs_kernel_error.hpp>
 #include <srs_app_utility.hpp>
 #include <srs_kernel_utility.hpp>
-#include <srs_service_log.hpp>
+#include <srs_protocol_log.hpp>
 #include <srs_app_log.hpp>
 #include <srs_app_config.hpp>
 #include <srs_core_autofree.hpp>

trunk/src/app/srs_app_conn.hpp

@@ -18,7 +18,7 @@
 #include <srs_app_st.hpp>
 #include <srs_protocol_kbps.hpp>
 #include <srs_app_reload.hpp>
-#include <srs_service_conn.hpp>
+#include <srs_protocol_conn.hpp>
 
 class SrsWallClock;
 

trunk/src/app/srs_app_coworkers.cpp

@@ -14,7 +14,7 @@ using namespace std;
 #include <srs_rtmp_stack.hpp>
 #include <srs_app_config.hpp>
 #include <srs_protocol_utility.hpp>
-#include <srs_service_utility.hpp>
+#include <srs_protocol_utility.hpp>
 #include <srs_kernel_utility.hpp>
 
 SrsCoWorkers* SrsCoWorkers::_instance = NULL;

trunk/src/app/srs_app_edge.cpp

@@ -29,7 +29,7 @@ using namespace std;
 #include <srs_kernel_utility.hpp>
 #include <srs_kernel_balance.hpp>
 #include <srs_app_rtmp_conn.hpp>
-#include <srs_service_http_client.hpp>
+#include <srs_protocol_http_client.hpp>
 #include <srs_app_caster_flv.hpp>
 #include <srs_kernel_flv.hpp>
 #include <srs_kernel_buffer.hpp>

trunk/src/app/srs_app_http_client.hpp

@@ -9,7 +9,7 @@
 
 #include <srs_core.hpp>
 
-#include <srs_service_http_client.hpp>
+#include <srs_protocol_http_client.hpp>
 
 #endif
 

trunk/src/app/srs_app_http_conn.hpp

@@ -13,7 +13,7 @@
 #include <string>
 #include <vector>
 
-#include <srs_service_http_conn.hpp>
+#include <srs_protocol_http_conn.hpp>
 #include <srs_app_reload.hpp>
 #include <srs_kernel_file.hpp>
 #include <srs_app_st.hpp>

trunk/src/app/srs_app_http_static.cpp

@@ -33,11 +33,11 @@ using namespace std;
 #include <srs_app_pithy_print.hpp>
 #include <srs_app_source.hpp>
 #include <srs_app_server.hpp>
-#include <srs_service_utility.hpp>
+#include <srs_protocol_utility.hpp>
 #include <srs_app_http_hooks.hpp>
 #include <srs_app_statistic.hpp>
 #include <srs_app_hybrid.hpp>
-#include <srs_service_log.hpp>
+#include <srs_protocol_log.hpp>
 
 #define SRS_CONTEXT_IN_HLS "hls_ctx"
 

trunk/src/app/srs_app_hybrid.cpp

@@ -9,7 +9,7 @@
 #include <srs_app_server.hpp>
 #include <srs_app_config.hpp>
 #include <srs_kernel_error.hpp>
-#include <srs_service_st.hpp>
+#include <srs_protocol_st.hpp>
 #include <srs_app_utility.hpp>
 
 using namespace std;

trunk/src/app/srs_app_log.hpp

@@ -13,7 +13,7 @@
 #include <string>
 
 #include <srs_app_reload.hpp>
-#include <srs_service_log.hpp>
+#include <srs_protocol_log.hpp>
 
 // For log TAGs.
 #define TAG_MAIN "MAIN"

trunk/src/app/srs_app_rtc_conn.cpp

@@ -32,17 +32,17 @@ using namespace std;
 #include <srs_app_rtc_queue.hpp>
 #include <srs_app_source.hpp>
 #include <srs_app_server.hpp>
-#include <srs_service_utility.hpp>
+#include <srs_protocol_utility.hpp>
 #include <srs_http_stack.hpp>
 #include <srs_app_http_api.hpp>
 #include <srs_app_statistic.hpp>
 #include <srs_app_pithy_print.hpp>
-#include <srs_service_st.hpp>
+#include <srs_protocol_st.hpp>
 #include <srs_app_rtc_server.hpp>
 #include <srs_app_rtc_source.hpp>
 #include <srs_protocol_utility.hpp>
 #include <srs_app_threads.hpp>
-#include <srs_service_log.hpp>
+#include <srs_protocol_log.hpp>
 #include <srs_app_log.hpp>
 #include <srs_app_http_hooks.hpp>
 #include <srs_protocol_kbps.hpp>

trunk/src/app/srs_app_rtc_conn.hpp

@@ -9,7 +9,7 @@
 
 #include <srs_core.hpp>
 #include <srs_app_listener.hpp>
-#include <srs_service_st.hpp>
+#include <srs_protocol_st.hpp>
 #include <srs_kernel_utility.hpp>
 #include <srs_rtmp_stack.hpp>
 #include <srs_app_hybrid.hpp>
@@ -21,7 +21,7 @@
 #include <srs_app_rtc_queue.hpp>
 #include <srs_app_rtc_source.hpp>
 #include <srs_app_rtc_dtls.hpp>
-#include <srs_service_conn.hpp>
+#include <srs_protocol_conn.hpp>
 #include <srs_app_conn.hpp>
 #include <srs_app_async_call.hpp>
 

trunk/src/app/srs_app_rtc_server.cpp

@@ -23,12 +23,12 @@ using namespace std;
 #include <srs_app_server.hpp>
 #include <srs_app_http_api.hpp>
 #include <srs_app_rtc_dtls.hpp>
-#include <srs_service_utility.hpp>
+#include <srs_protocol_utility.hpp>
 #include <srs_protocol_utility.hpp>
 #include <srs_app_rtc_source.hpp>
 #include <srs_app_rtc_api.hpp>
 #include <srs_protocol_utility.hpp>
-#include <srs_service_log.hpp>
+#include <srs_protocol_log.hpp>
 
 extern SrsPps* _srs_pps_rpkts;
 SrsPps* _srs_pps_rstuns = NULL;

trunk/src/app/srs_app_rtc_source.hpp

@@ -17,7 +17,7 @@
 #include <map>
 
 #include <srs_app_rtc_sdp.hpp>
-#include <srs_service_st.hpp>
+#include <srs_protocol_st.hpp>
 #include <srs_app_source.hpp>
 #include <srs_kernel_rtc_rtp.hpp>
 

trunk/src/app/srs_app_rtmp_conn.hpp

@@ -15,7 +15,7 @@
 #include <srs_app_conn.hpp>
 #include <srs_app_reload.hpp>
 #include <srs_rtmp_stack.hpp>
-#include <srs_service_rtmp_conn.hpp>
+#include <srs_protocol_rtmp_conn.hpp>
 
 class SrsServer;
 class SrsRtmpServer;

trunk/src/app/srs_app_server.cpp

@@ -34,7 +34,7 @@ using namespace std;
 #include <srs_app_caster_flv.hpp>
 #include <srs_kernel_consts.hpp>
 #include <srs_app_coworkers.hpp>
-#include <srs_service_log.hpp>
+#include <srs_protocol_log.hpp>
 #include <srs_app_latest_version.hpp>
 
 std::string srs_listener_type2string(SrsListenerType type)

trunk/src/app/srs_app_server.hpp

@@ -18,7 +18,7 @@
 #include <srs_app_hls.hpp>
 #include <srs_app_listener.hpp>
 #include <srs_app_conn.hpp>
-#include <srs_service_st.hpp>
+#include <srs_protocol_st.hpp>
 #include <srs_app_hourglass.hpp>
 #include <srs_app_hybrid.hpp>
 

trunk/src/app/srs_app_source.hpp

@@ -16,7 +16,7 @@
 #include <srs_app_st.hpp>
 #include <srs_app_reload.hpp>
 #include <srs_core_performance.hpp>
-#include <srs_service_st.hpp>
+#include <srs_protocol_st.hpp>
 #include <srs_app_hourglass.hpp>
 
 class SrsFormat;

trunk/src/app/srs_app_st.hpp

@@ -13,7 +13,7 @@
 
 #include <srs_kernel_log.hpp>
 #include <srs_kernel_error.hpp>
-#include <srs_service_st.hpp>
+#include <srs_protocol_st.hpp>
 #include <srs_protocol_io.hpp>
 
 class SrsFastCoroutine;

trunk/src/app/srs_app_utility.hpp

@@ -19,7 +19,7 @@
 
 #include <srs_app_st.hpp>
 #include <srs_kernel_log.hpp>
-#include <srs_service_utility.hpp>
+#include <srs_protocol_utility.hpp>
 
 class SrsKbps;
 class SrsBuffer;

trunk/src/main/srs_main_ingest_hls.cpp

@@ -23,12 +23,12 @@ using namespace std;
 #include <srs_raw_avc.hpp>
 #include <srs_rtmp_stack.hpp>
 #include <srs_protocol_utility.hpp>
-#include <srs_service_http_client.hpp>
-#include <srs_service_log.hpp>
-#include <srs_service_st.hpp>
-#include <srs_service_http_conn.hpp>
-#include <srs_service_rtmp_conn.hpp>
-#include <srs_service_utility.hpp>
+#include <srs_protocol_http_client.hpp>
+#include <srs_protocol_log.hpp>
+#include <srs_protocol_st.hpp>
+#include <srs_protocol_http_conn.hpp>
+#include <srs_protocol_rtmp_conn.hpp>
+#include <srs_protocol_utility.hpp>
 #include <srs_app_config.hpp>
 
 // pre-declare

trunk/src/main/srs_main_mp4_parser.cpp

@@ -7,7 +7,7 @@
 #include <srs_core.hpp>
 
 #include <srs_kernel_error.hpp>
-#include <srs_service_log.hpp>
+#include <srs_protocol_log.hpp>
 #include <srs_kernel_mp4.hpp>
 #include <srs_kernel_file.hpp>
 #include <srs_kernel_stream.hpp>

trunk/src/protocol/srs_protocol_conn.cpp

@@ -4,7 +4,7 @@
 // SPDX-License-Identifier: MIT or MulanPSL-2.0
 //
 
-#include <srs_service_conn.hpp>
+#include <srs_protocol_conn.hpp>
 
 ISrsResource::ISrsResource()
 {

trunk/src/protocol/srs_protocol_conn.hpp

@@ -4,8 +4,8 @@
 // SPDX-License-Identifier: MIT or MulanPSL-2.0
 //
 
-#ifndef SRS_SERVICE_CONN_HPP
-#define SRS_SERVICE_CONN_HPP
+#ifndef SRS_PROTOCOL_CONN_HPP
+#define SRS_PROTOCOL_CONN_HPP
 
 #include <srs_core.hpp>
 

trunk/src/protocol/srs_protocol_http_client.cpp

@@ -4,7 +4,7 @@
 // SPDX-License-Identifier: MIT or MulanPSL-2.0
 //
 
-#include <srs_service_http_client.hpp>
+#include <srs_protocol_http_client.hpp>
 
 #include <arpa/inet.h>
 #include <sstream>
@@ -16,7 +16,7 @@ using namespace std;
 #include <srs_kernel_error.hpp>
 #include <srs_kernel_log.hpp>
 #include <srs_core_autofree.hpp>
-#include <srs_service_http_conn.hpp>
+#include <srs_protocol_http_conn.hpp>
 
 // The return value of verify_callback controls the strategy of the further verification process. If verify_callback
 // returns 0, the verification process is immediately stopped with "verification failed" state. If SSL_VERIFY_PEER is

trunk/src/protocol/srs_protocol_http_client.hpp

@@ -4,8 +4,8 @@
 // SPDX-License-Identifier: MIT or MulanPSL-2.0
 //
 
-#ifndef SRS_SERVICE_HTTP_CLIENT_HPP
-#define SRS_SERVICE_HTTP_CLIENT_HPP
+#ifndef SRS_PROTOCOL_HTTP_CLIENT_HPP
+#define SRS_PROTOCOL_HTTP_CLIENT_HPP
 
 #include <srs_core.hpp>
 
@@ -14,7 +14,7 @@
 
 #include <openssl/ssl.h>
 
-#include <srs_service_st.hpp>
+#include <srs_protocol_st.hpp>
 #include <srs_http_stack.hpp>
 
 class SrsHttpUri;

trunk/src/protocol/srs_protocol_http_conn.cpp

@@ -4,7 +4,7 @@
 // SPDX-License-Identifier: MIT or MulanPSL-2.0
 //
 
-#include <srs_service_http_conn.hpp>
+#include <srs_protocol_http_conn.hpp>
 
 #include <stdlib.h>
 #include <sstream>
@@ -13,12 +13,12 @@ using namespace std;
 #include <srs_kernel_log.hpp>
 #include <srs_kernel_error.hpp>
 #include <srs_protocol_stream.hpp>
-#include <srs_service_utility.hpp>
+#include <srs_protocol_utility.hpp>
 #include <srs_kernel_utility.hpp>
 #include <srs_protocol_utility.hpp>
 #include <srs_core_autofree.hpp>
 #include <srs_rtmp_stack.hpp>
-#include <srs_service_conn.hpp>
+#include <srs_protocol_conn.hpp>
 
 SrsHttpParser::SrsHttpParser()
 {

trunk/src/protocol/srs_protocol_http_conn.hpp

@@ -4,8 +4,8 @@
 // SPDX-License-Identifier: MIT or MulanPSL-2.0
 //
 
-#ifndef SRS_SERVICE_HTTP_CONN_HPP
-#define SRS_SERVICE_HTTP_CONN_HPP
+#ifndef SRS_PROTOCOL_HTTP_CONN_HPP
+#define SRS_PROTOCOL_HTTP_CONN_HPP
 
 #include <srs_core.hpp>
 

trunk/src/protocol/srs_protocol_log.cpp

@@ -4,7 +4,7 @@
 // SPDX-License-Identifier: MIT or MulanPSL-2.0
 //
 
-#include <srs_service_log.hpp>
+#include <srs_protocol_log.hpp>
 
 #include <stdarg.h>
 #include <sys/time.h>

trunk/src/protocol/srs_protocol_log.hpp

@@ -4,15 +4,15 @@
 // SPDX-License-Identifier: MIT or MulanPSL-2.0
 //
 
-#ifndef SRS_SERVICE_LOG_HPP
-#define SRS_SERVICE_LOG_HPP
+#ifndef SRS_PROTOCOL_LOG_HPP
+#define SRS_PROTOCOL_LOG_HPP
 
 #include <srs_core.hpp>
 
 #include <map>
 #include <string>
 
-#include <srs_service_st.hpp>
+#include <srs_protocol_st.hpp>
 #include <srs_kernel_log.hpp>
 
 // The st thread context, get_id will get the st-thread id,

trunk/src/protocol/srs_protocol_rtmp_conn.cpp

@@ -4,17 +4,17 @@
 // SPDX-License-Identifier: MIT or MulanPSL-2.0
 //
 
-#include <srs_service_rtmp_conn.hpp>
+#include <srs_protocol_rtmp_conn.hpp>
 
 #include <unistd.h>
 using namespace std;
 
 #include <srs_protocol_kbps.hpp>
 #include <srs_rtmp_stack.hpp>
-#include <srs_service_st.hpp>
+#include <srs_protocol_st.hpp>
 #include <srs_protocol_amf0.hpp>
 #include <srs_protocol_utility.hpp>
-#include <srs_service_utility.hpp>
+#include <srs_protocol_utility.hpp>
 
 SrsBasicRtmpClient::SrsBasicRtmpClient(string r, srs_utime_t ctm, srs_utime_t stm)
 {

trunk/src/protocol/srs_protocol_rtmp_conn.hpp

@@ -4,8 +4,8 @@
 // SPDX-License-Identifier: MIT or MulanPSL-2.0
 //
 
-#ifndef SRS_SERVICE_RTMP_CONN_HPP
-#define SRS_SERVICE_RTMP_CONN_HPP
+#ifndef SRS_PROTOCOL_RTMP_CONN_HPP
+#define SRS_PROTOCOL_RTMP_CONN_HPP
 
 #include <srs_core.hpp>
 

trunk/src/protocol/srs_protocol_st.cpp

@@ -4,7 +4,7 @@
 // SPDX-License-Identifier: MIT or MulanPSL-2.0
 //
 
-#include <srs_service_st.hpp>
+#include <srs_protocol_st.hpp>
 
 #include <st.h>
 #include <fcntl.h>
@@ -15,7 +15,7 @@ using namespace std;
 #include <srs_core_autofree.hpp>
 #include <srs_kernel_error.hpp>
 #include <srs_kernel_log.hpp>
-#include <srs_service_utility.hpp>
+#include <srs_protocol_utility.hpp>
 #include <srs_kernel_utility.hpp>
 
 // nginx also set to 512

trunk/src/protocol/srs_protocol_st.hpp

@@ -4,8 +4,8 @@
 // SPDX-License-Identifier: MIT or MulanPSL-2.0
 //
 
-#ifndef SRS_SERVICE_ST_HPP
-#define SRS_SERVICE_ST_HPP
+#ifndef SRS_PROTOCOL_ST_HPP
+#define SRS_PROTOCOL_ST_HPP
 
 #include <srs_core.hpp>
 

trunk/src/protocol/srs_protocol_utility.cpp

@@ -24,6 +24,24 @@ using namespace std;
 #include <srs_rtmp_stack.hpp>
 #include <srs_protocol_io.hpp>
 
+#include <unistd.h>
+#include <arpa/inet.h>
+#include <net/if.h>
+#include <ifaddrs.h>
+#include <netdb.h>
+#include <math.h>
+#include <stdlib.h>
+#include <map>
+#include <sstream>
+using namespace std;
+
+#include <srs_protocol_st.hpp>
+#include <srs_kernel_error.hpp>
+#include <srs_kernel_consts.hpp>
+#include <srs_kernel_log.hpp>
+#include <srs_kernel_utility.hpp>
+#include <srs_http_stack.hpp>
+
 /**
  * resolve the vhost in query string
  * @pram vhost, update the vhost if query contains the vhost.
@@ -533,3 +551,363 @@ string srs_get_cidr_ipv4(string network_address) {
 
     return ipv4_address;
 }
+
+bool srs_string_is_http(string url)
+{
+    return srs_string_starts_with(url, "http://", "https://");
+}
+
+bool srs_string_is_rtmp(string url)
+{
+    return srs_string_starts_with(url, "rtmp://");
+}
+
+bool srs_is_digit_number(string str)
+{
+    if (str.empty()) {
+        return false;
+    }
+
+    const char* p = str.c_str();
+    const char* p_end = str.data() + str.length();
+    for (; p < p_end; p++) {
+        if (*p != '0') {
+            break;
+        }
+    }
+    if (p == p_end) {
+        return true;
+    }
+
+    int64_t v = ::atoll(p);
+    int64_t powv = (int64_t)pow(10, p_end - p - 1);
+    return  v / powv >= 1 && v / powv <= 9;
+}
+
+// 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.
+static std::map<std::string, bool> _srs_device_ifs;
+
+bool srs_net_device_is_internet(string ifname)
+{
+    srs_info("check ifname=%s", ifname.c_str());
+
+    if (_srs_device_ifs.find(ifname) == _srs_device_ifs.end()) {
+        return false;
+    }
+    return _srs_device_ifs[ifname];
+}
+
+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;
+}
+
+vector<SrsIPAddress*> _srs_system_ips;
+
+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) {
+        srs_warn("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()
+{
+    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();
+
+    // Get the addresses.
+    ifaddrs* ifap;
+    if (getifaddrs(&ifap) == -1) {
+        srs_warn("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);
+            }
+        }
+    }
+
+    srs_trace("%s", ss0.str().c_str());
+    srs_trace("%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;
+}
+
+std::string _public_internet_address;
+
+string srs_get_public_internet_address(bool ipv4_only)
+{
+    if (!_public_internet_address.empty()) {
+        return _public_internet_address;
+    }
+
+    std::vector<SrsIPAddress*>& ips = srs_get_local_ips();
+
+    // find the best match public address.
+    for (int i = 0; i < (int)ips.size(); i++) {
+        SrsIPAddress* ip = ips[i];
+        if (!ip->is_internet) {
+            continue;
+        }
+        if (ipv4_only && !ip->is_ipv4) {
+            continue;
+        }
+
+        srs_warn("use public address as ip: %s, ifname=%s", ip->ip.c_str(), ip->ifname.c_str());
+        _public_internet_address = ip->ip;
+        return ip->ip;
+    }
+
+    // no public address, use private address.
+    for (int i = 0; i < (int)ips.size(); i++) {
+        SrsIPAddress* ip = ips[i];
+        if (ip->is_loopback) {
+            continue;
+        }
+        if (ipv4_only && !ip->is_ipv4) {
+            continue;
+        }
+
+        srs_warn("use private address as ip: %s, ifname=%s", ip->ip.c_str(), ip->ifname.c_str());
+        _public_internet_address = ip->ip;
+        return ip->ip;
+    }
+
+    // Finally, use first whatever kind of address.
+    if (!ips.empty() && _public_internet_address.empty()) {
+        SrsIPAddress* ip = ips[0];
+
+        srs_warn("use first address as ip: %s, ifname=%s", ip->ip.c_str(), ip->ifname.c_str());
+        _public_internet_address = ip->ip;
+        return ip->ip;
+    }
+
+    return "";
+}
+
+string srs_get_original_ip(ISrsHttpMessage* r)
+{
+    SrsHttpHeader* h = r->header();
+
+    string x_forwarded_for = h->get("X-Forwarded-For");
+    if (!x_forwarded_for.empty()) {
+        size_t pos = string::npos;
+        if ((pos = x_forwarded_for.find(",")) == string::npos) {
+            return x_forwarded_for;
+        }
+        return x_forwarded_for.substr(0, pos);
+    }
+
+    string x_real_ip = h->get("X-Real-IP");
+    if (!x_real_ip.empty()) {
+        size_t pos = string::npos;
+        if ((pos = x_real_ip.find(":")) == string::npos) {
+            return x_real_ip;
+        }
+        return x_real_ip.substr(0, pos);
+    }
+
+    return "";
+}
+
+std::string _srs_system_hostname;
+
+string srs_get_system_hostname()
+{
+    if (!_srs_system_hostname.empty()) {
+        return _srs_system_hostname;
+    }
+
+    char buf[256];
+    if (-1 == gethostname(buf, sizeof(buf))) {
+        srs_warn("gethostbyname fail");
+        return "";
+    }
+
+    _srs_system_hostname = std::string(buf);
+    return _srs_system_hostname;
+}
+

trunk/src/protocol/srs_protocol_utility.hpp

@@ -20,6 +20,14 @@
 
 #include <srs_kernel_consts.hpp>
 
+#include <arpa/inet.h>
+#include <string>
+#include <vector>
+
+#include <srs_protocol_st.hpp>
+
+class ISrsHttpMessage;
+
 class SrsMessageHeader;
 class SrsSharedPtrMessage;
 class SrsCommonMessage;
@@ -124,5 +132,50 @@ extern std::string srs_get_cidr_mask(std::string network_address);
 // Get the CIDR (Classless Inter-Domain Routing) IPv4 for a network address.
 extern std::string srs_get_cidr_ipv4(std::string network_address);
 
+// Whether the url is starts with http:// or https://
+extern bool srs_string_is_http(std::string url);
+extern bool srs_string_is_rtmp(std::string url);
+
+// Whether string is digit number
+//      is_digit("0")  === true
+//      is_digit("0000000000")  === true
+//      is_digit("1234567890")  === true
+//      is_digit("0123456789")  === true
+//      is_digit("1234567890a") === false
+//      is_digit("a1234567890") === false
+//      is_digit("10e3") === false
+//      is_digit("!1234567890") === false
+//      is_digit("") === false
+extern bool srs_is_digit_number(std::string str);
+
+// Get local ip, fill to @param ips
+struct SrsIPAddress
+{
+    // The network interface name, such as eth0, en0, eth1.
+    std::string ifname;
+    // The IP v4 or v6 address.
+    std::string ip;
+    // Whether the ip is IPv4 address.
+    bool is_ipv4;
+    // Whether the ip is internet public IP address.
+    bool is_internet;
+    // Whether the ip is loopback, such as 127.0.0.1
+    bool is_loopback;
+};
+extern std::vector<SrsIPAddress*>& srs_get_local_ips();
+
+// Get local public ip, empty string if no public internet address found.
+extern std::string srs_get_public_internet_address(bool ipv4_only = false);
+
+// Detect whether specified device is internet public address.
+extern bool srs_net_device_is_internet(std::string ifname);
+extern bool srs_net_device_is_internet(const sockaddr* addr);
+
+// Get the original ip from query and header by proxy.
+extern std::string srs_get_original_ip(ISrsHttpMessage* r);
+
+// Get hostname
+extern std::string srs_get_system_hostname(void);
+
 #endif
 

trunk/src/protocol/srs_service_utility.cpp

@@ -1,385 +0,0 @@
-//
-// Copyright (c) 2013-2021 The SRS Authors
-//
-// SPDX-License-Identifier: MIT or MulanPSL-2.0
-//
-
-#include <srs_service_utility.hpp>
-
-#include <unistd.h>
-#include <arpa/inet.h>
-#include <net/if.h>
-#include <ifaddrs.h>
-#include <netdb.h>
-#include <math.h>
-#include <stdlib.h>
-#include <map>
-#include <sstream>
-using namespace std;
-
-#include <srs_service_st.hpp>
-#include <srs_kernel_error.hpp>
-#include <srs_kernel_consts.hpp>
-#include <srs_kernel_log.hpp>
-#include <srs_kernel_utility.hpp>
-#include <srs_http_stack.hpp>
-
-bool srs_string_is_http(string url)
-{
-    return srs_string_starts_with(url, "http://", "https://");
-}
-
-bool srs_string_is_rtmp(string url)
-{
-    return srs_string_starts_with(url, "rtmp://");
-}
-
-bool srs_is_digit_number(string str)
-{
-    if (str.empty()) {
-        return false;
-    }
-
-    const char* p = str.c_str();
-    const char* p_end = str.data() + str.length();
-    for (; p < p_end; p++) {
-        if (*p != '0') {
-            break;
-        }
-    }
-    if (p == p_end) {
-        return true;
-    }
-
-    int64_t v = ::atoll(p);
-    int64_t powv = (int64_t)pow(10, p_end - p - 1);
-    return  v / powv >= 1 && v / powv <= 9;
-}
-
-// 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.
-static std::map<std::string, bool> _srs_device_ifs;
-
-bool srs_net_device_is_internet(string ifname)
-{
-    srs_info("check ifname=%s", ifname.c_str());
-    
-    if (_srs_device_ifs.find(ifname) == _srs_device_ifs.end()) {
-        return false;
-    }
-    return _srs_device_ifs[ifname];
-}
-
-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;
-}
-
-vector<SrsIPAddress*> _srs_system_ips;
-
-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) {
-        srs_warn("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()
-{
-    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();
-
-    // Get the addresses.
-    ifaddrs* ifap;
-    if (getifaddrs(&ifap) == -1) {
-        srs_warn("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);
-            }
-        }
-    }
-    
-    srs_trace("%s", ss0.str().c_str());
-    srs_trace("%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;
-}
-
-std::string _public_internet_address;
-
-string srs_get_public_internet_address(bool ipv4_only)
-{
-    if (!_public_internet_address.empty()) {
-        return _public_internet_address;
-    }
-    
-    std::vector<SrsIPAddress*>& ips = srs_get_local_ips();
-    
-    // find the best match public address.
-    for (int i = 0; i < (int)ips.size(); i++) {
-        SrsIPAddress* ip = ips[i];
-        if (!ip->is_internet) {
-            continue;
-        }
-        if (ipv4_only && !ip->is_ipv4) {
-            continue;
-        }
-
-        srs_warn("use public address as ip: %s, ifname=%s", ip->ip.c_str(), ip->ifname.c_str());
-        _public_internet_address = ip->ip;
-        return ip->ip;
-    }
-    
-    // no public address, use private address.
-    for (int i = 0; i < (int)ips.size(); i++) {
-        SrsIPAddress* ip = ips[i];
-        if (ip->is_loopback) {
-            continue;
-        }
-        if (ipv4_only && !ip->is_ipv4) {
-            continue;
-        }
-
-        srs_warn("use private address as ip: %s, ifname=%s", ip->ip.c_str(), ip->ifname.c_str());
-        _public_internet_address = ip->ip;
-        return ip->ip;
-    }
-    
-    // Finally, use first whatever kind of address.
-    if (!ips.empty() && _public_internet_address.empty()) {
-        SrsIPAddress* ip = ips[0];
-
-        srs_warn("use first address as ip: %s, ifname=%s", ip->ip.c_str(), ip->ifname.c_str());
-        _public_internet_address = ip->ip;
-        return ip->ip;
-    }
-    
-    return "";
-}
-
-string srs_get_original_ip(ISrsHttpMessage* r)
-{
-    SrsHttpHeader* h = r->header();
-
-    string x_forwarded_for = h->get("X-Forwarded-For");
-    if (!x_forwarded_for.empty()) {
-        size_t pos = string::npos;
-        if ((pos = x_forwarded_for.find(",")) == string::npos) {
-            return x_forwarded_for;
-        }
-        return x_forwarded_for.substr(0, pos);
-    }
-
-    string x_real_ip = h->get("X-Real-IP");
-    if (!x_real_ip.empty()) {
-        size_t pos = string::npos;
-        if ((pos = x_real_ip.find(":")) == string::npos) {
-            return x_real_ip;
-        }
-        return x_real_ip.substr(0, pos);
-    }
-
-    return "";
-}
-
-
-std::string _srs_system_hostname;
-
-string srs_get_system_hostname()
-{
-    if (!_srs_system_hostname.empty()) {
-        return _srs_system_hostname;
-    }
-
-    char buf[256];
-    if (-1 == gethostname(buf, sizeof(buf))) {
-        srs_warn("gethostbyname fail");
-        return "";
-    }
-
-    _srs_system_hostname = std::string(buf);
-    return _srs_system_hostname;
-}

trunk/src/protocol/srs_service_utility.hpp

@@ -1,66 +0,0 @@
-//
-// Copyright (c) 2013-2021 The SRS Authors
-//
-// SPDX-License-Identifier: MIT or MulanPSL-2.0
-//
-
-#ifndef SRS_SERVICE_UTILITY_HPP
-#define SRS_SERVICE_UTILITY_HPP
-
-#include <srs_core.hpp>
-
-#include <arpa/inet.h>
-#include <string>
-#include <vector>
-
-#include <srs_service_st.hpp>
-
-class ISrsHttpMessage;
-
-// Whether the url is starts with http:// or https://
-extern bool srs_string_is_http(std::string url);
-extern bool srs_string_is_rtmp(std::string url);
-
-// Whether string is digit number
-//      is_digit("0")  === true
-//      is_digit("0000000000")  === true
-//      is_digit("1234567890")  === true
-//      is_digit("0123456789")  === true
-//      is_digit("1234567890a") === false
-//      is_digit("a1234567890") === false
-//      is_digit("10e3") === false
-//      is_digit("!1234567890") === false
-//      is_digit("") === false
-extern bool srs_is_digit_number(std::string str);
-
-// Get local ip, fill to @param ips
-struct SrsIPAddress
-{
-    // The network interface name, such as eth0, en0, eth1.
-    std::string ifname;
-    // The IP v4 or v6 address.
-    std::string ip;
-    // Whether the ip is IPv4 address.
-    bool is_ipv4;
-    // Whether the ip is internet public IP address.
-    bool is_internet;
-    // Whether the ip is loopback, such as 127.0.0.1
-    bool is_loopback;
-};
-extern std::vector<SrsIPAddress*>& srs_get_local_ips();
-
-// Get local public ip, empty string if no public internet address found.
-extern std::string srs_get_public_internet_address(bool ipv4_only = false);
-
-// Detect whether specified device is internet public address.
-extern bool srs_net_device_is_internet(std::string ifname);
-extern bool srs_net_device_is_internet(const sockaddr* addr);
-
-// Get the original ip from query and header by proxy.
-extern std::string srs_get_original_ip(ISrsHttpMessage* r);
-
-// Get hostname
-extern std::string srs_get_system_hostname(void);
-
-#endif
-

trunk/src/utest/srs_utest_app.cpp

@@ -13,7 +13,7 @@ using namespace std;
 #include <srs_app_config.hpp>
 
 #include <srs_app_st.hpp>
-#include <srs_service_conn.hpp>
+#include <srs_protocol_conn.hpp>
 #include <srs_app_conn.hpp>
 
 class MockIDResource : public ISrsResource

trunk/src/utest/srs_utest_config.cpp

@@ -13,7 +13,7 @@ using namespace std;
 #include <srs_app_source.hpp>
 #include <srs_core_performance.hpp>
 #include <srs_kernel_utility.hpp>
-#include <srs_service_st.hpp>
+#include <srs_protocol_st.hpp>
 #include <srs_rtmp_stack.hpp>
 #include <srs_utest_kernel.hpp>
 

trunk/src/utest/srs_utest_http.cpp

@@ -9,14 +9,14 @@
 using namespace std;
 
 #include <srs_http_stack.hpp>
-#include <srs_service_http_conn.hpp>
+#include <srs_protocol_http_conn.hpp>
 #include <srs_utest_protocol.hpp>
 #include <srs_protocol_json.hpp>
 #include <srs_kernel_utility.hpp>
 #include <srs_kernel_file.hpp>
 #include <srs_utest_kernel.hpp>
 #include <srs_app_http_static.hpp>
-#include <srs_service_utility.hpp>
+#include <srs_protocol_utility.hpp>
 #include <srs_core_autofree.hpp>
 
 class MockMSegmentsReader : public ISrsReader

trunk/src/utest/srs_utest_http.hpp

@@ -14,7 +14,7 @@
 
 #include <srs_utest_protocol.hpp>
 #include <srs_http_stack.hpp>
-#include <srs_service_http_conn.hpp>
+#include <srs_protocol_http_conn.hpp>
 
 #include <string>
 using namespace std;

trunk/src/utest/srs_utest_protocol.cpp

@@ -16,7 +16,7 @@ using namespace std;
 #include <srs_app_st.hpp>
 #include <srs_protocol_amf0.hpp>
 #include <srs_rtmp_stack.hpp>
-#include <srs_service_http_conn.hpp>
+#include <srs_protocol_http_conn.hpp>
 
 MockEmptyIO::MockEmptyIO()
 {

trunk/src/utest/srs_utest_rtmp.cpp

@@ -14,7 +14,7 @@
 #include <srs_app_st.hpp>
 #include <srs_protocol_amf0.hpp>
 #include <srs_rtmp_stack.hpp>
-#include <srs_service_http_conn.hpp>
+#include <srs_protocol_http_conn.hpp>
 #include <srs_kernel_buffer.hpp>
 #include <srs_kernel_codec.hpp>
 

trunk/src/utest/srs_utest_service.cpp

@@ -9,19 +9,19 @@ using namespace std;
 
 #include <srs_kernel_error.hpp>
 #include <srs_app_listener.hpp>
-#include <srs_service_st.hpp>
-#include <srs_service_utility.hpp>
+#include <srs_protocol_st.hpp>
+#include <srs_protocol_utility.hpp>
 
-#include <srs_service_st.hpp>
-#include <srs_service_http_conn.hpp>
+#include <srs_protocol_st.hpp>
+#include <srs_protocol_http_conn.hpp>
 #include <srs_rtmp_stack.hpp>
 #include <srs_core_autofree.hpp>
 #include <srs_utest_protocol.hpp>
 #include <srs_utest_http.hpp>
-#include <srs_service_utility.hpp>
-#include <srs_service_http_client.hpp>
-#include <srs_service_rtmp_conn.hpp>
-#include <srs_service_conn.hpp>
+#include <srs_protocol_utility.hpp>
+#include <srs_protocol_http_client.hpp>
+#include <srs_protocol_rtmp_conn.hpp>
+#include <srs_protocol_conn.hpp>
 #include <sys/socket.h>
 #include <netdb.h>
 #include <st.h>

trunk/src/utest/srs_utest_service.hpp

@@ -13,7 +13,7 @@
 #include <srs_utest.hpp>
 
 #include <srs_app_st.hpp>
-#include <srs_service_conn.hpp>
+#include <srs_protocol_conn.hpp>
 
 class MockSrsConnection : public ISrsConnection
 {