Update xfrpc.ini

Signed-off-by: Dengfeng Liu <liudf0716@gmail.com>

.github/workflows/linux.yml

@@ -0,0 +1,28 @@
+name: xfrpc 
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    
+    - name: install other depend lib
+      run: |
+          sudo apt-get update -y
+          sudo apt-get install -y libjson-c-dev
+          sudo apt-get install -y libevent-dev
+          
+    - name: compile xfrpc
+      run: |
+        mkdir build
+        cd build
+        cmake ..
+        make

CMakeLists.txt

@@ -2,6 +2,21 @@ cmake_minimum_required(VERSION 2.6)
 
 project(xfrp C)
 
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")
+
+find_package(LibEvent)
+if(NOT LibEvent_FOUND)
+  message(FATAL_ERROR "libevent2 not found!")
+endif(NOT LibEvent_FOUND)
+
+find_package(OpenSSL)
+if(NOT OPENSSL_FOUND)
+  message(FATAL_ERROR "OpenSSL not found!")
+endif(NOT OPENSSL_FOUND)
+
+find_package(JSON-C REQUIRED)
+include_directories(${JSON-C_INCLUDE_DIR})
+
 set(src_xfrpc
 	main.c
   	client.c

README.md

@@ -1,31 +1,9 @@
-![xfrp](https://github.com/KunTengRom/xfrp/blob/master/logo.png)
+![xfrpc](https://github.com/liudf0716/xfrpc/blob/master/logo.png)
 
-[![Build Status][1]][2]
-[![license][3]][4]
-[![Supported][7]][8]
-[![PRs Welcome][5]][6]
-[![Issue Welcome][9]][10]
-[![OpenWRT][11]][12]
-[![KunTeng][13]][14]
 
-[1]: https://img.shields.io/travis/KunTengRom/xfrp.svg?style=plastic
-[2]: https://travis-ci.org/KunTengRom/xfrp
-[3]: https://img.shields.io/badge/license-GPLV3-brightgreen.svg?style=plastic
-[4]: https://github.com/KunTengRom/xfrp/blob/master/LICENSE
-[5]: https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=plastic
-[6]: https://github.com/KunTengRom/xfrp/pulls
-[7]: https://img.shields.io/badge/XFRPS-Supported-blue.svg?style=plastic
-[8]: https://github.com/KunTengRom/xfrps
-[9]: https://img.shields.io/badge/Issues-welcome-brightgreen.svg?style=plastic
-[10]: https://github.com/KunTengRom/xfrp/issues/new
-[11]: https://img.shields.io/badge/Platform-%20OpenWRT%20%7CLEDE%20-brightgreen.svg?style=plastic
-[12]: https://github.com/KunTengRom/LEDE
-[13]: https://img.shields.io/badge/KunTeng-Inside-blue.svg?style=plastic
-[14]: http://rom.kunteng.org
+## What is xfrpc and why start xfrps
 
-## What is xfrp and why start xfrp
-
-`xfrp` is [xfrps](https://github.com/KunTengRom/xfrp) client implemented by c for [OpenWRT](https://github.com/openwrt/openwrt) and [LEDE](https://github.com/lede-project/source) system
+`xfrpc` is [xfrps](https://github.com/liudf0716/xfrps) client implemented by c for [OpenWRT](https://github.com/openwrt/openwrt) and [LEDE](https://github.com/lede-project/source) system
 
 The motivation to start xfrp project is that we are OpenWRTer, and openwrt usually ran in device which has little ROM and RAM space, however golang always need more space and memory; therefore we start xfrp project.
 
@@ -34,18 +12,26 @@ The motivation to start xfrp project is that we are OpenWRTer, and openwrt usual
 
 xfrp need [libevent](https://github.com/libevent/libevent) [openssl-dev](https://github.com/openssl/openssl) and [json-c](https://github.com/json-c/json-c) support
 
-Before compile xfrp, please install `libevent` `openssl-dev` and `json-c` in your system.
+Before compile xfrp, please install `libevent` and `json-c` in your system.
+
+Install json-c libevent in ubuntu 20.04 LTS
 
 ```shell
-git clone https://github.com/KunTengRom/xfrp.git
+sudo apt-get install -y libjson-c-dev
+sudo apt-get install -y libevent-dev
+```
+
+```shell
+git clone https://github.com/liudf0716/xfrpc.git
 cd xfrp
-cmake .
+mkdir build
+cmake ..
 make
 ```
 
 ## Quick start
 
-**before using xfrp, you should have built the proxy server: [xfrps](https://github.com/KunTengRom/xfrp), It's no difference with frp at usage, but support `FTP` and more embedded-client-friendly for linux.**
+**before using xfrpc, you should have built the proxy server: [xfrps](https://github.com/liudf0716/xfrps), It's no difference with frp at usage, but support `FTP` and more embedded-client-friendly for linux.**
 
 Run in debug mode :
 
@@ -61,7 +47,7 @@ xfrpc -c frpc_mini.ini -d 0
 
 ## FTP support
 
-xfrp support ftp proxy after version [0.07.451](https://github.com/KunTengRom/xfrp/tree/0.07.451). **Hypothesize you have built [xfrps](https://github.com/KunTengRom/xfrp) succeed!**
+xfrpc support ftp proxy after version [0.07.451](https://github.com/liudf0716/xfrpc/tree/0.07.451). **Hypothesize you have built [xfrps](https://github.com/liudf0716/xfrps) succeed!**
 
 Configure ftp in frpc.ini
 
@@ -85,8 +71,6 @@ Use `-p` (PASV Mode) of `ftp` command to connect to proxy ftp server:
 ftp -p 111.112.113.114 30621
 ```
 
-In [Master](https://github.com/KunTengRom/xfrp) version `server_addr` can use domain name intead of IP address in FTP proxy. [Issue #4](https://github.com/KunTengRom/xfrp/issues/4) and [Issue #5](https://github.com/KunTengRom/xfrp/issues/5).
-
 ----
 
 ## Todo list
@@ -97,7 +81,7 @@ In [Master](https://github.com/KunTengRom/xfrp) version `server_addr` can use do
 
 ## How to contribute our project
 
-See [CONTRIBUTING](https://github.com/KunTengRom/xfrp/blob/master/CONTRIBUTING.md) for details on submitting patches and the contribution workflow.
+See [CONTRIBUTING](https://github.com/liudf0716/xfrpc/blob/master/CONTRIBUTING.md) for details on submitting patches and the contribution workflow.
 
 ## Contact
 

client.c

@@ -54,14 +54,14 @@
 #include "zip.h"
 #include "common.h"
 #include "proxy.h"
+#include "utils.h"
 
 #define MAX_OUTPUT (512*1024)
 
 static void drained_writecb(struct bufferevent *bev, void *ctx);
 static void xfrp_event_cb(struct bufferevent *bev, short what, void *ctx);
 
-static void
-xfrp_read_cb(struct bufferevent *bev, void *ctx)
+static void xfrp_read_cb(struct bufferevent *bev, void *ctx)
 {
 	struct proxy *p = (struct proxy *)ctx;
 	struct bufferevent *partner = p?p->bev:NULL;
@@ -89,8 +89,7 @@ xfrp_read_cb(struct bufferevent *bev, void *ctx)
 	}
 }
 
-static void
-drained_writecb(struct bufferevent *bev, void *ctx)
+static void drained_writecb(struct bufferevent *bev, void *ctx)
 {
 	struct proxy *p = (struct proxy *)ctx;
 	struct bufferevent *partner = p?p->bev:NULL;
@@ -103,8 +102,7 @@ drained_writecb(struct bufferevent *bev, void *ctx)
 		bufferevent_enable(partner, EV_READ);
 }
 
-static void
-close_on_finished_writecb(struct bufferevent *bev, void *ctx)
+static void close_on_finished_writecb(struct bufferevent *bev, void *ctx)
 {
 	struct evbuffer *b = bufferevent_get_output(bev);
 
@@ -113,8 +111,7 @@ close_on_finished_writecb(struct bufferevent *bev, void *ctx)
 	}
 }
 
-static void
-xfrp_event_cb(struct bufferevent *bev, short what, void *ctx)
+static void xfrp_event_cb(struct bufferevent *bev, short what, void *ctx)
 {
 	struct proxy *p = (struct proxy *)ctx;
 	struct bufferevent *partner = p?p->bev:NULL;
@@ -145,6 +142,38 @@ xfrp_event_cb(struct bufferevent *bev, short what, void *ctx)
 	}
 }
 
+// return: 0: init succeed; 1: init failed
+// static int init_ftp_data_port(struct proxy_service *ps)
+// {
+// 	struct mycurl_string ret_buf;
+// 	if ( ! mycurl_string_init(&ret_buf)) {
+// 		debug(LOG_ERR, "error: ftp data port buffer init failed!");
+// 		return 1;
+// 	}
+
+// 	char url[1024] = {0};
+// 	struct common_conf *c_conf = get_common_config();
+	
+
+// 	int state_code = 0;
+// 	double down_size = 0;
+// 	int ret = net_visit(url, 
+// 			&ret_buf,
+// 			HTTP_GET,
+// 			NULL,
+// 			60l, 
+// 			&state_code,
+// 			&down_size);
+
+// 	if (ret) {
+// 		debug(LOG_ERR, "error: ftp remote data port init failed by HTTP GET");
+// 		mycurl_string_free(&ret_buf);
+// 		return 1;
+// 	}
+
+// 	return 0;
+// }
+
 int is_ftp_proxy(const struct proxy_service *ps)
 {
 	if (! ps || ! ps->proxy_type)

client.h

@@ -63,6 +63,7 @@ struct proxy_client {
 struct proxy_service {
 	char 	*proxy_name;
 	char 	*proxy_type;
+	char 	*ftp_cfg_proxy_name;
 	int 	use_encryption;
 	int		use_compression;
 

cmake/Modules/CMakeParseArguments.cmake

@@ -0,0 +1,161 @@
+#.rst:
+# CMakeParseArguments
+# -------------------
+#
+#
+#
+# CMAKE_PARSE_ARGUMENTS(<prefix> <options> <one_value_keywords>
+# <multi_value_keywords> args...)
+#
+# CMAKE_PARSE_ARGUMENTS() is intended to be used in macros or functions
+# for parsing the arguments given to that macro or function.  It
+# processes the arguments and defines a set of variables which hold the
+# values of the respective options.
+#
+# The <options> argument contains all options for the respective macro,
+# i.e.  keywords which can be used when calling the macro without any
+# value following, like e.g.  the OPTIONAL keyword of the install()
+# command.
+#
+# The <one_value_keywords> argument contains all keywords for this macro
+# which are followed by one value, like e.g.  DESTINATION keyword of the
+# install() command.
+#
+# The <multi_value_keywords> argument contains all keywords for this
+# macro which can be followed by more than one value, like e.g.  the
+# TARGETS or FILES keywords of the install() command.
+#
+# When done, CMAKE_PARSE_ARGUMENTS() will have defined for each of the
+# keywords listed in <options>, <one_value_keywords> and
+# <multi_value_keywords> a variable composed of the given <prefix>
+# followed by "_" and the name of the respective keyword.  These
+# variables will then hold the respective value from the argument list.
+# For the <options> keywords this will be TRUE or FALSE.
+#
+# All remaining arguments are collected in a variable
+# <prefix>_UNPARSED_ARGUMENTS, this can be checked afterwards to see
+# whether your macro was called with unrecognized parameters.
+#
+# As an example here a my_install() macro, which takes similar arguments
+# as the real install() command:
+#
+# ::
+#
+#    function(MY_INSTALL)
+#      set(options OPTIONAL FAST)
+#      set(oneValueArgs DESTINATION RENAME)
+#      set(multiValueArgs TARGETS CONFIGURATIONS)
+#      cmake_parse_arguments(MY_INSTALL "${options}" "${oneValueArgs}"
+#                            "${multiValueArgs}" ${ARGN} )
+#      ...
+#
+#
+#
+# Assume my_install() has been called like this:
+#
+# ::
+#
+#    my_install(TARGETS foo bar DESTINATION bin OPTIONAL blub)
+#
+#
+#
+# After the cmake_parse_arguments() call the macro will have set the
+# following variables:
+#
+# ::
+#
+#    MY_INSTALL_OPTIONAL = TRUE
+#    MY_INSTALL_FAST = FALSE (this option was not used when calling my_install()
+#    MY_INSTALL_DESTINATION = "bin"
+#    MY_INSTALL_RENAME = "" (was not used)
+#    MY_INSTALL_TARGETS = "foo;bar"
+#    MY_INSTALL_CONFIGURATIONS = "" (was not used)
+#    MY_INSTALL_UNPARSED_ARGUMENTS = "blub" (no value expected after "OPTIONAL"
+#
+#
+#
+# You can then continue and process these variables.
+#
+# Keywords terminate lists of values, e.g.  if directly after a
+# one_value_keyword another recognized keyword follows, this is
+# interpreted as the beginning of the new option.  E.g.
+# my_install(TARGETS foo DESTINATION OPTIONAL) would result in
+# MY_INSTALL_DESTINATION set to "OPTIONAL", but MY_INSTALL_DESTINATION
+# would be empty and MY_INSTALL_OPTIONAL would be set to TRUE therefor.
+
+#=============================================================================
+# Copyright 2010 Alexander Neundorf <neundorf@kde.org>
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+
+if(__CMAKE_PARSE_ARGUMENTS_INCLUDED)
+  return()
+endif()
+set(__CMAKE_PARSE_ARGUMENTS_INCLUDED TRUE)
+
+
+function(CMAKE_PARSE_ARGUMENTS prefix _optionNames _singleArgNames _multiArgNames)
+  # first set all result variables to empty/FALSE
+  foreach(arg_name ${_singleArgNames} ${_multiArgNames})
+    set(${prefix}_${arg_name})
+  endforeach()
+
+  foreach(option ${_optionNames})
+    set(${prefix}_${option} FALSE)
+  endforeach()
+
+  set(${prefix}_UNPARSED_ARGUMENTS)
+
+  set(insideValues FALSE)
+  set(currentArgName)
+
+  # now iterate over all arguments and fill the result variables
+  foreach(currentArg ${ARGN})
+    list(FIND _optionNames "${currentArg}" optionIndex)  # ... then this marks the end of the arguments belonging to this keyword
+    list(FIND _singleArgNames "${currentArg}" singleArgIndex)  # ... then this marks the end of the arguments belonging to this keyword
+    list(FIND _multiArgNames "${currentArg}" multiArgIndex)  # ... then this marks the end of the arguments belonging to this keyword
+
+    if(${optionIndex} EQUAL -1  AND  ${singleArgIndex} EQUAL -1  AND  ${multiArgIndex} EQUAL -1)
+      if(insideValues)
+        if("${insideValues}" STREQUAL "SINGLE")
+          set(${prefix}_${currentArgName} ${currentArg})
+          set(insideValues FALSE)
+        elseif("${insideValues}" STREQUAL "MULTI")
+          list(APPEND ${prefix}_${currentArgName} ${currentArg})
+        endif()
+      else()
+        list(APPEND ${prefix}_UNPARSED_ARGUMENTS ${currentArg})
+      endif()
+    else()
+      if(NOT ${optionIndex} EQUAL -1)
+        set(${prefix}_${currentArg} TRUE)
+        set(insideValues FALSE)
+      elseif(NOT ${singleArgIndex} EQUAL -1)
+        set(currentArgName ${currentArg})
+        set(${prefix}_${currentArgName})
+        set(insideValues "SINGLE")
+      elseif(NOT ${multiArgIndex} EQUAL -1)
+        set(currentArgName ${currentArg})
+        set(${prefix}_${currentArgName})
+        set(insideValues "MULTI")
+      endif()
+    endif()
+
+  endforeach()
+
+  # propagate the result variables to the caller:
+  foreach(arg_name ${_singleArgNames} ${_multiArgNames} ${_optionNames})
+    set(${prefix}_${arg_name}  ${${prefix}_${arg_name}} PARENT_SCOPE)
+  endforeach()
+  set(${prefix}_UNPARSED_ARGUMENTS ${${prefix}_UNPARSED_ARGUMENTS} PARENT_SCOPE)
+
+endfunction()

cmake/Modules/FindJSON-C.cmake

@@ -0,0 +1,21 @@
+# JSON-C_FOUND - true if library and headers were found
+# JSON-C_INCLUDE_DIRS - include directories
+# JSON-C_LIBRARIES - library directories
+
+find_package(PkgConfig)
+pkg_check_modules(PC_JSON-C QUIET json-c)
+
+find_path(JSON-C_INCLUDE_DIR json.h
+	HINTS ${PC_JSON-C_INCLUDEDIR} ${PC_JSON-C_INCLUDE_DIRS} PATH_SUFFIXES json-c json)
+
+find_library(JSON-C_LIBRARY NAMES json-c libjson-c
+	HINTS ${PC_JSON-C_LIBDIR} ${PC_JSON-C_LIBRARY_DIRS})
+
+set(JSON-C_LIBRARIES ${JSON-C_LIBRARY})
+set(JSON-C_INCLUDE_DIRS ${JSON-C_INCLUDE_DIR})
+
+include(FindPackageHandleStandardArgs)
+
+find_package_handle_standard_args(JSON-C DEFAULT_MSG JSON-C_LIBRARY JSON-C_INCLUDE_DIR)
+
+mark_as_advanced(JSON-C_INCLUDE_DIR JSON-C_LIBRARY)

cmake/Modules/FindLibEvent.cmake

@@ -0,0 +1,39 @@
+# - Find LibEvent (a cross event library)
+# This module defines
+# LIBEVENT_INCLUDE_DIR, where to find LibEvent headers
+# LIBEVENT_LIB, LibEvent libraries
+# LibEvent_FOUND, If false, do not try to use libevent
+
+set(LibEvent_EXTRA_PREFIXES /usr/local /opt/local "$ENV{HOME}")
+foreach(prefix ${LibEvent_EXTRA_PREFIXES})
+  list(APPEND LibEvent_INCLUDE_PATHS "${prefix}/include")
+  list(APPEND LibEvent_LIB_PATHS "${prefix}/lib")
+endforeach()
+
+FIND_PATH(LIBEVENT_INCLUDE_DIR event.h PATHS ${LibEvent_INCLUDE_PATHS})
+
+FIND_LIBRARY(LIBEVENT_LIB          NAMES event          PATHS ${LibEvent_LIB_PATHS})
+FIND_LIBRARY(LIBEVENT_CORE_LIB     NAMES event_core     PATHS ${LibEvent_LIB_PATHS})
+FIND_LIBRARY(LIBEVENT_PTHREADS_LIB NAMES event_pthreads PATHS ${LibEvent_LIB_PATHS})
+FIND_LIBRARY(LIBEVENT_EXTRA_LIB    NAMES event_extra    PATHS ${LibEvent_LIB_PATHS})
+FIND_LIBRARY(LIBEVENT_OPENSSL_LIB  NAMES event_openssl  PATHS ${LibEvent_LIB_PATHS})
+
+if (LIBEVENT_LIB AND LIBEVENT_INCLUDE_DIR)
+  set(LibEvent_FOUND TRUE)
+  set(LIBEVENT_LIB ${LIBEVENT_LIB})
+else ()
+  set(LibEvent_FOUND FALSE)
+endif ()
+
+if (LibEvent_FOUND)
+  if (NOT LibEvent_FIND_QUIETLY)
+    message(STATUS "Found libevent: ${LIBEVENT_LIB}")
+  endif ()
+else ()
+  if (LibEvent_FIND_REQUIRED)
+    message(FATAL_ERROR "Could NOT find libevent.")
+  endif ()
+  message(STATUS "libevent NOT found.")
+endif ()
+
+MARK_AS_ADVANCED(LIBEVENT_INCLUDE_DIR LIBEVENT_LIB LIBEVENT_PTHREADS_LIB LIBEVENT_OPENSSL_LIB LIBEVENT_CORE_LIB LIBEVENT_EXTRA_LIB)

cmake/Modules/FindOpenSSL.cmake

@@ -0,0 +1,340 @@
+#.rst:
+# FindOpenSSL
+# -----------
+#
+# Try to find the OpenSSL encryption library
+#
+# Once done this will define
+#
+# ::
+#
+#   OPENSSL_ROOT_DIR - Set this variable to the root installation of OpenSSL
+#
+#
+#
+# Read-Only variables:
+#
+# ::
+#
+#   OPENSSL_FOUND - System has the OpenSSL library
+#   OPENSSL_INCLUDE_DIR - The OpenSSL include directory
+#   OPENSSL_CRYPTO_LIBRARY - The OpenSSL crypto library
+#   OPENSSL_SSL_LIBRARY - The OpenSSL SSL library
+#   OPENSSL_LIBRARIES - All OpenSSL libraries
+#   OPENSSL_VERSION - This is set to $major.$minor.$revision$patch (eg. 0.9.8s)
+
+#=============================================================================
+# Copyright 2006-2009 Kitware, Inc.
+# Copyright 2006 Alexander Neundorf <neundorf@kde.org>
+# Copyright 2009-2011 Mathieu Malaterre <mathieu.malaterre@gmail.com>
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+if (UNIX)
+  find_package(PkgConfig QUIET)
+  pkg_check_modules(_OPENSSL QUIET openssl)
+endif ()
+
+if (WIN32)
+  # http://www.slproweb.com/products/Win32OpenSSL.html
+  set(_OPENSSL_ROOT_HINTS
+    ${OPENSSL_ROOT_DIR}
+    "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\OpenSSL (32-bit)_is1;Inno Setup: App Path]"
+    "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\OpenSSL (64-bit)_is1;Inno Setup: App Path]"
+    ENV OPENSSL_ROOT_DIR
+    )
+  file(TO_CMAKE_PATH "$ENV{PROGRAMFILES}" _programfiles)
+  set(_OPENSSL_ROOT_PATHS
+    "${_programfiles}/OpenSSL"
+    "${_programfiles}/OpenSSL-Win32"
+    "${_programfiles}/OpenSSL-Win64"
+    "C:/OpenSSL/"
+    "C:/OpenSSL-Win32/"
+    "C:/OpenSSL-Win64/"
+    )
+  unset(_programfiles)
+else ()
+  set(_OPENSSL_ROOT_HINTS
+    ${OPENSSL_ROOT_DIR}
+    ENV OPENSSL_ROOT_DIR
+    )
+endif ()
+
+set(_OPENSSL_ROOT_HINTS_AND_PATHS
+    HINTS ${_OPENSSL_ROOT_HINTS}
+    PATHS ${_OPENSSL_ROOT_PATHS}
+    )
+
+find_path(OPENSSL_INCLUDE_DIR
+  NAMES
+    openssl/ssl.h
+  ${_OPENSSL_ROOT_HINTS_AND_PATHS}
+  HINTS
+    ${_OPENSSL_INCLUDEDIR}
+  PATH_SUFFIXES
+    include
+)
+
+if(WIN32 AND NOT CYGWIN)
+  if(MSVC)
+    # /MD and /MDd are the standard values - if someone wants to use
+    # others, the libnames have to change here too
+    # use also ssl and ssleay32 in debug as fallback for openssl < 0.9.8b
+    # TODO: handle /MT and static lib
+    # In Visual C++ naming convention each of these four kinds of Windows libraries has it's standard suffix:
+    #   * MD for dynamic-release
+    #   * MDd for dynamic-debug
+    #   * MT for static-release
+    #   * MTd for static-debug
+
+    # Implementation details:
+    # We are using the libraries located in the VC subdir instead of the parent directory eventhough :
+    # libeay32MD.lib is identical to ../libeay32.lib, and
+    # ssleay32MD.lib is identical to ../ssleay32.lib
+    find_library(LIB_EAY_DEBUG
+      NAMES
+        libeay32MDd
+        libeay32d
+      ${_OPENSSL_ROOT_HINTS_AND_PATHS}
+      PATH_SUFFIXES
+        "lib"
+        "VC"
+        "lib/VC"
+    )
+
+    find_library(LIB_EAY_RELEASE
+      NAMES
+        libeay32MD
+        libeay32
+      ${_OPENSSL_ROOT_HINTS_AND_PATHS}
+      PATH_SUFFIXES
+        "lib"
+        "VC"
+        "lib/VC"
+    )
+
+    find_library(SSL_EAY_DEBUG
+      NAMES
+        ssleay32MDd
+        ssleay32d
+      ${_OPENSSL_ROOT_HINTS_AND_PATHS}
+      PATH_SUFFIXES
+        "lib"
+        "VC"
+        "lib/VC"
+    )
+
+    find_library(SSL_EAY_RELEASE
+      NAMES
+        ssleay32MD
+        ssleay32
+        ssl
+      ${_OPENSSL_ROOT_HINTS_AND_PATHS}
+      PATH_SUFFIXES
+        "lib"
+        "VC"
+        "lib/VC"
+    )
+
+    set(LIB_EAY_LIBRARY_DEBUG "${LIB_EAY_DEBUG}")
+    set(LIB_EAY_LIBRARY_RELEASE "${LIB_EAY_RELEASE}")
+    set(SSL_EAY_LIBRARY_DEBUG "${SSL_EAY_DEBUG}")
+    set(SSL_EAY_LIBRARY_RELEASE "${SSL_EAY_RELEASE}")
+
+    include(${CMAKE_CURRENT_LIST_DIR}/SelectLibraryConfigurations.cmake)
+    select_library_configurations(LIB_EAY)
+    select_library_configurations(SSL_EAY)
+
+    mark_as_advanced(LIB_EAY_LIBRARY_DEBUG LIB_EAY_LIBRARY_RELEASE
+                     SSL_EAY_LIBRARY_DEBUG SSL_EAY_LIBRARY_RELEASE)
+    set( OPENSSL_SSL_LIBRARY ${SSL_EAY_LIBRARY} )
+    set( OPENSSL_CRYPTO_LIBRARY ${LIB_EAY_LIBRARY} )
+    set( OPENSSL_LIBRARIES ${SSL_EAY_LIBRARY} ${LIB_EAY_LIBRARY} )
+  elseif(MINGW)
+    # same player, for MinGW
+    set(LIB_EAY_NAMES libeay32)
+    set(SSL_EAY_NAMES ssleay32)
+    if(CMAKE_CROSSCOMPILING)
+      list(APPEND LIB_EAY_NAMES crypto)
+      list(APPEND SSL_EAY_NAMES ssl)
+    endif()
+    find_library(LIB_EAY
+      NAMES
+        ${LIB_EAY_NAMES}
+      ${_OPENSSL_ROOT_HINTS_AND_PATHS}
+      PATH_SUFFIXES
+        "lib"
+        "lib/MinGW"
+    )
+
+    find_library(SSL_EAY
+      NAMES
+        ${SSL_EAY_NAMES}
+      ${_OPENSSL_ROOT_HINTS_AND_PATHS}
+      PATH_SUFFIXES
+        "lib"
+        "lib/MinGW"
+    )
+
+    mark_as_advanced(SSL_EAY LIB_EAY)
+    set( OPENSSL_SSL_LIBRARY ${SSL_EAY} )
+    set( OPENSSL_CRYPTO_LIBRARY ${LIB_EAY} )
+    set( OPENSSL_LIBRARIES ${SSL_EAY} ${LIB_EAY} )
+    unset(LIB_EAY_NAMES)
+    unset(SSL_EAY_NAMES)
+  else()
+    # Not sure what to pick for -say- intel, let's use the toplevel ones and hope someone report issues:
+    find_library(LIB_EAY
+      NAMES
+        libeay32
+      ${_OPENSSL_ROOT_HINTS_AND_PATHS}
+      HINTS
+        ${_OPENSSL_LIBDIR}
+      PATH_SUFFIXES
+        lib
+    )
+
+    find_library(SSL_EAY
+      NAMES
+        ssleay32
+      ${_OPENSSL_ROOT_HINTS_AND_PATHS}
+      HINTS
+        ${_OPENSSL_LIBDIR}
+      PATH_SUFFIXES
+        lib
+    )
+
+    mark_as_advanced(SSL_EAY LIB_EAY)
+    set( OPENSSL_SSL_LIBRARY ${SSL_EAY} )
+    set( OPENSSL_CRYPTO_LIBRARY ${LIB_EAY} )
+    set( OPENSSL_LIBRARIES ${SSL_EAY} ${LIB_EAY} )
+  endif()
+else()
+
+  find_library(OPENSSL_SSL_LIBRARY
+    NAMES
+      ssl
+      ssleay32
+      ssleay32MD
+    ${_OPENSSL_ROOT_HINTS_AND_PATHS}
+    HINTS
+      ${_OPENSSL_LIBDIR}
+    PATH_SUFFIXES
+      lib
+  )
+
+  find_library(OPENSSL_CRYPTO_LIBRARY
+    NAMES
+      crypto
+    ${_OPENSSL_ROOT_HINTS_AND_PATHS}
+    HINTS
+      ${_OPENSSL_LIBDIR}
+    PATH_SUFFIXES
+      lib
+  )
+
+  mark_as_advanced(OPENSSL_CRYPTO_LIBRARY OPENSSL_SSL_LIBRARY)
+
+  # compat defines
+  set(OPENSSL_SSL_LIBRARIES ${OPENSSL_SSL_LIBRARY})
+  set(OPENSSL_CRYPTO_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY})
+
+  set(OPENSSL_LIBRARIES ${OPENSSL_SSL_LIBRARY} ${OPENSSL_CRYPTO_LIBRARY})
+
+endif()
+
+function(from_hex HEX DEC)
+  string(TOUPPER "${HEX}" HEX)
+  set(_res 0)
+  string(LENGTH "${HEX}" _strlen)
+
+  while (_strlen GREATER 0)
+    math(EXPR _res "${_res} * 16")
+    string(SUBSTRING "${HEX}" 0 1 NIBBLE)
+    string(SUBSTRING "${HEX}" 1 -1 HEX)
+    if (NIBBLE STREQUAL "A")
+      math(EXPR _res "${_res} + 10")
+    elseif (NIBBLE STREQUAL "B")
+      math(EXPR _res "${_res} + 11")
+    elseif (NIBBLE STREQUAL "C")
+      math(EXPR _res "${_res} + 12")
+    elseif (NIBBLE STREQUAL "D")
+      math(EXPR _res "${_res} + 13")
+    elseif (NIBBLE STREQUAL "E")
+      math(EXPR _res "${_res} + 14")
+    elseif (NIBBLE STREQUAL "F")
+      math(EXPR _res "${_res} + 15")
+    else()
+      math(EXPR _res "${_res} + ${NIBBLE}")
+    endif()
+
+    string(LENGTH "${HEX}" _strlen)
+  endwhile()
+
+  set(${DEC} ${_res} PARENT_SCOPE)
+endfunction()
+
+if (OPENSSL_INCLUDE_DIR)
+  if(OPENSSL_INCLUDE_DIR AND EXISTS "${OPENSSL_INCLUDE_DIR}/openssl/opensslv.h")
+    file(STRINGS "${OPENSSL_INCLUDE_DIR}/openssl/opensslv.h" openssl_version_str
+         REGEX "^# *define[\t ]+OPENSSL_VERSION_NUMBER[\t ]+0x([0-9a-fA-F])+.*")
+
+    # The version number is encoded as 0xMNNFFPPS: major minor fix patch status
+    # The status gives if this is a developer or prerelease and is ignored here.
+    # Major, minor, and fix directly translate into the version numbers shown in
+    # the string. The patch field translates to the single character suffix that
+    # indicates the bug fix state, which 00 -> nothing, 01 -> a, 02 -> b and so
+    # on.
+
+    string(REGEX REPLACE "^.*OPENSSL_VERSION_NUMBER[\t ]+0x([0-9a-fA-F])([0-9a-fA-F][0-9a-fA-F])([0-9a-fA-F][0-9a-fA-F])([0-9a-fA-F][0-9a-fA-F])([0-9a-fA-F]).*$"
+           "\\1;\\2;\\3;\\4;\\5" OPENSSL_VERSION_LIST "${openssl_version_str}")
+    list(GET OPENSSL_VERSION_LIST 0 OPENSSL_VERSION_MAJOR)
+    list(GET OPENSSL_VERSION_LIST 1 OPENSSL_VERSION_MINOR)
+    from_hex("${OPENSSL_VERSION_MINOR}" OPENSSL_VERSION_MINOR)
+    list(GET OPENSSL_VERSION_LIST 2 OPENSSL_VERSION_FIX)
+    from_hex("${OPENSSL_VERSION_FIX}" OPENSSL_VERSION_FIX)
+    list(GET OPENSSL_VERSION_LIST 3 OPENSSL_VERSION_PATCH)
+
+    if (NOT OPENSSL_VERSION_PATCH STREQUAL "00")
+      from_hex("${OPENSSL_VERSION_PATCH}" _tmp)
+      # 96 is the ASCII code of 'a' minus 1
+      math(EXPR OPENSSL_VERSION_PATCH_ASCII "${_tmp} + 96")
+      unset(_tmp)
+      # Once anyone knows how OpenSSL would call the patch versions beyond 'z'
+      # this should be updated to handle that, too. This has not happened yet
+      # so it is simply ignored here for now.
+      string(ASCII "${OPENSSL_VERSION_PATCH_ASCII}" OPENSSL_VERSION_PATCH_STRING)
+    endif ()
+
+    set(OPENSSL_VERSION "${OPENSSL_VERSION_MAJOR}.${OPENSSL_VERSION_MINOR}.${OPENSSL_VERSION_FIX}${OPENSSL_VERSION_PATCH_STRING}")
+  endif ()
+endif ()
+
+include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
+
+if (OPENSSL_VERSION)
+  find_package_handle_standard_args(OpenSSL
+    REQUIRED_VARS
+      OPENSSL_LIBRARIES
+      OPENSSL_INCLUDE_DIR
+    VERSION_VAR
+      OPENSSL_VERSION
+    FAIL_MESSAGE
+      "Could NOT find OpenSSL, try to set the path to OpenSSL root folder in the system variable OPENSSL_ROOT_DIR"
+  )
+else ()
+  find_package_handle_standard_args(OpenSSL "Could NOT find OpenSSL, try to set the path to OpenSSL root folder in the system variable OPENSSL_ROOT_DIR"
+    OPENSSL_LIBRARIES
+    OPENSSL_INCLUDE_DIR
+  )
+endif ()
+
+mark_as_advanced(OPENSSL_INCLUDE_DIR OPENSSL_LIBRARIES)

cmake/Modules/FindPackageHandleStandardArgs.cmake

@@ -0,0 +1,382 @@
+#.rst:
+# FindPackageHandleStandardArgs
+# -----------------------------
+#
+#
+#
+# FIND_PACKAGE_HANDLE_STANDARD_ARGS(<name> ...  )
+#
+# This function is intended to be used in FindXXX.cmake modules files.
+# It handles the REQUIRED, QUIET and version-related arguments to
+# find_package().  It also sets the <packagename>_FOUND variable.  The
+# package is considered found if all variables <var1>...  listed contain
+# valid results, e.g.  valid filepaths.
+#
+# There are two modes of this function.  The first argument in both
+# modes is the name of the Find-module where it is called (in original
+# casing).
+#
+# The first simple mode looks like this:
+#
+# ::
+#
+#     FIND_PACKAGE_HANDLE_STANDARD_ARGS(<name>
+#       (DEFAULT_MSG|"Custom failure message") <var1>...<varN> )
+#
+# If the variables <var1> to <varN> are all valid, then
+# <UPPERCASED_NAME>_FOUND will be set to TRUE.  If DEFAULT_MSG is given
+# as second argument, then the function will generate itself useful
+# success and error messages.  You can also supply a custom error
+# message for the failure case.  This is not recommended.
+#
+# The second mode is more powerful and also supports version checking:
+#
+# ::
+#
+#     FIND_PACKAGE_HANDLE_STANDARD_ARGS(<NAME>
+#       [FOUND_VAR <resultVar>]
+#       [REQUIRED_VARS <var1>...<varN>]
+#       [VERSION_VAR   <versionvar>]
+#       [HANDLE_COMPONENTS]
+#       [CONFIG_MODE]
+#       [FAIL_MESSAGE "Custom failure message"] )
+#
+# In this mode, the name of the result-variable can be set either to
+# either <UPPERCASED_NAME>_FOUND or <OriginalCase_Name>_FOUND using the
+# FOUND_VAR option.  Other names for the result-variable are not
+# allowed.  So for a Find-module named FindFooBar.cmake, the two
+# possible names are FooBar_FOUND and FOOBAR_FOUND.  It is recommended
+# to use the original case version.  If the FOUND_VAR option is not
+# used, the default is <UPPERCASED_NAME>_FOUND.
+#
+# As in the simple mode, if <var1> through <varN> are all valid,
+# <packagename>_FOUND will be set to TRUE.  After REQUIRED_VARS the
+# variables which are required for this package are listed.  Following
+# VERSION_VAR the name of the variable can be specified which holds the
+# version of the package which has been found.  If this is done, this
+# version will be checked against the (potentially) specified required
+# version used in the find_package() call.  The EXACT keyword is also
+# handled.  The default messages include information about the required
+# version and the version which has been actually found, both if the
+# version is ok or not.  If the package supports components, use the
+# HANDLE_COMPONENTS option to enable handling them.  In this case,
+# find_package_handle_standard_args() will report which components have
+# been found and which are missing, and the <packagename>_FOUND variable
+# will be set to FALSE if any of the required components (i.e.  not the
+# ones listed after OPTIONAL_COMPONENTS) are missing.  Use the option
+# CONFIG_MODE if your FindXXX.cmake module is a wrapper for a
+# find_package(...  NO_MODULE) call.  In this case VERSION_VAR will be
+# set to <NAME>_VERSION and the macro will automatically check whether
+# the Config module was found.  Via FAIL_MESSAGE a custom failure
+# message can be specified, if this is not used, the default message
+# will be displayed.
+#
+# Example for mode 1:
+#
+# ::
+#
+#     find_package_handle_standard_args(LibXml2  DEFAULT_MSG
+#       LIBXML2_LIBRARY LIBXML2_INCLUDE_DIR)
+#
+#
+#
+# LibXml2 is considered to be found, if both LIBXML2_LIBRARY and
+# LIBXML2_INCLUDE_DIR are valid.  Then also LIBXML2_FOUND is set to
+# TRUE.  If it is not found and REQUIRED was used, it fails with
+# FATAL_ERROR, independent whether QUIET was used or not.  If it is
+# found, success will be reported, including the content of <var1>.  On
+# repeated Cmake runs, the same message won't be printed again.
+#
+# Example for mode 2:
+#
+# ::
+#
+#     find_package_handle_standard_args(LibXslt
+#       FOUND_VAR LibXslt_FOUND
+#       REQUIRED_VARS LibXslt_LIBRARIES LibXslt_INCLUDE_DIRS
+#       VERSION_VAR LibXslt_VERSION_STRING)
+#
+# In this case, LibXslt is considered to be found if the variable(s)
+# listed after REQUIRED_VAR are all valid, i.e.  LibXslt_LIBRARIES and
+# LibXslt_INCLUDE_DIRS in this case.  The result will then be stored in
+# LibXslt_FOUND .  Also the version of LibXslt will be checked by using
+# the version contained in LibXslt_VERSION_STRING.  Since no
+# FAIL_MESSAGE is given, the default messages will be printed.
+#
+# Another example for mode 2:
+#
+# ::
+#
+#     find_package(Automoc4 QUIET NO_MODULE HINTS /opt/automoc4)
+#     find_package_handle_standard_args(Automoc4  CONFIG_MODE)
+#
+# In this case, FindAutmoc4.cmake wraps a call to find_package(Automoc4
+# NO_MODULE) and adds an additional search directory for automoc4.  Here
+# the result will be stored in AUTOMOC4_FOUND.  The following
+# FIND_PACKAGE_HANDLE_STANDARD_ARGS() call produces a proper
+# success/error message.
+
+#=============================================================================
+# Copyright 2007-2009 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+include(${CMAKE_CURRENT_LIST_DIR}/FindPackageMessage.cmake)
+include(${CMAKE_CURRENT_LIST_DIR}/CMakeParseArguments.cmake)
+
+# internal helper macro
+macro(_FPHSA_FAILURE_MESSAGE _msg)
+  if (${_NAME}_FIND_REQUIRED)
+    message(FATAL_ERROR "${_msg}")
+  else ()
+    if (NOT ${_NAME}_FIND_QUIETLY)
+      message(STATUS "${_msg}")
+    endif ()
+  endif ()
+endmacro()
+
+
+# internal helper macro to generate the failure message when used in CONFIG_MODE:
+macro(_FPHSA_HANDLE_FAILURE_CONFIG_MODE)
+  # <name>_CONFIG is set, but FOUND is false, this means that some other of the REQUIRED_VARS was not found:
+  if(${_NAME}_CONFIG)
+    _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: missing: ${MISSING_VARS} (found ${${_NAME}_CONFIG} ${VERSION_MSG})")
+  else()
+    # If _CONSIDERED_CONFIGS is set, the config-file has been found, but no suitable version.
+    # List them all in the error message:
+    if(${_NAME}_CONSIDERED_CONFIGS)
+      set(configsText "")
+      list(LENGTH ${_NAME}_CONSIDERED_CONFIGS configsCount)
+      math(EXPR configsCount "${configsCount} - 1")
+      foreach(currentConfigIndex RANGE ${configsCount})
+        list(GET ${_NAME}_CONSIDERED_CONFIGS ${currentConfigIndex} filename)
+        list(GET ${_NAME}_CONSIDERED_VERSIONS ${currentConfigIndex} version)
+        set(configsText "${configsText}    ${filename} (version ${version})\n")
+      endforeach()
+      if (${_NAME}_NOT_FOUND_MESSAGE)
+        set(configsText "${configsText}    Reason given by package: ${${_NAME}_NOT_FOUND_MESSAGE}\n")
+      endif()
+      _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} ${VERSION_MSG}, checked the following files:\n${configsText}")
+
+    else()
+      # Simple case: No Config-file was found at all:
+      _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: found neither ${_NAME}Config.cmake nor ${_NAME_LOWER}-config.cmake ${VERSION_MSG}")
+    endif()
+  endif()
+endmacro()
+
+
+function(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FIRST_ARG)
+
+# set up the arguments for CMAKE_PARSE_ARGUMENTS and check whether we are in
+# new extended or in the "old" mode:
+  set(options  CONFIG_MODE  HANDLE_COMPONENTS)
+  set(oneValueArgs  FAIL_MESSAGE  VERSION_VAR  FOUND_VAR)
+  set(multiValueArgs REQUIRED_VARS)
+  set(_KEYWORDS_FOR_EXTENDED_MODE  ${options} ${oneValueArgs} ${multiValueArgs} )
+  list(FIND _KEYWORDS_FOR_EXTENDED_MODE "${_FIRST_ARG}" INDEX)
+
+  if(${INDEX} EQUAL -1)
+    set(FPHSA_FAIL_MESSAGE ${_FIRST_ARG})
+    set(FPHSA_REQUIRED_VARS ${ARGN})
+    set(FPHSA_VERSION_VAR)
+  else()
+
+    CMAKE_PARSE_ARGUMENTS(FPHSA "${options}" "${oneValueArgs}" "${multiValueArgs}"  ${_FIRST_ARG} ${ARGN})
+
+    if(FPHSA_UNPARSED_ARGUMENTS)
+      message(FATAL_ERROR "Unknown keywords given to FIND_PACKAGE_HANDLE_STANDARD_ARGS(): \"${FPHSA_UNPARSED_ARGUMENTS}\"")
+    endif()
+
+    if(NOT FPHSA_FAIL_MESSAGE)
+      set(FPHSA_FAIL_MESSAGE  "DEFAULT_MSG")
+    endif()
+  endif()
+
+# now that we collected all arguments, process them
+
+  if("x${FPHSA_FAIL_MESSAGE}" STREQUAL "xDEFAULT_MSG")
+    set(FPHSA_FAIL_MESSAGE "Could NOT find ${_NAME}")
+  endif()
+
+  # In config-mode, we rely on the variable <package>_CONFIG, which is set by find_package()
+  # when it successfully found the config-file, including version checking:
+  if(FPHSA_CONFIG_MODE)
+    list(INSERT FPHSA_REQUIRED_VARS 0 ${_NAME}_CONFIG)
+    list(REMOVE_DUPLICATES FPHSA_REQUIRED_VARS)
+    set(FPHSA_VERSION_VAR ${_NAME}_VERSION)
+  endif()
+
+  if(NOT FPHSA_REQUIRED_VARS)
+    message(FATAL_ERROR "No REQUIRED_VARS specified for FIND_PACKAGE_HANDLE_STANDARD_ARGS()")
+  endif()
+
+  list(GET FPHSA_REQUIRED_VARS 0 _FIRST_REQUIRED_VAR)
+
+  string(TOUPPER ${_NAME} _NAME_UPPER)
+  string(TOLOWER ${_NAME} _NAME_LOWER)
+
+  if(FPHSA_FOUND_VAR)
+    if(FPHSA_FOUND_VAR MATCHES "^${_NAME}_FOUND$"  OR  FPHSA_FOUND_VAR MATCHES "^${_NAME_UPPER}_FOUND$")
+      set(_FOUND_VAR ${FPHSA_FOUND_VAR})
+    else()
+      message(FATAL_ERROR "The argument for FOUND_VAR is \"${FPHSA_FOUND_VAR}\", but only \"${_NAME}_FOUND\" and \"${_NAME_UPPER}_FOUND\" are valid names.")
+    endif()
+  else()
+    set(_FOUND_VAR ${_NAME_UPPER}_FOUND)
+  endif()
+
+  # collect all variables which were not found, so they can be printed, so the
+  # user knows better what went wrong (#6375)
+  set(MISSING_VARS "")
+  set(DETAILS "")
+  # check if all passed variables are valid
+  unset(${_FOUND_VAR})
+  foreach(_CURRENT_VAR ${FPHSA_REQUIRED_VARS})
+    if(NOT ${_CURRENT_VAR})
+      set(${_FOUND_VAR} FALSE)
+      set(MISSING_VARS "${MISSING_VARS} ${_CURRENT_VAR}")
+    else()
+      set(DETAILS "${DETAILS}[${${_CURRENT_VAR}}]")
+    endif()
+  endforeach()
+  if(NOT "${${_FOUND_VAR}}" STREQUAL "FALSE")
+    set(${_FOUND_VAR} TRUE)
+  endif()
+
+  # component handling
+  unset(FOUND_COMPONENTS_MSG)
+  unset(MISSING_COMPONENTS_MSG)
+
+  if(FPHSA_HANDLE_COMPONENTS)
+    foreach(comp ${${_NAME}_FIND_COMPONENTS})
+      if(${_NAME}_${comp}_FOUND)
+
+        if(NOT DEFINED FOUND_COMPONENTS_MSG)
+          set(FOUND_COMPONENTS_MSG "found components: ")
+        endif()
+        set(FOUND_COMPONENTS_MSG "${FOUND_COMPONENTS_MSG} ${comp}")
+
+      else()
+
+        if(NOT DEFINED MISSING_COMPONENTS_MSG)
+          set(MISSING_COMPONENTS_MSG "missing components: ")
+        endif()
+        set(MISSING_COMPONENTS_MSG "${MISSING_COMPONENTS_MSG} ${comp}")
+
+        if(${_NAME}_FIND_REQUIRED_${comp})
+          set(${_FOUND_VAR} FALSE)
+          set(MISSING_VARS "${MISSING_VARS} ${comp}")
+        endif()
+
+      endif()
+    endforeach()
+    set(COMPONENT_MSG "${FOUND_COMPONENTS_MSG} ${MISSING_COMPONENTS_MSG}")
+    set(DETAILS "${DETAILS}[c${COMPONENT_MSG}]")
+  endif()
+
+  # version handling:
+  set(VERSION_MSG "")
+  set(VERSION_OK TRUE)
+  set(VERSION ${${FPHSA_VERSION_VAR}})
+
+  # check with DEFINED here as the requested or found version may be "0"
+  if (DEFINED ${_NAME}_FIND_VERSION)
+    if(DEFINED ${FPHSA_VERSION_VAR})
+
+      if(${_NAME}_FIND_VERSION_EXACT)       # exact version required
+        # count the dots in the version string
+        string(REGEX REPLACE "[^.]" "" _VERSION_DOTS "${VERSION}")
+        # add one dot because there is one dot more than there are components
+        string(LENGTH "${_VERSION_DOTS}." _VERSION_DOTS)
+        if (_VERSION_DOTS GREATER ${_NAME}_FIND_VERSION_COUNT)
+          # Because of the C++ implementation of find_package() ${_NAME}_FIND_VERSION_COUNT
+          # is at most 4 here. Therefore a simple lookup table is used.
+          if (${_NAME}_FIND_VERSION_COUNT EQUAL 1)
+            set(_VERSION_REGEX "[^.]*")
+          elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 2)
+            set(_VERSION_REGEX "[^.]*\\.[^.]*")
+          elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 3)
+            set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*")
+          else ()
+            set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*\\.[^.]*")
+          endif ()
+          string(REGEX REPLACE "^(${_VERSION_REGEX})\\..*" "\\1" _VERSION_HEAD "${VERSION}")
+          unset(_VERSION_REGEX)
+          if (NOT ${_NAME}_FIND_VERSION VERSION_EQUAL _VERSION_HEAD)
+            set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"")
+            set(VERSION_OK FALSE)
+          else ()
+            set(VERSION_MSG "(found suitable exact version \"${VERSION}\")")
+          endif ()
+          unset(_VERSION_HEAD)
+        else ()
+          if (NOT ${_NAME}_FIND_VERSION VERSION_EQUAL VERSION)
+            set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"")
+            set(VERSION_OK FALSE)
+          else ()
+            set(VERSION_MSG "(found suitable exact version \"${VERSION}\")")
+          endif ()
+        endif ()
+        unset(_VERSION_DOTS)
+
+      else()     # minimum version specified:
+        if (${_NAME}_FIND_VERSION VERSION_GREATER VERSION)
+          set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is at least \"${${_NAME}_FIND_VERSION}\"")
+          set(VERSION_OK FALSE)
+        else ()
+          set(VERSION_MSG "(found suitable version \"${VERSION}\", minimum required is \"${${_NAME}_FIND_VERSION}\")")
+        endif ()
+      endif()
+
+    else()
+
+      # if the package was not found, but a version was given, add that to the output:
+      if(${_NAME}_FIND_VERSION_EXACT)
+         set(VERSION_MSG "(Required is exact version \"${${_NAME}_FIND_VERSION}\")")
+      else()
+         set(VERSION_MSG "(Required is at least version \"${${_NAME}_FIND_VERSION}\")")
+      endif()
+
+    endif()
+  else ()
+    if(VERSION)
+      set(VERSION_MSG "(found version \"${VERSION}\")")
+    endif()
+  endif ()
+
+  if(VERSION_OK)
+    set(DETAILS "${DETAILS}[v${VERSION}(${${_NAME}_FIND_VERSION})]")
+  else()
+    set(${_FOUND_VAR} FALSE)
+  endif()
+
+
+  # print the result:
+  if (${_FOUND_VAR})
+    FIND_PACKAGE_MESSAGE(${_NAME} "Found ${_NAME}: ${${_FIRST_REQUIRED_VAR}} ${VERSION_MSG} ${COMPONENT_MSG}" "${DETAILS}")
+  else ()
+
+    if(FPHSA_CONFIG_MODE)
+      _FPHSA_HANDLE_FAILURE_CONFIG_MODE()
+    else()
+      if(NOT VERSION_OK)
+        _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: ${VERSION_MSG} (found ${${_FIRST_REQUIRED_VAR}})")
+      else()
+        _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} (missing: ${MISSING_VARS}) ${VERSION_MSG}")
+      endif()
+    endif()
+
+  endif ()
+
+  set(${_FOUND_VAR} ${${_FOUND_VAR}} PARENT_SCOPE)
+
+endfunction()

cmake/Modules/FindPackageMessage.cmake

@@ -0,0 +1,57 @@
+#.rst:
+# FindPackageMessage
+# ------------------
+#
+#
+#
+# FIND_PACKAGE_MESSAGE(<name> "message for user" "find result details")
+#
+# This macro is intended to be used in FindXXX.cmake modules files.  It
+# will print a message once for each unique find result.  This is useful
+# for telling the user where a package was found.  The first argument
+# specifies the name (XXX) of the package.  The second argument
+# specifies the message to display.  The third argument lists details
+# about the find result so that if they change the message will be
+# displayed again.  The macro also obeys the QUIET argument to the
+# find_package command.
+#
+# Example:
+#
+# ::
+#
+#   if(X11_FOUND)
+#     FIND_PACKAGE_MESSAGE(X11 "Found X11: ${X11_X11_LIB}"
+#       "[${X11_X11_LIB}][${X11_INCLUDE_DIR}]")
+#   else()
+#    ...
+#   endif()
+
+#=============================================================================
+# Copyright 2008-2009 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+function(FIND_PACKAGE_MESSAGE pkg msg details)
+  # Avoid printing a message repeatedly for the same find result.
+  if(NOT ${pkg}_FIND_QUIETLY)
+    string(REPLACE "\n" "" details "${details}")
+    set(DETAILS_VAR FIND_PACKAGE_MESSAGE_DETAILS_${pkg})
+    if(NOT "${details}" STREQUAL "${${DETAILS_VAR}}")
+      # The message has not yet been printed.
+      message(STATUS "${msg}")
+
+      # Save the find details in the cache to avoid printing the same
+      # message again.
+      set("${DETAILS_VAR}" "${details}"
+        CACHE INTERNAL "Details about finding ${pkg}")
+    endif()
+  endif()
+endfunction()

config.c

@@ -145,13 +145,6 @@ static void dump_proxy_service(const int index, struct proxy_service *ps)
 		ps->proxy_type = strdup("tcp");
 		assert(ps->proxy_type);
 	} else if (strcmp(ps->proxy_type, "ftp") == 0) {
-		if (ps->remote_data_port <= 0) {
-			debug(LOG_ERR, 
-				"Proxy [%s] error: remote_data_port must be exist when type is ftp", 
-				ps->proxy_name);
-			exit(0);
-		}
-
 		new_ftp_data_proxy_service(ps);
 	}
 
@@ -183,6 +176,7 @@ static struct proxy_service *new_proxy_service(const char *name)
 	assert(c_conf);
 
 	ps->proxy_name 			= strdup(name);
+	ps->ftp_cfg_proxy_name	= NULL;
 	assert(ps->proxy_name);
 
 	ps->proxy_type 			= NULL;
@@ -217,6 +211,9 @@ static void new_ftp_data_proxy_service(struct proxy_service *ftp_ps)
 				"cannot create ftp data proxy service, it should not happenned!");
 			exit(0);
 		}
+		
+		ps->ftp_cfg_proxy_name = strdup(ftp_ps->proxy_name);
+		assert(ps->ftp_cfg_proxy_name);
 
 		ps->proxy_type = strdup("tcp");
 		ps->remote_port = ftp_ps->remote_data_port;
@@ -318,6 +315,8 @@ static int common_handler(void *user, const char *section, const char *name, con
 			debug(LOG_ERR, "error: server_addr [%s] is invalid!", value);
 			exit(0);
 		}
+		if (is_valid_ip_address(value))
+			set_common_server_ip(value);
 	} else if (MATCH("common", "server_port")) {
 		config->server_port = atoi(value);
 	} else if (MATCH("common", "http_proxy")) {
@@ -387,7 +386,7 @@ static void init_common_conf(struct common_conf *config)
 // because of assert it will never return NULL
 char *get_ftp_data_proxy_name(const char *ftp_proxy_name)
 {
-	char *ftp_tail_data_name = FTP_DATA_PROXY_SUFFIX;
+	char *ftp_tail_data_name = FTP_RMT_CTL_PROXY_SUFFIX;
 	char *ftp_data_proxy_name = (char *)calloc(1, 
 								strlen(ftp_proxy_name)+strlen(ftp_tail_data_name)+1);
 	assert(ftp_data_proxy_name);

config.h

@@ -29,7 +29,7 @@
 #include "client.h"
 #include "common.h"
 
-#define FTP_DATA_PROXY_SUFFIX	"_ftp_data_proxy"
+#define FTP_RMT_CTL_PROXY_SUFFIX	"_ftp_remote_ctl_proxy"
 
 struct base_conf{
 	char	*name;

control.c

@@ -122,7 +122,7 @@ static void new_client_connect()
 	struct proxy_client *client = new_proxy_client();
 	struct common_conf *c_conf = get_common_config();
 	assert(c_conf);
-	client->base = main_ctl->connect_base;;
+	client->base = main_ctl->connect_base;
 	struct bufferevent *bev = connect_server(client->base, c_conf->server_addr, c_conf->server_port);
 	if (!bev) {
 		debug(LOG_DEBUG, "Connect server [%s:%d] failed", c_conf->server_addr, c_conf->server_port);
@@ -354,6 +354,50 @@ static void hb_sender_cb(evutil_socket_t fd, short event, void *arg)
 	set_ticker_ping_timer(main_ctl->ticker_ping);	
 }
 
+// return: 0: raw succeed 1: raw failed
+static int proxy_service_resp_raw(struct new_proxy_response *npr)
+{
+	if (npr->error && strlen(npr->error) > 2) {
+		debug(LOG_ERR, "error: new proxy response error_field:%s", npr->error);
+		return 1;
+	}
+	
+	if ((! npr->proxy_name) || (strlen(npr->proxy_name) <= 0)) {
+		debug(LOG_ERR, "error: new proxy response proxy name unmarshal failed!");
+		return 1;
+	}
+
+	struct proxy_service *ps = NULL;
+	ps = get_proxy_service(npr->proxy_name);
+	if (! ps) {
+		debug(LOG_ERR, "error: proxy_name responsed by TypeNewProxyResp not found!");
+		return 1;
+	}
+
+	if (! ps->proxy_type) {
+		debug(LOG_ERR, "error: proxy_type is NULL, it should be never happend!");
+		return 1;
+	}
+
+	if (ps->ftp_cfg_proxy_name) {
+		struct proxy_service *main_ps = get_proxy_service(ps->ftp_cfg_proxy_name);
+		if (main_ps) {
+			debug(LOG_DEBUG, "find main ftp proxy service name [%s]", main_ps->proxy_name);
+		} else {
+			debug(LOG_ERR, "error: cannot find main ftp proxy service!");
+			return 1;
+		}
+
+		if (npr->remote_port <= 0) {
+			debug(LOG_ERR, "error: ftp remote_data_port [%d] that request from server is invalid!", npr->remote_port);
+			return 1;
+		}
+		main_ps->remote_data_port = npr->remote_port;
+	}
+
+	return 0;
+}
+
 static void 
 raw_message(struct message *msg, struct bufferevent *bev, struct proxy_client *client)
 {
@@ -406,7 +450,24 @@ raw_message(struct message *msg, struct bufferevent *bev, struct proxy_client *c
 			break;
 
 		case TypeNewProxyResp:
-			break;
+			{
+				if (msg->data_p == NULL) {
+					debug(LOG_ERR, 
+						"recved TypeNewProxyResp but no data, it should be never happend!");
+					break;
+				}
+
+				struct new_proxy_response *npr = new_proxy_resp_unmarshal(msg->data_p);
+				if (npr == NULL) {
+					debug(LOG_ERR, "new proxy response buffer unmarshal faild!");
+					return;
+				}
+
+				proxy_service_resp_raw(npr);
+				
+				SAFE_FREE(npr);
+				break;
+			}
 
 		case TypeStartWorkConn:
 			sr = start_work_conn_resp_unmarshal(msg->data_p); 

crypto.c

@@ -149,21 +149,21 @@ size_t encrypt_data(const unsigned char *src_data, size_t srclen, struct frp_cod
 
 	int outlen = 0, tmplen = 0;
 	struct frp_coder *c = encoder;
-	EVP_CIPHER_CTX ctx;
-	EVP_CIPHER_CTX_init(&ctx);
-	EVP_EncryptInit_ex(&ctx, EVP_aes_128_cfb(), NULL, c->key, c->iv);
-	if(!EVP_EncryptUpdate(&ctx, outbuf, &outlen, intext, (int)srclen)) {
+	EVP_CIPHER_CTX *ctx;
+	ctx = EVP_CIPHER_CTX_new();
+	EVP_EncryptInit_ex(ctx, EVP_aes_128_cfb(), NULL, c->key, c->iv);
+	if(!EVP_EncryptUpdate(ctx, outbuf, &outlen, intext, (int)srclen)) {
 		debug(LOG_ERR, "EVP_EncryptUpdate error!");
 		goto E_END;
 	}
 
-	if(!EVP_EncryptFinal_ex(&ctx, outbuf+outlen, &tmplen)) {
+	if(!EVP_EncryptFinal_ex(ctx, outbuf+outlen, &tmplen)) {
 		debug(LOG_ERR, "EVP_EncryptFinal_ex error!");
 		goto E_END;
 	}
 
 	outlen += tmplen;
-	EVP_CIPHER_CTX_cleanup(&ctx);
+	EVP_CIPHER_CTX_free(ctx);
 
 #ifdef ENC_DEBUG
 	int j = 0;
@@ -203,10 +203,10 @@ size_t decrypt_data(const unsigned char *enc_data, size_t enc_len, struct frp_co
 
 	int outlen = 0, tmplen = 0;
 	struct frp_coder *c = decoder;
-	EVP_CIPHER_CTX ctx;
-	EVP_CIPHER_CTX_init(&ctx);
-	EVP_DecryptInit_ex(&ctx, EVP_aes_128_cfb(), NULL, c->key, c->iv);
-	EVP_CIPHER_CTX_set_padding(&ctx, 0);
+	EVP_CIPHER_CTX *ctx;
+	ctx = EVP_CIPHER_CTX_new();
+	EVP_DecryptInit_ex(ctx, EVP_aes_128_cfb(), NULL, c->key, c->iv);
+	EVP_CIPHER_CTX_set_padding(ctx, 0);
 
 	int loop_times = enc_len / 10;
 	int latest_len = enc_len % 10;
@@ -220,7 +220,7 @@ size_t decrypt_data(const unsigned char *enc_data, size_t enc_len, struct frp_co
 			enc_per_len = 10;
 		}
 
-		if(!EVP_DecryptUpdate(&ctx, outbuf + (i*10), &outlen, inbuf + (i*10), enc_per_len)) {
+		if(!EVP_DecryptUpdate(ctx, outbuf + (i*10), &outlen, inbuf + (i*10), enc_per_len)) {
 			debug(LOG_ERR, "EVP_DecryptUpdate error!");
 			goto D_END;
 		}
@@ -228,14 +228,13 @@ size_t decrypt_data(const unsigned char *enc_data, size_t enc_len, struct frp_co
 	}
 
 
-	if(!EVP_DecryptFinal_ex(&ctx, outbuf+totol_len, &tmplen)) {
+	if(!EVP_DecryptFinal_ex(ctx, outbuf+totol_len, &tmplen)) {
 		debug(LOG_ERR, "EVP_DecryptFinal_ex error");
 		goto D_END;
 	}
 
 	totol_len += tmplen;
-	EVP_CIPHER_CTX_cleanup(&ctx);
-
+	EVP_CIPHER_CTX_free(ctx);
 #ifdef ENC_DEBUG
 	debug(LOG_DEBUG, "DEC_LEN:%lu", enc_len);
 	int j = 0;

msg.c

@@ -27,7 +27,6 @@
 #include <string.h>
 #include <stdio.h>
 #include <json-c/json.h>
-#include <json-c/bits.h>
 #include <openssl/md5.h>
 #include <time.h>
 #include <assert.h>
@@ -132,7 +131,7 @@ size_t login_request_marshal(char **msg)
 {
 	size_t nret = 0;
 	struct json_object *j_login_req = json_object_new_object();
-	if (is_error(j_login_req))
+	if (j_login_req == NULL)
 		return 0;
 	
 	struct login *lg = get_common_login_config();
@@ -242,11 +241,49 @@ int new_work_conn_marshal(const struct work_conn *work_c, char **msg)
 	return nret;
 }
 
+// result returned of this func need be free
+struct new_proxy_response *new_proxy_resp_unmarshal(const char *jres)
+{
+	struct json_object *j_np_res = json_tokener_parse(jres);
+	if (j_np_res == NULL)
+		return NULL;
+	
+	struct new_proxy_response *npr = calloc(1, sizeof(struct new_proxy_response));
+	assert(npr);
+
+	struct json_object *npr_run_id = NULL;
+	if (! json_object_object_get_ex(j_np_res, "run_id", &npr_run_id))
+		goto END_ERROR;
+	npr->run_id = strdup(json_object_get_string(npr_run_id));
+	assert(npr->run_id);
+
+	struct json_object *npr_proxy_remote_port = NULL;
+	if (! json_object_object_get_ex(j_np_res, "remote_port", &npr_proxy_remote_port))
+		goto END_ERROR;
+	npr->remote_port = json_object_get_int(npr_proxy_remote_port);
+
+	struct json_object *npr_proxy_name = NULL;
+	if (! json_object_object_get_ex(j_np_res, "proxy_name", &npr_proxy_name))
+		goto END_ERROR;
+	npr->proxy_name = strdup(json_object_get_string(npr_proxy_name));
+	assert(npr->proxy_name);
+
+	struct json_object *npr_error = NULL;
+	if(! json_object_object_get_ex(j_np_res, "error", &npr_error))
+		goto END_ERROR;
+	npr->error = strdup(json_object_get_string(npr_error));
+	assert(npr->error);
+
+END_ERROR:
+	json_object_put(j_np_res);
+	return npr;
+}
+
 // login_resp_unmarshal NEED FREE
 struct login_resp *login_resp_unmarshal(const char *jres)
 {
 	struct json_object *j_lg_res = json_tokener_parse(jres);
-	if (is_error(j_lg_res))
+	if (j_lg_res == NULL)
 		return NULL;
 	
 	struct login_resp *lr = calloc(1, sizeof(struct login_resp));
@@ -278,7 +315,7 @@ END_ERROR:
 struct start_work_conn_resp *start_work_conn_resp_unmarshal(const char *resp_msg)
 {
 	struct json_object *j_start_w_res = json_tokener_parse(resp_msg);
-	if (is_error(j_start_w_res))
+	if (j_start_w_res == NULL)
 		return NULL;
 
 	struct start_work_conn_resp *sr = calloc(1, sizeof(struct start_work_conn_resp));
@@ -299,7 +336,7 @@ START_W_C_R_END:
 struct control_response *control_response_unmarshal(const char *jres)
 {
 	struct json_object *j_ctl_res = json_tokener_parse(jres);
-	if (is_error(j_ctl_res))
+	if (j_ctl_res == NULL)
 		return NULL;
 	struct control_response *ctl_res = calloc(sizeof(struct control_response), 1);
 	assert(ctl_res);
@@ -390,4 +427,4 @@ size_t pack(struct message *req_msg, unsigned char **ret_buf)
 	memcpy((char *)*ret_buf+TYPE_LEN+sizeof(data_len_bigend), req_msg->data_p, req_msg->data_len);
 
 	return buf_len;
-}
+}

msg.h

@@ -67,6 +67,13 @@ struct control_response {
 	char	*msg;
 };
 
+struct new_proxy_response {
+	char 	*run_id;
+	char 	*proxy_name;
+	char	*error;
+	int		remote_port;
+};
+
 struct work_conn {
 	char *run_id;
 };
@@ -91,6 +98,7 @@ size_t pack(struct message *req_msg, unsigned char **ret_buf);
 struct message *unpack(unsigned char *recv_msg, const ushort len);
 
 // tranlate control request to json string
+struct new_proxy_response *new_proxy_resp_unmarshal(const char *jres);
 struct login_resp *login_resp_unmarshal(const char *jres);
 struct start_work_conn_resp *start_work_conn_resp_unmarshal(const char *resp_msg);
 

openwrt/Makefile

@@ -0,0 +1,55 @@
+#
+# Copyright (C) 2022 Dengfeng Liu
+#
+# This is free software, licensed under the GNU General Public License v3.
+# See /LICENSE for more information.
+#
+
+include $(TOPDIR)/rules.mk
+
+PKG_NAME:=xfrpc
+#PKG_VERSION:=0.07.496
+PKG_VERSION:=master
+PKG_RELEASE:=1
+
+PKG_SOURCE_PROTO:=git
+PKG_SOURCE_URL:=https://github.com/liudf0716/xfrpc.git
+PKG_SOURCE_VERSION:=$(PKG_VERSION)
+PKG_MIRROR_HASH:=a7141da8a85203d8341fd6d2551f1228396ae54aace6ec0bad2dfeb89e0a377d
+
+PKG_MAINTAINER:=Dengfeng Liu <liudf0716@gmail.com>
+PKG_LICENSE:=GPL-3.0-or-later
+PKG_LICENSE_FILES:=COPYING
+
+include $(INCLUDE_DIR)/package.mk
+include $(INCLUDE_DIR)/cmake.mk
+
+define Package/xfrpc
+  SUBMENU:=Web Servers/Proxies
+  SECTION:=net
+  CATEGORY:=Network
+  DEPENDS:=+zlib +libjson-c +libevent2 +libevent2-openssl
+  TITLE:= C language fast reverse proxy client
+  URL:=https://github.com/liudf0716/xfrpc
+endef
+
+define Package/xfrpc/description
+  xfrpc is C language fast reverse proxy client
+  compare with golang version frpc
+  xfrpc can run in almost all openwrt device
+endef
+
+define Package/xfrpc/conffiles
+/etc/config/xfrpc
+endef
+
+define Package/xfrpc/install
+        $(INSTALL_DIR) $(1)/usr/bin
+        $(INSTALL_BIN) $(PKG_INSTALL_DIR)/usr/bin/xfrpc $(1)/usr/bin/xfrpc
+        $(INSTALL_DIR) $(1)/etc/init.d
+        $(INSTALL_BIN) ./files/xfrpc.init $(1)/etc/init.d/xfrpc
+        $(INSTALL_DIR) $(1)/etc/config
+        $(CP) ./files/xfrpc.conf $(1)/etc/config/xfrpc
+endef
+
+$(eval $(call BuildPackage,xfrpc))

openwrt/files/xfrpc.conf

@@ -0,0 +1,31 @@
+config xfrp 'init'
+	option disabled 1
+	option loglevel 7
+
+config xfrpc 'common'
+	option server_addr 127.0.0.1
+	option server_port 7000
+	option auth_token abdesf13d
+
+config xfrpc 'ssh01'
+	option type tcp
+	option local_ip 127.0.0.1
+	option local_port 22
+	option remote_port 6000
+
+#config xfrpc 'ftp01'
+#	option type ftp
+#	option local_ip 127.0.01
+#	option local_port 21
+#	option remote_port 8021
+#	option remote_data_port 8022
+	
+#config xfrpc 'web01'
+#	option type http
+#	option local_ip 127.0.0.1
+#	option local_port 8080
+	
+#config xfrpc 'web02'
+#	option type https
+#	option local_ip 127.0.0.1
+#	option local_port 8443

openwrt/files/xfrpc.ini

@@ -0,0 +1,93 @@
+#!/bin/sh /etc/rc.common
+# Copyright (C) 2022 Dengfeng Liu <liu_df@qq.com>
+#
+# This is free software, licensed under the GNU General Public License v3.
+# See /LICENSE for more information.
+#
+
+START=99
+USE_PROCD=1
+
+NAME=xfrpc
+PROG=/user/bin/$NAME
+
+
+handle_xfrpc() {
+	local name="$1"
+	local config="$2"
+
+	echo "[$name]" >> "$config"
+
+	handle_type() {
+		uci_validate_section xfrpc xfrpc "$name" \
+										'type:or("tcp", "udp", "ftp", "http", "https")' \
+										'local_ip:ipaddr:127.0.0.1' \
+										'local_port:uinteger'
+
+		echo "type = $type" >> "$config"
+		echo "local_ip = $local_ip" >> "$config"
+		echo "local_port = $local_port" >> "$config"
+		case "$type" in
+		"tcp"|"udp")
+			config_get remote_port "$name" remote_port
+			echo "remote_port = $remote_port" >> "$config"
+			;;
+		"ftp")
+			config_get remote_port "$name" remote_port
+			config_get remote_data_port "$name" remote_data_port
+			echo "remote_port = $remote_port" >> "$config"
+			echo "remote_data_port = $remote_data_port" >> "$config"
+			;;
+		esac
+	}
+
+	if [ "$name" = "common" ]; then
+		uci_validate_section xfrpc xfrpc "$name" \
+										'server_addr:ipaddr' \
+										'server_port:uinteger' \
+										'auth_token:string'
+
+		[ -z "$auth_token" ] && {
+			echo "no auth_token"
+			exit
+		}
+		echo "server_addr = $server_addr" >> "$config"
+		echo "server_port = $server_port" >> "$config"
+		echo "auth_token = $auth_token" >> "$config"
+	else
+		handle_type
+	fi
+}
+
+service_triggers() {
+	procd_add_reload_trigger "$NAME"
+}
+
+start_service() {
+	local conf_file="/var/etc/$NAME.ini"
+
+	> "$conf_file"
+	config_load "$NAME"
+
+	uci_validate_section xfrpc xfrpc init \
+									'disabled:bool:1' \
+									'loglevel:uinteger:0'
+
+	if [ $disabled = 1 ]; then
+		echo "xfrpc service disabled"
+		return
+	fi
+
+	config_foreach handle_xfrpc xfrpc "$conf_file"
+
+	procd_open_instance
+	procd_set_param command "$PROG" -c "$conf_file" -f -d $loglevel
+	procd_set_param file "$conf_file"
+	procd_set_param respawn
+	procd_close_instance
+}
+
+reload_service() {
+	stop
+	start
+}

utils.h

@@ -1,6 +1,11 @@
 #ifndef _UTILS_H_
 #define _UTILS_H_
 
+struct mycurl_string {
+	char 	*ptr;
+	size_t 	len;
+};
+
 void s_sleep(unsigned int s, unsigned int u);
 
 // is_valid_ip_address: