Skip to content
Please note that GitHub no longer supports your web browser.

We recommend upgrading to the latest Google Chrome Or Firefox .

Learn more
Permalink
Branch: Master
Find file Copy path
Find file Copy path
Six Contributors

Users who have contributed to this file

 @fatedier  @IanSmith123  @Hyduan  @ericlarssen  @renmu123  @bighamx
906 lines (630 SLOC) 27.9 KB

FRP

 Build Status

README A kind of Chinese document

FRP is a high-performance reverse proxy application that can be used for internal network penetration. It supports TCP and UDP protocol. It provides additional capabilities for HTTP and HTTPS application protocols, and tries to support peer to peer penetration.

Catalog

Development state

FRP is still in development stage, and has not been fully tested and verified. It is not recommended for production environment.

The master branch is used to release stable versions, and dev branches are used for development. You can try to download the latest release version for testing.

The current interaction protocol may change at any time, and does not guarantee backward compatibility. When upgrading the new version, it is necessary to pay attention to announcements while upgrading the server and client.

Framework

 Architecture

Use example

According to the corresponding operating system and architecture, from Release Page download the latest version of the program.

take FRPs and Frps.ini Put it on a machine with a public network IP.

take FRPC and Frpc.ini Put it on the machine in the Intranet environment.

Access the company's intranet machine through SSH

  1. Modify the frps.ini file, where the simplest configuration is used:
 Wei Frps.ini
 [common]
 Bind_port = 7000
  1. Start FRPs:

./frps -c./frps.ini

  1. Modify the frpc.ini file, assuming that the public network IP of the server where FRPs is located is x.x.x.x;
 Wei Frpc.ini
 [common]
 Server_addr = x.x.x.x Server_port = 7000 [ssh]
 Type = TCP Local_ip = 127.0.0.1 Local_port = 22 Remote_port = 6000
  1. Start FRPC:

./frpc -c./frpc.ini

  1. Access the intranet machine through SSH, assuming that the user name is test:

SSH -oPort=6000 test@x.x.x.x

Accessing web services deployed in Intranet through custom domain names

Sometimes we want other people to access or test our local web services through domain names. However, because the local machine does not have a public network IP, it can not resolve the domain name to the local machine. This function can be realized through FRP. The following example is HTTP service, the HTTPS service allocation method is the same, vhost_http_port is replaced by vhost_https_port, type is set to HTTPS.

  1. Modify the frps.ini file and set the HTTP access port to 8080.
 Wei Frps.ini
 [common]
 Bind_port = 7000 Vhost_http_port = 8080
  1. Start FRPs:

./frps -c./frps.ini

  1. Modify the frpc.ini file, assuming that the IP of the server where FRPs is located is x.x.x.x, local_port is the port corresponding to the web service on the local machine, and bind the custom domain name. Www.yourdomain.com :
 Wei Frpc.ini
 [common]
 Server_addr = x.x.x.x Server_port = 7000 [web]
 Type = http Local_port = 80 Custom_domains = www.yourdomain.com
  1. Start FRPC:

./frpc -c./frpc.ini

  1. take Www.yourdomain.com The domain name A record is parsed to IP X.x.x.x If the server already has the corresponding domain name, it can also resolve the CNAME record to the original domain name of the server.

  2. Browser access Http://www.yourdomain.com:8080 You can access Web services on the intranet machine.

Forwarding DNS query requests

DNS query requests usually use the UDP protocol. FRP supports the penetration of UDP services in the intranet, and the configuration is basically the same as that of TCP.

  1. Modify the frps.ini file:
 Wei Frps.ini
 [common]
 Bind_port = 7000
  1. Start FRPs:

./frps -c./frps.ini

  1. Modify the frpc.ini file, set the FRPs's server's IP to x.x.x.x, and forward to Google's DNS query server. 8.8.8.8 UDP 53 port:
 Wei Frpc.ini
 [common]
 Server_addr = x.x.x.x Server_port = 7000 [dns]
 Type = UDP Local_ip = 8.8.8.8 Local_port = 53 Remote_port = 6000
  1. Start FRPC:

./frpc -c./frpc.ini

  1. Dig test whether the UDP packet forwarding is successful and is expected to return. Www.google.com Domain name analysis results:

Dig @x.x.x.x -p 6000 www.google.com

Forwarding Unix domain socket

Access the UNIX domain socket of the intranet (such as communication with docker daemon) through the TCP port.

The deployment steps of FRPs are the same as above.

  1. Start FRPC, enable Unix_domain_socket The plug-in is configured as follows:
 Wei Frpc.ini
 [common]
 Server_addr = x.x.x.x Server_port = 7000 [unix_domain_socket]
 Type = TCP Remote_port = 6000 Plugin = unix_domain_socket Plugin_unix_path = /var/run/docker.sock
  1. View docker version information through the curl command

Curl http://x.x.x.x:6000/version

Providing simple file access services outside

adopt Static_file Plug-ins can provide a simple file access service based on HTTP.

The deployment steps of FRPs are the same as above.

  1. Start FRPC, enable Static_file The plug-in is configured as follows:
 Wei Frpc.ini
 [common]
 Server_addr = x.x.x.x Server_port = 7000 [test_static_file]
 Type = TCP Remote_port = 6000 Plugin = static_file Wei List of files to be exposed to
 Plugin_local_path = /tmp/file Wei Access the prefix that will be removed in URL, and the reserved content is the file path to be accessed.
 Plugin_strip_prefix = static Plugin_http_user = ABC Plugin_http_passwd = ABC
  1. Browser access Http://x.x.x.x:6000/static/ Check it out. /tmp/file The files in the directory will require the user name and password to be entered.

Enabling HTTPS for local HTTP services

adopt Https2http Plug-ins can transform local HTTP services into HTTPS services to provide external services.

  1. Enable FRPC, enable Https2http The plug-in is configured as follows:
 Wei Frpc.ini
 [common]
 Server_addr = x.x.x.x Server_port = 7000 [test_htts2http]
 Type = HTTPS Custom_domains = test.yourdomain.com Plugin = https2http Plugin_local_addr = 127.0.0.1:80 Wei HTTPS certificate related configuration
 Plugin_crt_path =./server.crt Plugin_key_path =./server.key Plugin_host_header_rewrite = 127.0.0.1 Plugin_header_X-From-Where = FRP
  1. Browser access Https://test.yourdomain.com Yes.

Exposing intranet services safely

For some services, if exposed directly to the public network, there will be security risks.

Use STCP (secret TCP) The type of proxy can prevent anyone from accessing the services to be penetrated, but visitors also need to run another FRPC.

The following example will create a SSH service agent that can only be accessed by itself.

The deployment steps of FRPs are the same as above.

  1. Start FRPC and forward the SSH service of the intranet. The configuration is as follows: no remote port is required.
 Wei Frpc.ini
 [common]
 Server_addr = x.x.x.x Server_port = 7000 [secret_ssh]
 Type = STCP Wei Only SK consistent users can access this service.
 Sk = ABCDEFG Local_ip = 127.0.0.1 Local_port = 22
  1. Start another FRPC on the machine to access the service. The configuration is as follows:
 Wei Frpc.ini
 [common]
 Server_addr = x.x.x.x Server_port = 7000 [secret_ssh_visitor]
 Type = STCP Wei Visitors to STCP
 Role = visitor Wei The name of the STCP agent to be visited
 Server_name = secret_ssh Sk = ABCDEFG Wei Binding local ports for accessing SSH services
 Bind_addr = 127.0.0.1 Bind_port = 6000
  1. Access the intranet machine through SSH, assuming that the user name is test:

SSH -oPort=6000 test@127.0.0.1

Peer to peer network penetration

FRP provides a new proxy type. Xtcp It is used to deal with scenarios where large amounts of data are expected to be transmitted and traffic is not passed through the server.

Same way of use STCP Similarly, it is necessary to deploy FRPC on both sides to establish direct connections.

At present, at the initial stage of development, it does not penetrate all types of NAT devices, so the penetration success rate is low. If you fail, you can try. STCP The way.

  1. In addition to the normal configuration, FRPs needs to configure an additional UDP port to support the type of client:
 Bind_udp_port = 7001
  1. Start FRPC and forward the SSH service of the intranet. The configuration is as follows: no remote port is required.
 Wei Frpc.ini
 [common]
 Server_addr = x.x.x.x Server_port = 7000 [p2p_ssh]
 Type = xtcp Wei Only SK consistent users can access this service.
 Sk = ABCDEFG Local_ip = 127.0.0.1 Local_port = 22
  1. Start another FRPC on the machine to access the service. The configuration is as follows:
 Wei Frpc.ini
 [common]
 Server_addr = x.x.x.x Server_port = 7000 [p2p_ssh_visitor]
 Type = xtcp Wei Visitors to xtcp
 Role = visitor Wei The name of the xtcp agent to be visited
 Server_name = p2p_ssh Sk = ABCDEFG Wei Binding local ports for accessing SSH services
 Bind_addr = 127.0.0.1 Bind_port = 6000
  1. Access the intranet machine through SSH, assuming that the user name is test:.

SSH -oPort=6000 test@127.0.0.1

Function description

configuration file

Due to the many functions and configuration items currently supported by FRP, the functions not listed in the document can be found in the complete example configuration file.

FRPs complete configuration file

FRPC complete configuration file

Profile template rendering

The configuration file supports template rendering using system environment variables, and the template format is in Go standard format.

The example is configured as follows:

 Wei Frpc.ini
 [common]
 Server_addr =.Envs.FRP_SERVER_ADDR Server_port = 7000 [ssh]
 Type = TCP Local_ip = 127.0.0.1 Local_port = 22 Remote_port =.Envs.FRP_SSH_REMOTE_PORT

Start the FRPC program:

 Export FRP_SERVER_ADDR= "x.x.x.x" 
export FRP_SSH_REMOTE_PORT= "6000" 
./frpc -c./frpc.ini

FRPC automatically uses the environment variable to render the configuration file template, and all environment variables need to be .Envs Prefix.

Dashboard

Browser to view the status of FRP and proxy statistics display.

Note: Dashboard has not been optimized for a large number of proxy data display. If Dashboard access is slow, please do not enable this function.

You need to specify the port used by the dashboard service in frps.ini to enable this function:

 [common]
 Dashboard_port = 7500 Wei Dashboard user name password, the default is admin
 Dashboard_user = admin Dashboard_pwd = admin

Open browser through Http://[server_addr]: 7500 Access the dashboard interface. The user name password is default. Admin

 Dashboard

Admin UI

Admin UI can help users to query and manage the proxy state and configuration of the client through browser.

You need to specify the port used by the admin service in frpc.ini to enable this function:

 [common]
 Admin_addr = 127.0.0.1 Admin_port = 7400 Admin_user = admin Admin_pwd = admin

Open browser through Http://127.0.0.1:7400 Access Admin UI, username password is default. Admin

If you want to access Admin UI in the external network environment, you can map out the 7400 port, but you need to pay attention to the security risk.

Identity verification

Common configuration in server and client Token Identity is passed through parameter consistency.

Encryption and compression

These two functions are not opened by default. They need to be configured in frpc.ini to enable encryption and compression functions for the specified agent. The compression algorithm uses snappy:

 Wei Frpc.ini
 [ssh]
 Type = TCP Local_port = 22 Remote_port = 6000 Use_encryption = true Use_compression = true

If the internal firewall of the company carries out traffic identification and shielding to the external network access, such as the prohibition of the SSH protocol, and so on, through setting up Use_encryption = true Encrypting transmission between FRPC and FRPs will effectively prevent traffic from being intercepted.

If the length of the message transmitted is longer, set it up. Use_compression = true Compressing the transmission content can effectively reduce the network traffic between FRPC and FRPs, speed up the forwarding speed, but it will consume some additional CPU resources.

TLS

Starting from the v0.25.0 version, FRPC and FRPs support the encrypted transmission through the TLS protocol. Through in Frpc.ini Of Common Middle configuration Tls_enable = true To enable this function, the security is even higher.

For port reuse, the first byte of FRP to establish TLS connection is 0x17.

Note: after this function is enabled, there is no need to set up use_encryption except xtcp.

Client hot loading configuration file

When modifying the agent configuration in FRPC, you can pass FRPC reload The command dynamically loads the configuration file, which usually completes the agent's update in 10 seconds.

Enabling this function requires the use of admin ports in FRPC to provide API services. The configuration is as follows:

 Wei Frpc.ini
 [common]
 Admin_addr = 127.0.0.1 Admin_port = 7400

After that, restart the command.

FRPC reload -c./frpc.ini

After waiting for some time, the client will create, update and delete agents based on the new configuration file.

It should be noted that the parameters in [common] can not be modified except start.

Client view agent status

FRPC supports adoption. FRPC status -c./frpc.ini The command looks at the status information of the agent, which requires configuring the admin port in FRPC.

Port white list

To prevent ports from being abused, you can manually specify which ports are allowed to be used and pass in frps.ini. Allow_ports To specify:

 Wei Frps.ini
 [common]
 Allow_ports = 2000-3000300130034000-50000

Allow_ports You can configure a specific port that you want to use, or all ports in a range. , Separate, specified ranges - Separate.

Port multiplexing

Currently in FRPs Vhost_http_port and Vhost_https_port Support configuration into Bind_port For the same port, FRPs will analyze the protocol and deal with it differently.

For example, in some restricted network environment, we can Bind_port and Vhost_https_port Set to 443.

Subsequent attempts will allow multiple proxy to bind different protocols on the same remote port.

TCP multiplexing

From the v0.10.0 version, the connection between the client and the server side supports multiplexing, no longer requires creating a connection for each user request, reducing the delay in connection establishment, and avoiding the occupation of large number of file descriptors, enabling the FRP to carry a higher number of connections.

This function is enabled by default. If you want to close it, it can be configured in frps.ini and frpc.ini. The configuration item must be consistent on both the server side and the client side.

 Wei Frps.ini and frpc.ini
 [common]
 Tcp_mux = false

The underlying communication is optional KCP protocol.

The underlying communication protocol supports the choice of the KCP protocol. The transmission efficiency in the weak network environment is significantly improved, but there will be some additional traffic consumption.

Open KCP protocol support:

  1. Enable KCP protocol support in frps.ini, specify a UDP port to receive client requests:
 Wei Frps.ini
 [common]
 Bind_port = 7000 Wei KCP binding is UDP port, which can be the same as bind_port.
 Kcp_bind_port = 7000
  1. Specify the type of protocol to be used in frpc.ini, and currently support TCP and KCP only. Other agent configurations do not need to be changed:
 Wei Frpc.ini
 [common]
 Server_addr = x.x.x.x Wei Server_port is designated as FRPs's kcp_bind_port.
 Server_port = 7000 Protocol = KCP
  1. Using FRP as before, you need to pay attention to opening access to UDP ports on related machines.

Connection pool

By default, when a user requests a connection, FRPs will ask FRPC to initiate a connection with the back-end service. When the connection pool is set up for the specified agent, FRP will set up a specified number of connections in advance with the back-end service. After receiving the user request every time, a connection and user connection will be taken out from the connection pool to avoid the waiting time to establish connection with the back-end service and the time to transfer control information between FRPC and FRPs.

This function is more suitable for opening a large number of short connection requests.

  1. First, you can set up the upper limit of the connection pool that can be created by each agent in frps.ini and avoid a lot of resource occupation. If client settings exceed this configuration, they will be adjusted to the current value.
 Wei Frps.ini
 [common]
 Max_pool_count = 5
  1. The connection pool is enabled for clients in frpc.ini, and the number of pre created connections is specified.
 Wei Frpc.ini
 [common]
 Pool_count = 1

load balancing

Multiple proxy of the same type can be added to the same group to achieve load balancing function.

At present, TCP and HTTP type proxy are only supported.

 Wei Frpc.ini
 [test1]
 Type = TCP Local_port = 8080 Remote_port = 80 Group = Web Group_key = 123 [test2]
 Type = TCP Local_port = 8081 Remote_port = 80 Group = Web Group_key = 123

Users connect to the 80 port of the FRPs server, and FRPs will distribute the received user connections to one of the surviving proxy randomly. This can be done after a FRPC machine is hung up, and there are still other nodes that can provide services.

TCP type proxy requirements Group_key Same, do permission verification, and Remote_port The same.

HTTP type proxy requirements Group_key, custom_domains or subdomain and locations The same.

Health examination

By adding the function of health check to proxy, the service can be removed from the FRPs when the reverse proxy service fails. It can be used to realize the high availability architecture and avoid the service single point failure with the load balancing function.

Add to each proxy configuration. Health_check_type = {type} To enable health check function.

Type TCP and HTTP are currently available.

If TCP can establish a connection, it thinks the service is normal. HTTP will send a HTTP request, and the status code that the service needs to return to 2XX will be considered normal.

The TCP example is configured as follows:

 Wei Frpc.ini
 [test1]
 Type = TCP Local_port = 22 Remote_port = 6000 Wei Enable health check, type TCP
 Health_check_type = TCP Wei The connection timeout is 3 seconds.
 Health_check_timeout_s = 3 Wei After 3 successive checks, the proxy will be removed.
 Health_check_max_failed = 3 Wei A health check every 10 seconds.
 Health_check_interval_s = 10

The HTTP example is configured as follows:

 Wei Frpc.ini
 [web]
 Type = http Local_ip = 127.0.0.1 Local_port = 80 Custom_domains = test.yourdomain.com Wei Enable health check, type http
 Health_check_type = http Wei The health check sends the URL of the HTTP request, and the backend service needs to return the HTTP status code of 2XX.
 Health_check_url = /status Health_check_interval_s = 10 Health_check_max_failed = 3 Health_check_timeout_s = 3

Modify Host Header

Normally, FRP does not modify any data forwarded. However, there are some back-end services that will display different websites according to the host fields in HTTP request header, such as nginx's virtual host service, and enable host-header modification to dynamically modify host fields in HTTP requests. This function is limited to HTTP type agents.

 Wei Frpc.ini
 [web]
 Type = http Local_port = 80 Custom_domains = test.yourdomain.com Host_header_rewrite = dev.yourdomain.com

The host field in the original HTTP request Test.yourdomain.com Forwarding to the back-end service will be replaced by Dev.yourdomain.com

Set header for HTTP request

about Type = http The proxy can set the header parameters dynamically added in the forwarding.

 Wei Frpc.ini
 [web]
 Type = http Local_port = 80 Custom_domains = test.yourdomain.com Host_header_rewrite = dev.yourdomain.com Header_X-From-Where = FRP

For all parameters in the configuration, Header_ The initial parameters (which support multiple simultaneous configuration) will be added to the header of the HTTP request. According to the above configuration, the header will be added to the request. X-From-Where: FRP

Get user real IP

HTTP X-Forwarded-For

Currently only Http The type of agent supports this function, which can be passed in the header requested by the user. X-Forwarded-For To get the user's real IP, it is enabled by default.

Proxy Protocol

FRP supports adoption. Proxy Protocol The protocol passes the real IP of the request through the FRP proxy. This function supports all types of TCP based protocols, and does not support UDP.

Proxy Protocol After the function is enabled, FRPC will first send a section after establishing a connection with the local service. Proxy Protocol The content of the protocol is local service, and the local service can get the real IP of the user through parsing this content. So it is not just HTTP services, any TCP service, as long as the support of this agreement, you can get the user's real IP address.

It should be noted that if you want to enable this function in the agent configuration, you need local services to support it. Proxy Protocol At present, nginx and haproxy can support this agreement very well.

Take HTTPS type as an example.

 Wei Frpc.ini
 [web]
 Type = HTTPS Local_port = 443 Custom_domains = test.yourdomain.com Wei Currently supports two versions of V1 and V2 proxy protocol protocol.
 Proxy_protocol_version = V2

You only need to add one row to the agent configuration. Proxy_protocol_version = V2 This function can be turned on.

Local HTTPS services can be enabled in the configuration of nginx. Proxy Protocol Parse and set the result in X-Real-IP This Header can be passed in its own Web service. X-Real-IP Get the real IP to the user.

Protect your web service by password

Since all clients share a FRPs HTTP service port, anyone who knows your domain name and URL can access your web services deployed in the intranet. However, in some scenarios, only qualified users can be assured.

FRP supports the use of HTTP Basic Auth to protect your web services, enabling users to access your services through usernames and passwords.

This function is currently limited to HTTP type agents, and the user name and password settings are required in the proxy configuration of FRPC.

 Wei Frpc.ini
 [web]
 Type = http Local_port = 80 Custom_domains = test.yourdomain.com Http_user = ABC Http_pwd = ABC

Browser access Http://test.yourdomain.com You need to enter the configured username and password to access.

Custom two level domain name

When multiple people use a FRPs at the same time, it will be more convenient to use it by customizing the two level domain name.

Configuration in FRPs configuration file Subdomain_host You can enable this feature. After that, it can not be configured in FRPC's HTTP and HTTPS type agents. Custom_domains Instead, configure one. Subdomain Parameters.

Only need to *.{subdomain_host} Resolve to the server where FRPs is located. After that, the user can pass. Subdomain The two level domain name required to use its own web service is passed by itself. {subdomain}.{subdomain_host} To access their web services.

 Wei Frps.ini
 [common]
 Subdomain_host = frps.com

Pan domain name *.frps.com Resolve to the IP address of the server where FRPs is located.

 Wei Frpc.ini
 [web]
 Type = http Local_port = 80 Subdomain = Test

Both FRPs and FRPC have been successful. Test.frps.com You can access the web service of the intranet.

Note: if FRPs is configured Subdomain_host Then Custom_domains China can't belong to it. Subdomain_host Subdomain or pan domain name.

The same HTTP or HTTPS type agent. Custom_domains and Subdomain It can be configured at the same time.

URL routing

FRP supports forwarding to different backend services according to the requested URL path routing.

Through the configuration file Locations Fields specify one or more URL prefixes that proxy can match (currently only supports maximum prefix matching, followed by regular matching). For example, specify Locations = /news All URL will be /news The first request will be forwarded to this service.

 Wei Frpc.ini
 [web01]
 Type = http Local_port = 80 Custom_domains = web.yourdomain.com Locations = / [web02]
 Type = http Local_port = 81 Custom_domains = web.yourdomain.com Locations = /news, /about

Following the configuration of the above example, Web.yourdomain.com The domain name is all /news as well as /about URL requests as prefixes will be forwarded to Web02, and the rest of requests will be forwarded to web01.

Connect FRPs by proxy

Within the environment where agents can only access external networks, FRPC supports communication through HTTP PROXY and FRPs.

By setting up HTTP_PROXY System environment variables or set up in the configuration file of FRPC. Http_proxy Parameters to use this function.

Only in Protocol = TCP It will take effect.

 Wei Frpc.ini
 [common]
 Server_addr = x.x.x.x Server_port = 7000 Http_proxy = http://user:pwd@192.168.1.128:8080

Range port mapping

You can specify multiple ports to be mapped in the configuration file of FRPC, and currently support only the types of TCP and UDP.

This function is passed. Range: The paragraph tag is implemented, the client parses the configuration in the tag, splits it into multiple proxy, and each proxy is named after the number.

For example, to map the 6 ports of local 6000-6005 and 6007, the main configuration is as follows:

 Wei Frpc.ini
 [range:test_tcp]
 Type = TCP Local_ip = 127.0.0.1 Local_port = 6000-60066007 Remote_port = 6000-60066007

After the actual connection is successful, 8 proxy will be created, named Test_tcp_0, test_tcp_1... Test_tcp_7

Plug-in unit

By default, FRPC will only forward requests to local TCP or UDP ports.

The plug-in mode is designed to provide richer functions on the client side. Unix_domain_socket , Http_proxy , Socks5 , Static_file Please see how to use it. Use example

adopt Plugin Specify the plug-ins that need to be used, and the configuration parameters of plug-ins are Plugin_ Start. After using plug-ins Local_ip and Local_port No configuration is required.

Use Http_proxy Examples of plug-ins:

 Wei Frpc.ini
 [http_proxy]
 Type = TCP Remote_port = 6000 Plugin = http_proxy Plugin_http_user = ABC Plugin_http_passwd = ABC

Plugin_http_user and Plugin_http_passwd mean Http_proxy Plugin optional configuration parameters.

Development plan

The functions and optimizations that are planned to be added in subsequent editions will be ranked in a row. Issues Medium feedback.

  • FRPs records the HTTP request log.

Contribute to FRP

FRP is a free and open source project. We welcome anyone to contribute to its development and progress.

  • Any problems that may arise during use may be passed. Issues Feedback.
  • The repair of Bug can be submitted directly to Pull Request to dev branch.
  • If you want to add new features, please create a issue and make a brief description and a general implementation. After the proposal is adopted, you can create a Pull Request that implements the new feature.
  • Welcome to improve the documentation, help more people to use FRP, especially English documents.
  • The contribution code is submitted to the PR to dev branch, and the master branch is only used to issue stable available versions.
  • If you have any other questions, please feel free to answer them. Fatedier@gmail.com Common communication.

Reminder: project related issues are best. Issues In this way, people who have similar problems can quickly find solutions and avoid replying to some questions.

Donation

If you think FRP is helpful to you, you are welcome to give us some donations to maintain the long-term development of the project.

FRP exchange group: 606194980 (QQ group)

Knowledge planet

If you want to learn about FRP related knowledge and technology, or seek any help, you can pay for the official community of knowledge planet by scanning the two-dimensional code below WeChat:

 Zsxq

Alipay scan code donation

 Donate-alipay

WeChat pays donations

 Donate-wechatpay

Paypal donation

Recommended by overseas users Paypal To my account Fatedier@gmail.com Donate.

You can 't perform that action at this time.